Host MCP server in-process with auto-config and release workflow

- Embed MCP server directly in the extension using Streamable HTTP transport
  at /mcp, eliminating the need for a separate stdio proxy process
- Auto-update ~/.claude.json on activation for zero-config Claude Code setup
- Add sidebar panel showing server status, port, and Claude config state
- Add IDebugClient interface so tools work with both in-process and stdio paths
- Add GitHub Actions workflow to build .vsix and create releases on tag push
- Bump version to 0.2.0

Author: TristanSpeakEasy

.github/workflows/release.yml

@@ -0,0 +1,25 @@
+name: Release
+
+on:
+  push:
+    tags: ['v*']
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+      - run: npm ci
+      - run: npm run package
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: '*.vsix'
+          generate_release_notes: true

.gitignore

@@ -1,3 +1,4 @@
 node_modules/
 dist/
 .vscode-test/
+*.vsix

README.md

@@ -6,41 +6,38 @@ A VS Code extension that exposes an MCP (Model Context Protocol) server, allowin
 
 - **22 MCP tools** for full debugger control
 - **Works with any debugger** that implements the Debug Adapter Protocol
+- **Zero-config for Claude Code** — auto-updates `~/.claude.json` on activation
 - **Execution commands block until the debugger stops** and return the stop location + local variables in a single response
 - **Captures program output** (stdout/stderr) for inspection
-- **Multi-window support** — each VS Code window runs its own bridge
 
 ## Architecture
 
 ```
-Claude Code CLI / Desktop
-       |  (stdio: JSON-RPC)
+Claude Code / Desktop / any MCP client
+       |  (HTTP: Streamable HTTP transport)
        v
-MCP Server Process (dist/mcp-server.js)
-       |  (HTTP to localhost:<port>)
-       v
-VS Code Extension (dist/extension.js)
+VS Code Extension (MCP server on localhost:<port>/mcp)
        |  (vscode.debug.* API)
        v
 Debug Adapter Protocol → Any Debugger
 ```
 
-The extension starts a localhost HTTP server on a random port with a random auth token, and writes both to a temporary port file. The MCP server (spawned by the AI client via stdio) reads this file to communicate with the extension.
+The extension hosts the MCP server directly inside the VS Code process — no separate server or sidecar needed. On activation it starts a localhost HTTP server (default port `45557`) and automatically writes the connection URL to `~/.claude.json`.
 
 ## Installation
 
 This extension is not yet published to the VS Code Marketplace. Install it manually from the `.vsix` file.
 
 ### 1. Download the `.vsix`
 
