feat(extension): add attach-to-process command

Author: govert

README.md

@@ -131,6 +131,7 @@ If you have multiple solutions, use the Command Palette action **"VB.NET: Select
 For diagnostics, use **"VB.NET: Show Logs"** and **"VB.NET: Toggle LSP Trace"**.
 If assets are missing, run **"VB.NET: Restore Workspace"** or **"VB.NET: Restore Project"**.
 To force a reanalysis without restarting VS Code, use **"VB.NET: Reload Workspace"**.
+For attaching to a running .NET process, use **"VB.NET: Attach Debugger to Process"**.
 
 ## Architecture
 

docs/configuration.md

@@ -31,6 +31,7 @@ Last Updated: 2026-01-20
 - **`VB.NET: Restore Workspace`** — runs `dotnet restore` using the selected solution (or workspace root).
 - **`VB.NET: Restore Project`** — picks a `.vbproj` file and runs `dotnet restore` for it.
 - **`VB.NET: Reload Workspace`** — requests a workspace reload without restarting the extension.
+- **`VB.NET: Attach Debugger to Process`** — picks a running process and starts an attach session.
 
 ### Explorer File Nesting Defaults
 

src/extension/package.json

@@ -247,6 +247,11 @@
         "title": "Reload VB.NET Workspace",
         "category": "VB.NET"
       },
+      {
+        "command": "vbnet.attachToProcess",
+        "title": "Attach VB.NET Debugger to Process",
+        "category": "VB.NET"
+      },
       {
         "command": "vbnet.showOutputChannel",
         "title": "Show VB.NET Output",
@@ -384,6 +389,20 @@
               "stopAtEntry": false
             }
           },
+          {
+            "label": "VB.NET: Launch (projectPath inference)",
+            "description": "Launch using projectPath and let the extension infer the program.",
+            "body": {
+              "name": "VB.NET Launch (projectPath)",
+              "type": "vbnet",
+              "request": "launch",
+              "projectPath": "${workspaceFolder}/YourProject.vbproj",
+              "args": [],
+              "cwd": "${workspaceFolder}",
+              "console": "internalConsole",
+              "stopAtEntry": false
+            }
+          },
           {
             "label": "VB.NET: Attach (netcoredbg)",
             "description": "Attach netcoredbg to a running .NET process.",

src/extension/src/extension.ts

@@ -259,6 +259,18 @@ function registerCommands(context: vscode.ExtensionContext): void {
             }
         })
     );
