Implementation for debug-isolated flag and streaming func CLI output

package.json

@@ -990,6 +990,12 @@
                 "properties": {
                     "command": {
                         "type": "string"
+                    },
+                    "args": {
+                        "type": "array",
+                        "items": {
+                            "type": "string"
+                        }
                     }
                 }
             }

src/commands/CommandAttributes.ts

@@ -31,4 +31,12 @@ export class CommandAttributes {
         ],
     };
 
+    static readonly Debug: ActivityAttributes = {
+        description: "Starts the Azure Functions host in debug mode, allowing you to set breakpoints and step through your function code locally using a debugger.",
+        troubleshooting: [
+            "Function host fails to start — check the output logs for errors related to your function code or configuration.",
+            "Breakpoints are not being hit — ensure that the debugger is properly attached and that you're running the function host in debug mode.",
+            "Port conflicts — verify that the ports required for debugging (e.g., 9229 for Node.js) are not being used by other applications.",
+        ],
+    };
 }

src/commands/debug/PostFuncDebugExecuteStep.ts

@@ -0,0 +1,70 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ActivityChildItem, ActivityChildType, activityInfoContext, AzureWizardExecuteStep, createContextValue, randomUtils, type ExecuteActivityContext, type ExecuteActivityOutput, type IActionContext } from "@microsoft/vscode-azext-utils";
+import { stripVTControlCharacters } from "node:util";
+import { ThemeIcon } from "vscode";
+
+export class PostFuncDebugExecuteStep<T extends IActionContext & ExecuteActivityContext> extends AzureWizardExecuteStep<T> {
+    public priority: number = 999;
+    public stepName: string = 'PostFuncDebugExecuteStep';
+    // public options: AzureWizardExecuteStepOptions = {
+    //     continueOnFail: true
+    // }
+
+    public constructor(readonly logs: string[]) {
+        super();
+    }
+
+    public async execute(context: T): Promise<void> {
+        const errorLogs: string[] = [];
+        // eslint-disable-next-line no-control-regex
+        const redAnsiRegex = /\x1b\[(?:[0-9;]*31m|[0-9;]*91m|38;5;(9|1)m)/;
+        const functionErrors = [
+            /No job functions found/i,
+            /Worker was unable to load entry point/i,
+            /SyntaxError:/i,
+            /Cannot find module/i,
+            /Failed to start Worker Channel/i,
+            /Serialization and deserialization.*not supported/i
+        ];
+        for (const log of this.logs) {
+            if (redAnsiRegex.test(log) || functionErrors.some(err => err.test(log))) {
+                errorLogs.push(log);
+            }
+        }
+
+        if (errorLogs.length > 0) {
+            context.activityAttributes = context.activityAttributes || {};
+            context.activityAttributes.logs = errorLogs.map(log => { return { content: stripVTControlCharacters(log) }; });
+            context.activityChildren = [];
+            throw new Error('This is from the error in execute');
+        }
+
+        return;
+    }
+
+    public shouldExecute(_context: T): boolean {
+        return true;
+    }
+
+    public createFailOutput(_context: T): ExecuteActivityOutput {
+        return {
+            item: new ActivityChildItem({
+                label: 'Click to have Copilot help diagnose the issue.',
+                id: `${randomUtils.getRandomHexString(8)}-terminateDebugSession-fail`,
+                activityType: ActivityChildType.Fail,
+                contextValue: createContextValue([activityInfoContext, 'terminateDebugSessionFail']),
+                iconPath: new ThemeIcon('sparkle'),
+                // a little trick to remove the description timer on activity children
+                description: ' ',
+                command: {
+                    "command": "azureResourceGroups.askAgentAboutActivityLogItem",
+                    "title": "Ask Copilot",
+                }
+            })
+        };
+    }
+}

src/commands/pickFuncProcess.ts

@@ -20,16 +20,25 @@ import { getWorkspaceSetting } from '../vsCodeConfig/settings';
 
 const funcTaskReadyEmitter = new vscode.EventEmitter<vscode.WorkspaceFolder>();
 export const onDotnetFuncTaskReady = funcTaskReadyEmitter.event;
+// flag used by func core tools to indicate to wait for the debugger to attach before starting the worker
+const dotnetIsolatedDebugFlag = '--dotnet-isolated-debug';
+const enableJsonOutput = '--enable-json-output';
 
 export async function startFuncProcessFromApi(
     buildPath: string,
     args: string[],
     env: { [key: string]: string }
-): Promise<{ processId: string; success: boolean; error: string }> {
-    const result = {
+): Promise<{ processId: string; success: boolean; error: string, stream: AsyncIterable<string> | undefined }> {
+    const result: {
+        processId: string;
+        success: boolean;
+        error: string;
+        stream: AsyncIterable<string> | undefined;
+    } = {
         processId: '',
         success: false,
-        error: ''
+        error: '',
+        stream: undefined
     };
 
     let funcHostStartCmd: string = 'func host start';
@@ -66,6 +75,7 @@ export async function startFuncProcessFromApi(
             const taskInfo = await startFuncTask(context, workspaceFolder, buildPath, funcTask);
             result.processId = await pickChildProcess(taskInfo);
             result.success = true;
+            result.stream = taskInfo.stream;
         } catch (err) {
             const pError = parseError(err);
             result.error = pError.message;
@@ -140,34 +150,48 @@ async function startFuncTask(context: IActionContext, workspaceFolder: vscode.Wo
         const funcPort: string = await getFuncPortFromTaskOrProject(context, funcTask, workspaceFolder);
         let statusRequestTimeout: number = intervalMs;
         const maxTime: number = Date.now() + timeoutInSeconds * 1000;
+        const funcShellExecution = funcTask.execution as vscode.ShellExecution;
+        const debugModeOn = funcShellExecution.commandLine?.includes(dotnetIsolatedDebugFlag) && funcShellExecution.commandLine?.includes(enableJsonOutput);
+
         while (Date.now() < maxTime) {
             if (taskError !== undefined) {
                 throw taskError;
             }
 
             const taskInfo: IRunningFuncTask | undefined = runningFuncTaskMap.get(workspaceFolder, buildPath);
             if (taskInfo) {
-                for (const scheme of ['http', 'https']) {
-                    const statusRequest: AzExtRequestPrepareOptions = { url: `${scheme}://localhost:${funcPort}/admin/host/status`, method: 'GET' };
-                    if (scheme === 'https') {
-                        statusRequest.rejectUnauthorized = false;
+                if (debugModeOn) {
+                    // if we are in dotnet isolated debug mode, we need to find the pid from the terminal output
+                    // if there is no pid yet, keep waiting
+                    const newPid = await getWorkerPidFromJsonOutput(taskInfo);
+                    if (newPid) {
+                        taskInfo.processId = newPid;
+                        return taskInfo;
                     }
-
-                    try {
-                        // wait for status url to indicate functions host is running
-                        const response = await sendRequestWithTimeout(context, statusRequest, statusRequestTimeout, undefined);
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-                        if (response.parsedBody.state.toLowerCase() === 'running') {
-                            funcTaskReadyEmitter.fire(workspaceFolder);
-                            return taskInfo;
+                } else {
+                    // otherwise, we have to wait for the status url to indicate the host is running
+                    for (const scheme of ['http', 'https']) {
+                        const statusRequest: AzExtRequestPrepareOptions = { url: `${scheme}://localhost:${funcPort}/admin/host/status`, method: 'GET' };
+                        if (scheme === 'https') {
+                            statusRequest.rejectUnauthorized = false;
                         }
-                    } catch (error) {
-                        if (requestUtils.isTimeoutError(error)) {
-                            // Timeout likely means localhost isn't ready yet, but we'll increase the timeout each time it fails just in case it's a slow computer that can't handle a request that fast
-                            statusRequestTimeout *= 2;
-                            context.telemetry.measurements.maxStatusTimeout = statusRequestTimeout;
-                        } else {
-                            // ignore
+
+                        try {
+                            // wait for status url to indicate functions host is running
+                            const response = await sendRequestWithTimeout(context, statusRequest, statusRequestTimeout, undefined);
+                            // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+                            if (response.parsedBody.state.toLowerCase() === 'running') {
+                                funcTaskReadyEmitter.fire(workspaceFolder);
+                                return taskInfo;
+                            }
+                        } catch (error) {
+                            if (requestUtils.isTimeoutError(error)) {
+                                // Timeout likely means localhost isn't ready yet, but we'll increase the timeout each time it fails just in case it's a slow computer that can't handle a request that fast
+                                statusRequestTimeout *= 2;
+                                context.telemetry.measurements.maxStatusTimeout = statusRequestTimeout;
+                            } else {
+                                // ignore
+                            }
                         }
                     }
                 }
@@ -182,6 +206,23 @@ async function startFuncTask(context: IActionContext, workspaceFolder: vscode.Wo
     }
 }
 
+async function getWorkerPidFromJsonOutput(taskInfo: IRunningFuncTask): Promise<number | undefined> {
+    // if there is no stream yet or if the output doesn't include the workerProcessId yet, then keep waiting
+    if (!taskInfo.stream) {
+        return;
+    }
+
+    for await (const chunk of taskInfo.stream) {
+        if (chunk.includes(`{ "name":"dotnet-worker-startup", "workerProcessId" :`)) {
+            const matches = chunk.match(/"workerProcessId"\s*:\s*(\d+)/);
+            if (matches && matches.length > 1) {
+                return Number(matches[1]);
+            }
+        }
+    }
+    return;
+}
+
 type OSAgnosticProcess = { command: string | undefined; pid: number | string };
 
 /**

src/debug/FuncTaskProvider.ts

@@ -104,6 +104,11 @@ export class FuncTaskProvider implements TaskProvider {
 
     private async createTask(context: IActionContext, command: string, folder: WorkspaceFolder, projectRoot: string | undefined, language: string | undefined, definition?: TaskDefinition): Promise<Task> {
         const funcCliPath = await getFuncCliPath(context, folder);
+        const args = (definition?.args || []) as string[];
+        if (args.length > 0) {
+            command = `${command} ${args.join(' ')}`;
+        }
+
         let commandLine: string = `${funcCliPath} ${command}`;
         if (language === ProjectLanguage.Python) {
             commandLine = venvUtils.convertToVenvCommand(commandLine, folder.uri.fsPath);