pull from remote

Author: Nathan Turinski

src/commands/pickFuncProcess.ts

@@ -21,17 +21,40 @@ import { getWorkspaceSetting } from '../vsCodeConfig/settings';
 const funcTaskReadyEmitter = new vscode.EventEmitter<vscode.WorkspaceFolder>();
 export const onDotnetFuncTaskReady = funcTaskReadyEmitter.event;
 
+/**
+ * Result returned from starting a function host process via the API.
+ */
+export interface IStartFuncProcessResult {
+    /**
+     * The process ID of the started function host.
+     */
+    processId: string;
+    /**
+     * Whether the function host was successfully started.
+     */
+    success: boolean;
+    /**
+     * Error message if the function host failed to start.
+     */
+    error: string;
+    /**
+     * An async iterable stream of terminal output from the function host task.
+     * This stream provides real-time access to the output of the `func host start` command,
+     * allowing consumers to monitor host status, capture logs, and detect errors.
+     * 
+     * The stream will be undefined if the host failed to start or if output streaming is not available.
+     * Consumers should iterate over the stream asynchronously to read output lines as they are produced.
+     * The stream remains active for the lifetime of the function host process.
+     */
+    stream: AsyncIterable<string> | undefined;
+}
+
 export async function startFuncProcessFromApi(
     buildPath: string,
     args: string[],
     env: { [key: string]: string }
-): Promise<{ processId: string; success: boolean; error: string, stream: AsyncIterable<string> | undefined }> {
-    const result: {
-        processId: string;
-        success: boolean;
-        error: string;
-        stream: AsyncIterable<string> | undefined;
-    } = {
+): Promise<IStartFuncProcessResult> {
+    const result: IStartFuncProcessResult = {
         processId: '',
         success: false,
         error: '',

src/debug/FunctionHostDebugView.ts

@@ -92,9 +92,10 @@ export class FuncHostDebugViewProvider implements vscode.TreeDataProvider<FuncHo
                 return getHostErrorTreeItem(element);
             case 'hostTask':
                 return getHostTaskTreeItem(element);
-            default:
-                // Exhaustive check
-                return getNoHostTreeItem();
+            default: {
+                // Exhaustive check: if we reach here, the FuncHostDebugNode union is out of sync with this switch.
+                throw new Error(`Unexpected FuncHostDebugNode kind: ${(element as { kind?: unknown }).kind}`);
+            }
         }
     }
 

src/funcCoreTools/funcHostErrorUtils.ts

@@ -21,7 +21,7 @@ export interface FuncHostErrorContextOptions {
 }
 
 // eslint-disable-next-line no-control-regex
-const redAnsiRegex = /\u001b\[(?:[0-9;]*31m|[0-9;]*91m|38;5;(9|1)m)/;
+const redAnsiRegex = /\u001b\[(?:[0-9;]*31m|[0-9;]*91m)/;
 
 export function isFuncHostErrorLog(log: string): boolean {
     return redAnsiRegex.test(log);

src/funcCoreTools/funcHostTask.ts

@@ -33,6 +33,11 @@ export interface IRunningFuncTask {
      * This avoids repeatedly stealing focus / opening the view for every subsequent error.
      */
     hasReportedLiveErrors?: boolean;
+    /**
+     * AbortController used to signal when the stream iteration should stop.
+     * This prevents the async iteration loop from hanging indefinitely when the task ends.
+     */
+    streamAbortController?: AbortController;
 }
 
 function addErrorLog(task: IRunningFuncTask, rawChunk: string): void {
@@ -189,6 +194,7 @@ export function registerFuncHostTaskEvents(): void {
                 logs,
                 errorLogs: [],
                 hasReportedLiveErrors: false,
+                streamAbortController: new AbortController(),
             };
 
             runningFuncTaskMap.set(e.execution.task.scope, runningFuncTask);
@@ -212,6 +218,13 @@ export function registerFuncHostTaskEvents(): void {
         context.errorHandling.suppressDisplay = true;
         context.telemetry.suppressIfSuccessful = true;
         if (e.execution.task.scope !== undefined && isFuncHostTask(e.execution.task)) {
+            const task = runningFuncTaskMap.get(e.execution.task.scope, (e.execution.task.execution as vscode.ShellExecution).options?.cwd);
+            
+            // Abort the stream iteration to prevent it from hanging indefinitely
+            if (task?.streamAbortController) {
+                task.streamAbortController.abort();
+            }
+            
             runningFuncTaskMap.delete(e.execution.task.scope, (e.execution.task.execution as vscode.ShellExecution).options?.cwd);
 
             runningFuncTasksChangedEmitter.fire();
@@ -233,18 +246,39 @@ export function registerFuncHostTaskEvents(): void {
             return;
         }
 
-        for await (const chunk of task.stream ?? []) {
-            task.logs.push(chunk);
+        const maxLogEntries = 1000;
+
+        try {
+            for await (const chunk of task.stream ?? []) {
+                // Check if the stream iteration should be aborted
+                if (task.streamAbortController?.signal.aborted) {
+                    break;
+                }
 
-            // Keep track of errors for the Debug view.
-            if (isFuncHostErrorLog(chunk)) {
-                const beforeCount = task.errorLogs?.length ?? 0;
-                addErrorLog(task, chunk);
-                const afterCount = task.errorLogs?.length ?? 0;
-                if (afterCount > beforeCount) {
-                    runningFuncTasksChangedEmitter.fire();
+                task.logs.push(chunk);
+                if (task.logs.length > maxLogEntries) {
+                    task.logs.splice(0, task.logs.length - maxLogEntries);
                 }
+
+                // Keep track of errors for the Debug view.
+                if (isFuncHostErrorLog(chunk)) {
+                    const beforeCount = task.errorLogs?.length ?? 0;
+                    addErrorLog(task, chunk);
+                    const afterCount = task.errorLogs?.length ?? 0;
+                    if (afterCount > beforeCount) {
+                        runningFuncTasksChangedEmitter.fire();
+                    }
+                }
+            }
+        } catch (error) {
+            // If the stream encounters an error or is aborted, gracefully exit the loop
+            // This prevents the event handler from hanging indefinitely
+            if (task.streamAbortController?.signal.aborted) {
+                // Expected when the task ends - no need to log
+                return;
             }
+            // Log unexpected errors but don't throw to avoid crashing the extension
+            console.error('Error reading func host task stream:', error);
         }
     });