-Download `vscode-debugger-mcp-0.1.0.vsix` from this repository (it's in the repo root).
+Download `vscode-debugger-mcp-0.2.0.vsix` from this repository (it's in the repo root).
 
 ### 2. Install in VS Code
 
 **Option A — Command line:**
 
 ```bash
-code --install-extension vscode-debugger-mcp-0.1.0.vsix
+code --install-extension vscode-debugger-mcp-0.2.0.vsix
 ```
 
 **Option B — VS Code UI:**
@@ -53,7 +50,7 @@ code --install-extension vscode-debugger-mcp-0.1.0.vsix
 
 ### 3. Reload VS Code
 
-After installation, reload the window (`Ctrl+Shift+P` / `Cmd+Shift+P` → **Developer: Reload Window**). The extension activates automatically on startup.
+After installation, reload the window (`Ctrl+Shift+P` / `Cmd+Shift+P` → **Developer: Reload Window**). The extension activates automatically on startup and the MCP server begins listening.
 
 ### From source (development)
 
@@ -68,30 +65,22 @@ Then press `F5` in VS Code to launch the Extension Development Host.
 
 ## MCP Client Configuration
 
-After installing the `.vsix`, the MCP server script is located inside the installed extension directory. The path depends on your setup:
+### Claude Code (zero-config)
 
-| Setup | Extensions path |
-|-------|----------------|
-| VS Code (local) | `~/.vscode/extensions/` |
-| VS Code Remote / WSL | `~/.vscode-server/extensions/` |
-| Windows (local) | `%USERPROFILE%\.vscode\extensions\` |
+The extension automatically registers itself in `~/.claude.json` on activation. **No manual setup needed** — just install the extension, reload VS Code, and start using Claude Code.
 
-The full path to the MCP server will be:
+To verify it's configured, run:
 
-```
-<extensions-path>/debugger-mcp.vscode-debugger-mcp-0.1.0/dist/mcp-server.js
+```bash
+claude mcp list
 ```
 
-Use this path when configuring your MCP client below.
+You should see `vscode-debugger` listed as an HTTP server.
 
-### Claude Code
+If you prefer to configure manually, or if auto-config is disabled:
 
 ```bash
-# Local VS Code
-claude mcp add vscode-debugger node ~/.vscode/extensions/debugger-mcp.vscode-debugger-mcp-0.1.0/dist/mcp-server.js
-
-# VS Code Remote / WSL
-claude mcp add vscode-debugger node ~/.vscode-server/extensions/debugger-mcp.vscode-debugger-mcp-0.1.0/dist/mcp-server.js
+claude mcp add --transport http vscode-debugger http://localhost:45557/mcp
 ```
 
 ### Claude Desktop
@@ -102,10 +91,8 @@ Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_
 {
   "mcpServers": {
     "vscode-debugger": {
-      "command": "node",
-      "args": [
-        "~/.vscode/extensions/debugger-mcp.vscode-debugger-mcp-0.1.0/dist/mcp-server.js"
-      ]
+      "type": "http",
+      "url": "http://localhost:45557/mcp"
     }
   }
 }
@@ -119,15 +106,24 @@ Add to `.vscode/mcp.json` in your workspace:
 {
   "servers": {
     "vscode-debugger": {
-      "command": "node",
-      "args": [
-        "~/.vscode/extensions/debugger-mcp.vscode-debugger-mcp-0.1.0/dist/mcp-server.js"
-      ]
+      "type": "http",
+      "url": "http://localhost:45557/mcp"
     }
   }
 }
 ```
 
+### Alternative: stdio transport
+
+A standalone MCP server process is also available for clients that only support stdio transport. See the extension's `dist/mcp-server.js` — it discovers the running extension via a port file and proxies MCP requests over HTTP.
+
+## Settings
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| `debuggerMcp.port` | `45557` | Preferred port for the MCP server. Falls back to a random port if taken. |
+| `debuggerMcp.autoConfigureClaude` | `true` | Automatically update `~/.claude.json` with the MCP server URL on activation. |
+
 ## Tools
 
 ### Session Management
@@ -189,19 +185,18 @@ Add to `.vscode/mcp.json` in your workspace:
 
 ## How It Works
 
-1. **Extension activates** on VS Code startup and starts a localhost HTTP server on a random port
-2. **Port file** is written to the OS temp directory containing `{ port, authToken, pid, workspaceFolder, timestamp }`
-3. **MCP server** (spawned by the AI client) reads the port file, validates it (PID check, timestamp freshness), and sends authenticated HTTP requests
-4. **Debug commands** are forwarded to the VS Code debug API
+1. **Extension activates** on VS Code startup and starts an HTTP server on `localhost:45557`
+2. **MCP endpoint** at `/mcp` uses the Streamable HTTP transport protocol — each client gets its own session
+3. **Auto-config** writes the server URL to `~/.claude.json` so Claude Code discovers it automatically
+4. **Debug commands** are forwarded to the VS Code debug API via an in-process `DirectClient`
 5. **DAP message interception** captures stopped events, program output, and exit codes in real-time
 6. **Execution commands** (continue, step) block until the debugger pauses, then automatically gather the stop location and local variables
 
 ## Security
 
 - HTTP server binds to `127.0.0.1` only (no network exposure)
-- Random UUID auth token required on every request
-- Token is shared only through a local temp file
-- Port file includes PID for stale-file detection
+- MCP endpoint uses the standard Streamable HTTP transport protocol
+- Port file (for legacy stdio transport) includes random auth token and PID for stale-file detection
 
 ## License
 

package.json

@@ -2,7 +2,7 @@
   "name": "vscode-debugger-mcp",
   "displayName": "Debugger MCP",
   "description": "MCP server for AI-agent-controlled debugging via VS Code's Debug Adapter Protocol",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "publisher": "debugger-mcp",
   "license": "MIT",
   "engines": {
@@ -21,8 +21,45 @@
       {
         "command": "vscode-debugger-mcp.showPort",
         "title": "Debugger MCP: Show Server Port"
+      },
+      {
+        "command": "vscode-debugger-mcp.refreshClaudeConfig",
+        "title": "Debugger MCP: Update Claude Config"
+      }
+    ],
+    "viewsContainers": {
+      "activitybar": [
+        {
+          "id": "debuggerMcp",
+          "title": "Debugger MCP",
+          "icon": "$(bug)"
+        }
+      ]
+    },
+    "views": {
+      "debuggerMcp": [
+        {
+          "type": "webview",
+          "id": "debuggerMcp.statusView",
+          "name": "Status"
+        }
+      ]
+    },
+    "configuration": {
+      "title": "Debugger MCP",
+      "properties": {
+        "debuggerMcp.port": {
+          "type": "number",
+          "default": 45557,
+          "description": "Preferred port for the MCP server. Falls back to a random port if taken."
+        },
+        "debuggerMcp.autoConfigureClaude": {
+          "type": "boolean",
+          "default": true,
+          "description": "Automatically update ~/.claude.json with the MCP server URL on activation."
+        }
       }
-    ]
+    }
   },
   "scripts": {
     "compile": "npm run check-types && node esbuild.js",

src/extension/claude-config.ts

@@ -0,0 +1,78 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+const CLAUDE_CONFIG_PATH = path.join(os.homedir(), '.claude.json');
+const MCP_SERVER_KEY = 'vscode-debugger';
+
+interface ClaudeConfig {
+  mcpServers?: Record<string, any>;
+  projects?: Record<string, { mcpServers?: Record<string, any>; [key: string]: unknown }>;
+  [key: string]: unknown;
+}
+
+export interface ClaudeConfigResult {
+  success: boolean;
+  error?: string;
+  details?: string;
+}
+
+export function updateClaudeConfig(port: number): ClaudeConfigResult {
+  let config: ClaudeConfig = {};
+
+  try {
+    if (fs.existsSync(CLAUDE_CONFIG_PATH)) {
+      const raw = fs.readFileSync(CLAUDE_CONFIG_PATH, 'utf-8');
+      config = JSON.parse(raw);
+    }
+  } catch {
+    config = {};
+  }
+
+  const mcpUrl = `http://localhost:${port}/mcp`;
+  const httpEntry = { type: 'http', url: mcpUrl };
+  let changed = false;
+
+  // Update global config
+  if (!config.mcpServers) {
+    config.mcpServers = {};
+  }
+  const existing = config.mcpServers[MCP_SERVER_KEY];
+  if (existing?.type !== 'http' || existing?.url !== mcpUrl) {
+    config.mcpServers[MCP_SERVER_KEY] = httpEntry;
+    changed = true;
+  }
+
+  // Update project-level configs that have old entries for this server
+  let projectsUpdated = 0;
+  if (config.projects) {
+    for (const [, project] of Object.entries(config.projects)) {
+      const projectServer = project.mcpServers?.[MCP_SERVER_KEY];
+      if (projectServer && (projectServer.type !== 'http' || projectServer.url !== mcpUrl)) {
+        project.mcpServers![MCP_SERVER_KEY] = httpEntry;
+        projectsUpdated++;
+        changed = true;
+      }
+    }
+  }
+
+  if (!changed) {
+    return { success: true, details: 'Already up to date' };
+  }
+
+  try {
+    fs.writeFileSync(CLAUDE_CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to write ${CLAUDE_CONFIG_PATH}: ${err instanceof Error ? err.message : String(err)}`,
+    };
+  }
+
+  const parts: string[] = ['Updated ~/.claude.json'];
+  if (projectsUpdated > 0) {
+    parts.push(`Migrated ${projectsUpdated} project config(s) from stdio to HTTP`);
+  }
+
+  return { success: true, details: parts.join('. ') };
+}