Refactor into individual tree items

Nathan Turinski · Nathan Turinski · commit ada82e4c1a23 · 2026-03-26T10:16:49.000-07:00
diff --git a/package.json b/package.json
@@ -485,12 +485,6 @@
                 "category": "Azure Functions",
                 "icon": "$(refresh)"
             },
-            {
-                "command": "azureFunctions.funcHostDebug.clearErrors",
-                "title": "%azureFunctions.funcHostDebug.clearErrors%",
-                "category": "Azure Functions",
-                "icon": "$(clear-all)"
-            },
             {
                 "command": "azureFunctions.funcHostDebug.showRecentLogs",
                 "title": "%azureFunctions.funcHostDebug.showRecentLogs%",
@@ -556,11 +550,6 @@
                     "when": "view == azureFunctions.funcHostDebugView",
                     "group": "navigation@1"
                 },
-                {
-                    "command": "azureFunctions.funcHostDebug.clearErrors",
-                    "when": "view == azureFunctions.funcHostDebugView",
-                    "group": "navigation@1"
-                },
                 {
                     "command": "azureFunctions.funcHostDebug.clearStoppedSessions",
                     "when": "view == azureFunctions.funcHostDebugView",
diff --git a/package.nls.json b/package.nls.json
@@ -147,7 +147,6 @@
     "azureFunctions.mcpProjectType.SelfHostedMcpServer": "Runs the Functions host in custom-handler mode, forwarding requests to a self-hosted MCP server process.",
     "azureFunctions.funcHostDebugView.title": "Functions Host Exceptions Debugger",
     "azureFunctions.funcHostDebug.refresh": "Refresh",
-    "azureFunctions.funcHostDebug.clearErrors": "Clear Function Host Errors",
     "azureFunctions.funcHostDebug.showRecentLogs": "Show Recent Host Logs",
     "azureFunctions.funcHostDebug.copyRecentLogs": "Copy Recent Host Logs",
     "azureFunctions.funcHostDebug.askCopilot": "Ask Copilot",
diff --git a/src/debug/FunctionHostDebugView.ts b/src/debug/FunctionHostDebugView.ts
@@ -4,118 +4,18 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { runningFuncTaskMap, stoppedFuncTasks, type IStoppedFuncTask } from '../funcCoreTools/funcHostTask';
-import { localize } from '../localize';
+import { runningFuncTaskMap, stoppedFuncTasks } from '../funcCoreTools/funcHostTask';
+import { HostErrorNode } from './nodes/HostErrorNode';
+import { HostTaskNode } from './nodes/HostTaskNode';
+import { NoHostNode } from './nodes/NoHostNode';
+import { StoppedHostNode } from './nodes/StoppedHostNode';
 
-enum FuncHostDebugContextValue {
-    HostTask = 'azFunc.funcHostDebug.hostTask',
-    StoppedHostTask = 'azFunc.funcHostDebug.stoppedHostTask',
-    HostError = 'azFunc.funcHostDebug.hostError',
-}
-
-type FuncHostDebugNode = INoHostNode | IHostTaskNode | IStoppedHostNode | IHostErrorNode;
+export { getScopeLabel } from './nodes/funcHostDebugUtils';
+export { HostErrorNode } from './nodes/HostErrorNode';
+export { HostTaskNode } from './nodes/HostTaskNode';
+export { StoppedHostNode } from './nodes/StoppedHostNode';
 
-interface INoHostNode {
-    kind: 'noHost';
-}
-
-export interface IHostTaskNode {
-    kind: 'hostTask';
-    workspaceFolder: vscode.WorkspaceFolder | vscode.TaskScope;
-    cwd?: string;
-    portNumber: string;
-    startTime: Date;
-}
-
-export interface IStoppedHostNode {
-    kind: 'stoppedHost';
-    stoppedTask: IStoppedFuncTask;
-}
-
-export interface IHostErrorNode {
-    kind: 'hostError';
-    workspaceFolder: vscode.WorkspaceFolder | vscode.TaskScope;
-    cwd?: string;
-    portNumber: string;
-    message: string;
-}
-
-function formatTimestamp(date: Date): string {
-    return date.toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit', second: '2-digit' });
-}
-
-function buildHostTooltip(opts: { label: string; scopeLabel: string; portNumber: string; startTime: Date; stopTime?: Date; cwd?: string; pid?: number }): vscode.MarkdownString {
-    const tooltip = new vscode.MarkdownString(undefined, true);
-    tooltip.appendMarkdown(`**${opts.label}**\n\n`);
-    tooltip.appendMarkdown(`- ${localize('funcHostDebug.workspace', 'Workspace')}: ${opts.scopeLabel}\n`);
-    if (opts.pid !== undefined) {
-        tooltip.appendMarkdown(`- ${localize('funcHostDebug.pid', 'PID')}: ${opts.pid}\n`);
-    }
-    tooltip.appendMarkdown(`- ${localize('funcHostDebug.port', 'Port')}: ${opts.portNumber}\n`);
-    tooltip.appendMarkdown(`- ${localize('funcHostDebug.started', 'Started')}: ${opts.startTime.toLocaleString()}\n`);
-    if (opts.stopTime) {
-        tooltip.appendMarkdown(`- ${localize('funcHostDebug.stopped', 'Stopped')}: ${opts.stopTime.toLocaleString()}\n`);
-    }
-    if (opts.cwd) {
-        tooltip.appendMarkdown(`- ${localize('funcHostDebug.cwd', 'CWD')}: ${opts.cwd}\n`);
-    }
-    return tooltip;
-}
-
-function getNoHostTreeItem(): vscode.TreeItem {
-    const item = new vscode.TreeItem(localize('funcHostDebug.noneRunning', 'No Function Host task is currently running.'), vscode.TreeItemCollapsibleState.None);
-    item.description = localize('funcHostDebug.startDebuggingHint', 'Start debugging (F5) to launch the host.');
-    item.iconPath = new vscode.ThemeIcon('debug');
-    return item;
-}
-
-function getHostErrorTreeItem(element: IHostErrorNode): vscode.TreeItem {
-    const firstLine = element.message.split(/\r?\n/)[0].trim();
-    const label = firstLine || localize('funcHostDebug.errorDetected', 'Error detected');
-
-    const item = new vscode.TreeItem(label, vscode.TreeItemCollapsibleState.None);
-    item.iconPath = new vscode.ThemeIcon('error');
-    item.tooltip = element.message;
-    item.contextValue = FuncHostDebugContextValue.HostError;
-    return item;
-}
-
-function getHostTaskTreeItem(element: IHostTaskNode): vscode.TreeItem {
-    const task = runningFuncTaskMap.get(element.workspaceFolder, element.cwd);
-    const scopeLabel = typeof element.workspaceFolder === 'object'
-        ? element.workspaceFolder.name
-        : localize('funcHostDebug.globalScope', 'Global');
-
-    const label = `${scopeLabel} (${element.portNumber})`;
-
-    const tooltip = buildHostTooltip({ label, scopeLabel, portNumber: element.portNumber, startTime: element.startTime, cwd: element.cwd, pid: task?.processId });
-
-    const item = new vscode.TreeItem(label, vscode.TreeItemCollapsibleState.Expanded);
-    item.description = formatTimestamp(element.startTime);
-    item.tooltip = tooltip;
-    item.contextValue = FuncHostDebugContextValue.HostTask;
-    item.iconPath = new vscode.ThemeIcon('server-process');
-    return item;
-}
-
-function getStoppedHostTreeItem(element: IStoppedHostNode): vscode.TreeItem {
-    const stopped = element.stoppedTask;
-    const scopeLabel = typeof stopped.workspaceFolder === 'object'
-        ? stopped.workspaceFolder.name
-        : localize('funcHostDebug.globalScope', 'Global');
-
-    const label = `${scopeLabel} (${stopped.portNumber}) — Stopped`;
-
-    const tooltip = buildHostTooltip({ label, scopeLabel, portNumber: stopped.portNumber, startTime: stopped.startTime, stopTime: stopped.stopTime, cwd: stopped.cwd });
-
-    const errorCount = stopped.errorLogs.length;
-    const item = new vscode.TreeItem(label, errorCount > 0 ? vscode.TreeItemCollapsibleState.Expanded : vscode.TreeItemCollapsibleState.None);
-    item.description = `${formatTimestamp(stopped.startTime)} → ${formatTimestamp(stopped.stopTime)}`;
-    item.tooltip = tooltip;
-    item.contextValue = FuncHostDebugContextValue.StoppedHostTask;
-    item.iconPath = new vscode.ThemeIcon('debug-stop', new vscode.ThemeColor('disabledForeground'));
-    return item;
-}
+export type FuncHostDebugNode = NoHostNode | HostTaskNode | StoppedHostNode | HostErrorNode;
 
 export class FuncHostDebugViewProvider implements vscode.TreeDataProvider<FuncHostDebugNode> {
     private readonly _onDidChangeTreeDataEmitter = new vscode.EventEmitter<FuncHostDebugNode | undefined>();
@@ -126,50 +26,12 @@ export class FuncHostDebugViewProvider implements vscode.TreeDataProvider<FuncHo
     }
 
     public getTreeItem(element: FuncHostDebugNode): vscode.TreeItem {
-        switch (element.kind) {
-            case 'noHost':
-                return getNoHostTreeItem();
-            case 'hostError':
-                return getHostErrorTreeItem(element);
-            case 'hostTask':
-                return getHostTaskTreeItem(element);
-            case 'stoppedHost':
-                return getStoppedHostTreeItem(element);
-            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}`);
-            }
-        }
+        return element.getTreeItem();
     }
 
     public async getChildren(element?: FuncHostDebugNode): Promise<FuncHostDebugNode[]> {
-        if (element?.kind === 'hostTask') {
-            const task = runningFuncTaskMap.get(element.workspaceFolder, element.cwd);
-            const errors = task?.errorLogs ?? [];
-            return errors
-                .slice()
-                .reverse()
-                .map((message): IHostErrorNode => ({
-                    kind: 'hostError',
-                    workspaceFolder: element.workspaceFolder,
-                    cwd: element.cwd,
-                    portNumber: element.portNumber,
-                    message,
-                }));
-        } else if (element?.kind === 'stoppedHost') {
-            const stopped = element.stoppedTask;
-            return stopped.errorLogs
-                .slice()
-                .reverse()
-                .map((message): IHostErrorNode => ({
-                    kind: 'hostError',
-                    workspaceFolder: stopped.workspaceFolder,
-                    cwd: stopped.cwd,
-                    portNumber: stopped.portNumber,
-                    message,
-                }));
-        } else if (element) {
-            return [];
+        if (element) {
+            return element.getChildren();
         }
 
         const nodes: FuncHostDebugNode[] = [];
@@ -182,19 +44,19 @@ export class FuncHostDebugViewProvider implements vscode.TreeDataProvider<FuncHo
                     continue;
                 }
                 const cwd = (t.taskExecution.task.execution as vscode.ShellExecution | undefined)?.options?.cwd;
-                nodes.push({ kind: 'hostTask', workspaceFolder: folder, cwd, portNumber: t.portNumber, startTime: t.startTime });
+                nodes.push(new HostTaskNode(folder, t.portNumber, t.startTime, cwd));
                 hasRunning = true;
             }
         }
 
         // Always show the hint node when no host is actively running.
         if (!hasRunning) {
-            nodes.push({ kind: 'noHost' });
+            nodes.push(new NoHostNode());
         }
 
         // Stopped sessions (already newest-first in the array).
         for (const stopped of stoppedFuncTasks) {
-            nodes.push({ kind: 'stoppedHost', stoppedTask: stopped });
+            nodes.push(new StoppedHostNode(stopped));
         }
 
         return nodes;
diff --git a/src/debug/nodes/HostErrorNode.ts b/src/debug/nodes/HostErrorNode.ts
@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import { localize } from '../../localize';
+
+enum FuncHostDebugContextValue {
+    HostError = 'azFunc.funcHostDebug.hostError',
+}
+
+export class HostErrorNode {
+    public readonly kind = 'hostError' as const;
+
+    constructor(
+        public readonly workspaceFolder: vscode.WorkspaceFolder | vscode.TaskScope,
+        public readonly portNumber: string,
+        public readonly message: string,
+        public readonly cwd?: string,
+    ) { }
+
+    public getTreeItem(): vscode.TreeItem {
+        const firstLine = this.message.split(/\r?\n/)[0].trim();
+        const label = firstLine || localize('funcHostDebug.errorDetected', 'Error detected');
+
+        const item = new vscode.TreeItem(label, vscode.TreeItemCollapsibleState.None);
+        item.iconPath = new vscode.ThemeIcon('error');
+        item.tooltip = this.message;
+        item.contextValue = FuncHostDebugContextValue.HostError;
+        return item;
+    }
+
+    public getChildren(): never[] {
+        return [];
+    }
+}
diff --git a/src/debug/nodes/HostTaskNode.ts b/src/debug/nodes/HostTaskNode.ts
@@ -0,0 +1,48 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import { runningFuncTaskMap } from '../../funcCoreTools/funcHostTask';
+import { buildHostTooltip, formatTimestamp, getScopeLabel } from './funcHostDebugUtils';
+import { HostErrorNode } from './HostErrorNode';
+
+enum FuncHostDebugContextValue {
+    HostTask = 'azFunc.funcHostDebug.hostTask',
+}
+
+export class HostTaskNode {
+    public readonly kind = 'hostTask' as const;
+
+    constructor(
+        public readonly workspaceFolder: vscode.WorkspaceFolder | vscode.TaskScope,
+        public readonly portNumber: string,
+        public readonly startTime: Date,
+        public readonly cwd?: string,
+    ) { }
+
+    public getTreeItem(): vscode.TreeItem {
+        const task = runningFuncTaskMap.get(this.workspaceFolder, this.cwd);
+        const scopeLabel = getScopeLabel(this.workspaceFolder);
+        const label = `${scopeLabel} (${this.portNumber})`;
+
+        const tooltip = buildHostTooltip({ label, scopeLabel, portNumber: this.portNumber, startTime: this.startTime, cwd: this.cwd, pid: task?.processId });
+
+        const item = new vscode.TreeItem(label, vscode.TreeItemCollapsibleState.Expanded);
+        item.description = formatTimestamp(this.startTime);
+        item.tooltip = tooltip;
+        item.contextValue = FuncHostDebugContextValue.HostTask;
+        item.iconPath = new vscode.ThemeIcon('server-process');
+        return item;
+    }
+
+    public getChildren(): HostErrorNode[] {
+        const task = runningFuncTaskMap.get(this.workspaceFolder, this.cwd);
+        const errors = task?.errorLogs ?? [];
+        return errors
+            .slice()
+            .reverse()
+            .map((message) => new HostErrorNode(this.workspaceFolder, this.portNumber, message, this.cwd));
+    }
+}
diff --git a/src/debug/nodes/NoHostNode.ts b/src/debug/nodes/NoHostNode.ts
@@ -0,0 +1,22 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import { localize } from '../../localize';
+
+export class NoHostNode {
+    public readonly kind = 'noHost' as const;
+
+    public getTreeItem(): vscode.TreeItem {
+        const item = new vscode.TreeItem(localize('funcHostDebug.noneRunning', 'No Function Host task is currently running.'), vscode.TreeItemCollapsibleState.None);
+        item.description = localize('funcHostDebug.startDebuggingHint', 'Start debugging (F5) to launch the host.');
+        item.iconPath = new vscode.ThemeIcon('debug');
+        return item;
+    }
+
+    public getChildren(): never[] {
+        return [];
+    }
+}
diff --git a/src/debug/nodes/StoppedHostNode.ts b/src/debug/nodes/StoppedHostNode.ts
@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import { type IStoppedFuncTask } from '../../funcCoreTools/funcHostTask';
+import { buildHostTooltip, formatTimestamp, getScopeLabel } from './funcHostDebugUtils';
+import { HostErrorNode } from './HostErrorNode';
+
+enum FuncHostDebugContextValue {
+    StoppedHostTask = 'azFunc.funcHostDebug.stoppedHostTask',
+}
+
+export class StoppedHostNode {
+    public readonly kind = 'stoppedHost' as const;
+
+    constructor(public readonly stoppedTask: IStoppedFuncTask) { }
+
+    public getTreeItem(): vscode.TreeItem {
+        const stopped = this.stoppedTask;
+        const scopeLabel = getScopeLabel(stopped.workspaceFolder);
+        const label = `${scopeLabel} (${stopped.portNumber}) — Stopped`;
+
+        const tooltip = buildHostTooltip({ label, scopeLabel, portNumber: stopped.portNumber, startTime: stopped.startTime, stopTime: stopped.stopTime, cwd: stopped.cwd });
+
+        const errorCount = stopped.errorLogs.length;
+        const item = new vscode.TreeItem(label, errorCount > 0 ? vscode.TreeItemCollapsibleState.Expanded : vscode.TreeItemCollapsibleState.None);
+        item.description = `${formatTimestamp(stopped.startTime)} → ${formatTimestamp(stopped.stopTime)}`;
+        item.tooltip = tooltip;
+        item.contextValue = FuncHostDebugContextValue.StoppedHostTask;
+        item.iconPath = new vscode.ThemeIcon('debug-stop', new vscode.ThemeColor('disabledForeground'));
+        return item;
+    }
+
+    public getChildren(): HostErrorNode[] {
+        const stopped = this.stoppedTask;
+        return stopped.errorLogs
+            .slice()
+            .reverse()
+            .map((message) => new HostErrorNode(stopped.workspaceFolder, stopped.portNumber, message, stopped.cwd));
+    }
+}
diff --git a/src/debug/nodes/funcHostDebugUtils.ts b/src/debug/nodes/funcHostDebugUtils.ts
diff --git a/src/debug/registerFunctionHostDebugView.ts b/src/debug/registerFunctionHostDebugView.ts