+
+    context.subscriptions.push(
+        vscode.commands.registerCommand('vbnet.attachToProcess', async () => {
+            try {
+                await attachToProcess();
+            } catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                outputChannel?.appendLine(`Failed to attach to process: ${message}`);
+                vscode.window.showErrorMessage(`Failed to attach to process: ${message}`);
+            }
+        })
+    );
 }
 
 interface SolutionPickItem extends vscode.QuickPickItem {
@@ -270,6 +282,16 @@ interface ProjectPickItem extends vscode.QuickPickItem {
     projectPath: string;
 }
 
+interface ProcessInfo {
+    pid: number;
+    name: string;
+    commandLine?: string;
+}
+
+interface ProcessPickItem extends vscode.QuickPickItem {
+    pid: number;
+}
+
 async function selectWorkspaceSolution(): Promise<void> {
     const workspaceFolders = vscode.workspace.workspaceFolders;
     if (!workspaceFolders || workspaceFolders.length === 0) {
@@ -567,6 +589,122 @@ function fsPathExists(filePath: string): boolean {
     }
 }
 
+async function attachToProcess(): Promise<void> {
+    const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+    const processes = await listProcesses();
+
+    if (processes.length === 0) {
+        vscode.window.showInformationMessage('No running processes found.');
+        return;
+    }
+
+    processes.sort((a, b) => {
+        const nameCompare = a.name.localeCompare(b.name);
+        if (nameCompare !== 0) {
+            return nameCompare;
+        }
+        return a.pid - b.pid;
+    });
+
+    const items: ProcessPickItem[] = processes.map((proc) => ({
+        label: `${proc.name} (${proc.pid})`,
+        description: proc.commandLine,
+        pid: proc.pid
+    }));
+
+    const pick = await vscode.window.showQuickPick(items, {
+        placeHolder: 'Select a process to attach netcoredbg',
+        matchOnDescription: true
+    });
+
+    if (!pick) {
+        return;
+    }
+
+    const attachConfig: vscode.DebugConfiguration = {
+        name: `VB.NET Attach (${pick.pid})`,
+        type: 'vbnet',
+        request: 'attach',
+        processId: pick.pid
+    };
+
+    const started = await vscode.debug.startDebugging(workspaceFolder, attachConfig);
+    if (!started) {
+        vscode.window.showErrorMessage('Failed to start VB.NET attach session.');
+    }
+}
+
+async function listProcesses(): Promise<ProcessInfo[]> {
+    if (process.platform === 'win32') {
+        return await listWindowsProcesses();
+    }
+
+    return await listUnixProcesses();
+}
+
+async function listWindowsProcesses(): Promise<ProcessInfo[]> {
+    const output = await execCommand('tasklist', ['/FO', 'CSV', '/NH']);
+    const lines = output.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+    const results: ProcessInfo[] = [];
+
+    for (const line of lines) {
+        const values = line.split('","').map((value) => value.replace(/^"|"$/g, ''));
+        if (values.length < 2) {
+            continue;
+        }
+        const pid = Number.parseInt(values[1], 10);
+        if (Number.isNaN(pid)) {
+            continue;
+        }
+        results.push({
+            pid,
+            name: values[0],
+            commandLine: values[0]
+        });
+    }
+
+    return results;
+}
+
+async function listUnixProcesses(): Promise<ProcessInfo[]> {
+    const output = await execCommand('ps', ['-ax', '-o', 'pid=,comm=,args=']);
+    const lines = output.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+    const results: ProcessInfo[] = [];
+
+    for (const line of lines) {
+        const match = line.match(/^(\d+)\s+(\S+)\s*(.*)$/);
+        if (!match) {
+            continue;
+        }
+        const pid = Number.parseInt(match[1], 10);
+        if (Number.isNaN(pid)) {
+            continue;
+        }
+        results.push({
+            pid,
+            name: match[2],
+            commandLine: match[3]
+        });
+    }
+
+    return results;
+}
+
+async function execCommand(command: string, args: string[]): Promise<string> {
+    return await new Promise((resolve, reject) => {
+        cp.execFile(command, args, { encoding: 'utf8' }, (error, stdout, stderr) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            if (stderr) {
+                outputChannel?.appendLine(stderr.trim());
+            }
+            resolve(stdout ?? '');
+        });
+    });
+}
+
 /**
  * Extension deactivation.
  * Called when the extension is deactivated.

test-explore/TEST_RESULTS.md

@@ -47,6 +47,16 @@ Optional flags:
 
 ## Recent runs
 
+### 2026-01-22 — VS Code harness (VB.NET server, attach command)
+
+Command:
+- `cd test-explore\\clients\\vscode; npm test`
+
+Outcome: PASS (14 passing, 5 pending; non-fatal DAP warnings)
+Notes:
+- DAP warnings: `Failed command 'threads' : 0x80004005`.
+- DAP trace: `test-explore/clients/vscode/logs/dap-trace-2026-01-22T202246021Z.log`.
+
 ### 2026-01-22 — VS Code harness (VB.NET server, reload command)
 
 Command:

test-explore/clients/vscode/src/suite/vbnet-extension.test.ts

@@ -280,6 +280,7 @@ if (skipVbnetSmoke) {
             assert.ok(commands.includes("vbnet.restoreWorkspace"), "Restore workspace command not registered.");
             assert.ok(commands.includes("vbnet.restoreProject"), "Restore project command not registered.");
             assert.ok(commands.includes("vbnet.reloadWorkspace"), "Reload workspace command not registered.");
+            assert.ok(commands.includes("vbnet.attachToProcess"), "Attach to process command not registered.");
             await config.update("trace.server", "verbose", vscode.ConfigurationTarget.Workspace);
             await config.update("server.transportType", "namedPipe", vscode.ConfigurationTarget.Workspace);
 

test/VbNet.Extension.Tests.Vb/ExtensionManifestTests.vb

@@ -71,7 +71,8 @@ Namespace VbNet.Extension.Tests
                 "vbnet.toggleLspTrace",
                 "vbnet.restoreWorkspace",
                 "vbnet.restoreProject",
-                "vbnet.reloadWorkspace"
+                "vbnet.reloadWorkspace",
+                "vbnet.attachToProcess"
             }
 
             For Each commandName In required