Fix duplicate log entries, fix func start tasks with args not being recognized

Author: Nathan Turinski

src/funcCoreTools/funcHostErrorUtils.ts

@@ -5,6 +5,22 @@
 
 import { stripAnsiControlCharacters } from '../utils/ansiUtils';
 
+/**
+ * Regex that matches a Functions-host timestamp prefix, e.g. `[2026-03-11T19:57:44.622Z]`.
+ * Used to split raw terminal chunks into logical log entries.
+ */
+const funcHostTimestampRegex = /(?=\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d+Z\])/;
+
+/**
+ * Collapse all whitespace runs to a single space for dedup comparison.
+ * Terminal reflow wraps the same logical message at different column positions
+ * depending on window width, producing different newline/space patterns for
+ * an otherwise identical log entry.
+ */
+function normalizeWhitespace(text: string): string {
+    return text.replace(/\s+/g, ' ').trim();
+}
+
 export interface FuncHostErrorContextOptions {
     /**
      * Number of log lines to include before an error line
@@ -20,11 +36,64 @@ export interface FuncHostErrorContextOptions {
     max?: number;
 }
 
+// Detect red/bright-red foreground in any of the common SGR forms:
+//   Basic 4-bit:    \x1b[31m  (red)  /  \x1b[91m  (bright red), with optional extra params
+//   256-color:      \x1b[38;5;1m (red) / \x1b[38;5;9m (bright red)
+//   24-bit RGB:     \x1b[38;2;R;G;Bm  where R is dominant (R≥128, G≤64, B≤64)
+// eslint-disable-next-line no-control-regex
+const basicRedRegex = /\u001b\[(?:(?:\d+;)*(?:31|91)(?:;\d+)*m)/;
 // eslint-disable-next-line no-control-regex
-const redAnsiRegex = /\u001b\[(?:[0-9;]*31m|[0-9;]*91m)/;
+const extended256RedRegex = /\u001b\[38;5;(?:1|9)m/;
+
+function isRedAnsi(text: string): boolean {
+    return basicRedRegex.test(text) || extended256RedRegex.test(text);
+}
 
 export function isFuncHostErrorLog(log: string): boolean {
-    return redAnsiRegex.test(log);
+    return isRedAnsi(log);
+}
+
+/**
+ * Splits a raw terminal chunk into logical log entries (by timestamp boundaries),
+ * checks each entry for red ANSI codes, and appends only genuinely new error
+ * entries to the given errorLogs array.
+ *
+ * @param errorLogs The mutable array of plain-text error strings to append to.
+ * @param rawChunk  A raw terminal output chunk (may contain ANSI + multiple log entries).
+ * @returns `true` if at least one new error entry was added.
+ */
+export function addErrorLinesFromChunk(errorLogs: string[], rawChunk: string): boolean {
+    const seen = new Set(errorLogs.map(normalizeWhitespace));
+    let added = false;
+
+    // Split on timestamp boundaries so each segment is a complete log entry.
+    for (const segment of rawChunk.split(funcHostTimestampRegex)) {
+        if (!isFuncHostErrorLog(segment)) {
+            continue;
+        }
+
+        const plain = stripAnsiControlCharacters(segment).trim();
+        if (!plain) {
+            continue;
+        }
+
+        const normalized = normalizeWhitespace(plain);
+        if (seen.has(normalized)) {
+            continue;
+        }
+
+        seen.add(normalized);
+        errorLogs.push(plain);
+        added = true;
+    }
+
+    // Keep the most recent few to avoid unbounded memory usage.
+    const maxErrors = 10;
+    if (errorLogs.length > maxErrors) {
+        errorLogs.splice(0, errorLogs.length - maxErrors);
+    }
+
+    return added;
 }
 
 /**

src/funcCoreTools/funcHostTask.ts

@@ -11,10 +11,9 @@ import { tryGetFunctionProjectRoot } from '../commands/createNewProject/verifyIs
 import { localSettingsFileName } from '../constants';
 import { getLocalSettingsJson } from '../funcConfig/local.settings';
 import { localize } from '../localize';
-import { stripAnsiControlCharacters } from '../utils/ansiUtils';
 import { cpUtils } from '../utils/cpUtils';
 import { getWorkspaceSetting } from '../vsCodeConfig/settings';
-import { isFuncHostErrorLog } from './funcHostErrorUtils';
+import { addErrorLinesFromChunk } from './funcHostErrorUtils';
 
 export interface IRunningFuncTask {
     taskExecution: vscode.TaskExecution;
@@ -40,26 +39,6 @@ export interface IRunningFuncTask {
     streamAbortController?: AbortController;
 }
 
-function addErrorLog(task: IRunningFuncTask, rawChunk: string): void {
-    const plain = stripAnsiControlCharacters(rawChunk).trim();
-    if (!plain) {
-        return;
-    }
-
-    const arr = task.errorLogs ?? (task.errorLogs = []);
-    if (arr[arr.length - 1] === plain) {
-        return;
-    }
-
-    arr.push(plain);
-
-    // Keep the most recent few to avoid unbounded memory usage.
-    const maxErrors = 10;
-    if (arr.length > maxErrors) {
-        task.errorLogs = arr.slice(arr.length - maxErrors);
-    }
-}
-
 export interface IRunningFuncTaskWithScope {
     scope: vscode.WorkspaceFolder | vscode.TaskScope;
     task: IRunningFuncTask;
@@ -90,8 +69,14 @@ class RunningFunctionTaskMap {
             const taskExecution = t.taskExecution.task.execution as vscode.ShellExecution;
             // the cwd will include ${workspaceFolder} from our tasks.json so we need to replace it with the actual path
             const taskDirectory = taskExecution.options?.cwd?.replace('${workspaceFolder}', (t.taskExecution.task?.scope as vscode.WorkspaceFolder).uri?.path);
-            buildPath = buildPath?.replace('${workspaceFolder}', (t.taskExecution.task?.scope as vscode.WorkspaceFolder).uri?.path);
-            return taskDirectory && buildPath && normalizePath(taskDirectory) === normalizePath(buildPath);
+            const resolvedBuildPath = buildPath?.replace('${workspaceFolder}', (t.taskExecution.task?.scope as vscode.WorkspaceFolder).uri?.path);
+
+            // When neither cwd is set, both tasks use the default working directory — treat as a match
+            if (!taskDirectory && !resolvedBuildPath) {
+                return true;
+            }
+
+            return taskDirectory && resolvedBuildPath && normalizePath(taskDirectory) === normalizePath(resolvedBuildPath);
         });
     }
 
@@ -157,8 +142,25 @@ const defaultFuncPort: string = '7071';
 
 const funcCommandRegex: RegExp = /(func(?:\.exe)?)\s+host\s+start/i;
 export function isFuncHostTask(task: vscode.Task): boolean {
-    const commandLine: string | undefined = task.execution && (<vscode.ShellExecution>task.execution).commandLine;
-    return funcCommandRegex.test(commandLine || '');
+    const execution = task.execution as vscode.ShellExecution | undefined;
+    if (!execution) {
+        return false;
+    }
+
+    // String-based ShellExecution: `commandLine` contains the full command
+    if (execution.commandLine) {
+        return funcCommandRegex.test(execution.commandLine);
+    }
+
+    // Args-based ShellExecution: `command` + `args` are separate
+    // Reconstruct the command string to test against the regex
+    const command = typeof execution.command === 'string' ? execution.command : execution.command?.value;
+    if (command && execution.args) {
+        const argsStr = execution.args.map(a => typeof a === 'string' ? a : a.value).join(' ');
+        return funcCommandRegex.test(`${command} ${argsStr}`);
+    }
+
+    return false;
 }
 
 export function isFuncShellEvent(event: vscode.TerminalShellExecutionStartEvent): boolean {
@@ -219,12 +221,12 @@ export function registerFuncHostTaskEvents(): void {
         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();
@@ -260,14 +262,11 @@ export function registerFuncHostTaskEvents(): void {
                     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();
-                    }
+                // Split chunk into log entries by timestamp, check each for red
+                // ANSI, and deduplicate against existing errors.
+                const errorArr = task.errorLogs ?? (task.errorLogs = []);
+                if (addErrorLinesFromChunk(errorArr, chunk)) {
+                    runningFuncTasksChangedEmitter.fire();
                 }
             }
         } catch (error) {
@@ -319,7 +318,7 @@ export async function stopFuncTaskIfRunning(workspaceFolder: vscode.WorkspaceFol
 
     if (runningFuncTask !== undefined && runningFuncTask.length > 0) {
         for (const runningFuncTaskItem of runningFuncTask) {
-            if (!runningFuncTaskItem) {break;}
+            if (!runningFuncTaskItem) { break; }
             if (terminate) {
                 runningFuncTaskItem.taskExecution.terminate();
             } else {