vscode-terminal-mcp 0.1.4 → 0.1.6

package/CHANGELOG.md

@@ -0,0 +1,45 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.1.6] - 2026-03-19 18:18 PDT
+
+### Added
+- Screenshots in README for marketplace (run, exec, permission dialog)
+- Custom terminal tab names with date format (e.g., `MCP: BashTerm-26-03-19-17-30`)
+- `name` parameter in `run` tool for custom terminal names
+- Unique IPC socket per workspace to prevent conflicts between multiple VSCode instances
+- Large output handling documentation
+- Development workflow docs for extension cache workaround
+
+### Fixed
+- Clean output format for all tools (`run`, `exec`, `read`, `list`, `close`, `input`) — no more raw JSON responses
+- `waitForCompletion: false` not working (`z.coerce.boolean()` converted string `"false"` to `true`)
+- Idle reaper killing sessions with running commands — reaper disabled, user closes sessions manually
+
+## [0.1.5] - 2026-03-18 14:50 PDT
+
+### Added
+- npm publish with `bin` entry for `npx vscode-terminal-mcp` support
+- Published to VSCode Marketplace and MCP Registry
+
+## [0.1.3] - 2026-03-18 11:00 PDT
+
+### Added
+- `run` tool combining create + exec in one step
+- Session reuse: `run` finds idle sessions before creating new ones
+- Busy session detection: won't reuse sessions with running commands
+
+### Fixed
+- First-command timing fix with shell initialization delay
+
+## [0.1.0] - 2026-03-18 10:00 PDT
+
+### Added
+- Initial release
+- Tools: `create`, `exec`, `read`, `input`, `list`, `close`
+- Shell Integration API for output capture and exit code detection
+- Circular output buffer with pagination support
+- Subagent isolation with `agentId`
+- Command blocklist security
+- IPC bridge for MCP stdio-to-socket communication

package/CLAUDE.md

@@ -0,0 +1,84 @@
+# Project: vscode-terminal-mcp
+
+MCP server that runs commands in visible VSCode terminal tabs.
+
+## Release Process
+
+When publishing a new version, follow these steps in order:
+
+### 1. Update version
+
+```bash
+# In package.json, bump the version
+# e.g., "version": "0.1.6" → "version": "0.1.7"
+```
+
+### 2. Update CHANGELOG.md
+
+Add a new entry at the top with the new version and date:
+
+```markdown
+## [0.1.7] - YYYY-MM-DD
+
+### Added
+- ...
+
+### Fixed
+- ...
+```
+
+### 3. Update README.md
+
+Replace the "Latest Changes" section with the new version's changes. Keep only the latest version in README — full history lives in CHANGELOG.md.
+
+### 4. Build and publish
+
+```bash
+# Build
+npm run build
+
+# Publish to npm
+npm publish --access public
+
+# Package vsix
+npx vsce package --allow-missing-repository
+
+# Install locally for testing
+cp dist/extension.js dist/mcp-entry.js ~/.vscode/extensions/sirlordt.vscode-terminal-mcp-<version>/dist/
+```
+
+### 5. Upload to VSCode Marketplace
+
+1. Go to https://marketplace.visualstudio.com/manage/publishers/sirlordt
+2. Click "..." next to Terminal MCP → "Update"
+3. Upload the `.vsix` file
+
+### 6. Commit and push
+
+```bash
+git add -A
+git commit -m "v0.1.7: <summary of changes>"
+git push
+```
+
+## Extension Cache Workaround
+
+VSCode aggressively caches extensions. When developing locally:
+
+```bash
+# Quick update (after modifying source)
+npm run build
+cp dist/extension.js ~/.vscode/extensions/sirlordt.vscode-terminal-mcp-<version>/dist/extension.js
+# Then "Developer: Reload Window"
+
+# If reload doesn't pick up changes, close and reopen VSCode completely
+```
+
+## Terminal Execution
+
+Prefer the BashTerm MCP tools (`run`, `exec`, `read`, etc.) over the built-in Bash tool for executing commands. BashTerm runs commands in visible VSCode terminal tabs where the user can see output in real time.
+
+For commands that may take longer than 30 seconds or produce large output, use pull mode:
+1. Call `run` with `waitForCompletion: false`
+2. Call `read` with `offset: -10` to check progress
+3. Repeat until done

package/README.md

@@ -84,6 +84,20 @@ After installation, try asking:
 
 You should see a new terminal tab open in VSCode with the command output.
 
+## Screenshots
+
+### Running a command with `run`
+
+![Run command output](docs/images/run_finished.png)
+
+### Permission dialog for `exec`
+
+![Exec permission dialog](docs/images/ask_exec_permission.png)
+
+### Exec result with clean output
+
+![Exec finished](docs/images/exec_finished.png)
+
 ## Tools
 
 ### Quick Execution
@@ -202,6 +216,76 @@ This prevents conversation timeouts and lets the user watch progress in the term
 | Session state | Each command is isolated | Persistent sessions with history |
 | Interactive commands | Not supported | Send input to prompts/REPLs |
 
+## Development: Updating the Extension
+
+VSCode aggressively caches extensions in memory. When developing locally, `code --install-extension` and even "Developer: Reload Window" may **not** reload your changes. Use this workflow:
+
+### Quick update (no restart needed)
+
+After modifying source files, build and copy directly into the installed extension directory:
+
+```bash
+cd /path/to/vscode-terminal-mcp
+npm run build
+cp dist/extension.js ~/.vscode/extensions/sirlordt.vscode-terminal-mcp-<version>/dist/extension.js
+```
+
+Then run **"Developer: Reload Window"** (`Ctrl+Shift+P`).
+
+### Full reinstall (when quick update doesn't work)
+
+If VSCode still uses old code:
+
+```bash
+# 1. Uninstall and remove all copies
+code --uninstall-extension sirlordt.vscode-terminal-mcp
+rm -rf ~/.vscode/extensions/sirlordt.vscode-terminal-mcp-*
+
+# 2. Check for ghost entries with old publisher names
+# Look in ~/.vscode/extensions/extensions.json for stale entries
+# Remove any entries with old publisher IDs (e.g., "terminal-mcp.vscode-terminal-mcp")
+
+# 3. Close VSCode completely (not just reload)
+
+# 4. Rebuild and install
+npm run build
+npx vsce package --allow-missing-repository
+code --install-extension vscode-terminal-mcp-<version>.vsix --force
+
+# 5. Open VSCode
+```
+
+### Verify the correct version is loaded
+
+```bash
+# Check which extension directories exist
+ls ~/.vscode/extensions/ | grep terminal
+
+# Verify your changes are in the installed extension
+grep "YOUR_UNIQUE_STRING" ~/.vscode/extensions/sirlordt.vscode-terminal-mcp-*/dist/extension.js
+
+# Compare checksums
+md5sum dist/extension.js ~/.vscode/extensions/sirlordt.vscode-terminal-mcp-*/dist/extension.js
+```
+
+## Large Output Handling
+
+When `read` returns output that exceeds the MCP client's token limit, the system automatically saves the full output to a temporary JSON file and returns the file path in the error message.
+
+To extract the relevant content:
+
+```bash
+# Get the last 50 lines (most relevant for status)
+tail -50 /path/to/saved/file.txt
+
+# Or parse the JSON to extract the text content
+python3 -c "import json; data=json.load(open('/path/to/file.txt')); print(data[0]['text'][-2000:])"
+```
+
+The file format is JSON: `[{"type": "text", "text": "..."}]`
+
+This commonly happens with commands that produce heavy TUI output (progress bars, ANSI escape codes). Use smaller `offset` values (e.g., `offset: -20` instead of `offset: -100`) to reduce the captured output size.
+
 ## How It Works
 
 1. The **VSCode extension** activates and starts an IPC server on a Unix socket
@@ -209,6 +293,18 @@ This prevents conversation timeouts and lets the user watch progress in the term
 3. Commands execute in real VSCode terminals using the **Shell Integration API** for reliable output capture and exit code detection
 4. Output is stored in circular buffers with pagination support for efficient reading
 
+## Latest Changes (0.1.6)
+
+- Screenshots in README for marketplace
+- Clean output format for all tools — no more raw JSON
+- Fixed `waitForCompletion: false` not working
+- Disabled idle reaper — user closes sessions manually
+- Unique IPC socket per workspace (multi-instance support)
+- Custom terminal tab names with date format
+- Large output handling documentation
+
+See [CHANGELOG.md](CHANGELOG.md) for full history.
+
 ## License
 
 MIT

package/dist/extension.js

@@ -5389,6 +5389,13 @@ var zodToJsonSchema = (schema, options) => {
 };
 
 // src/mcp/tools/schemas.ts
+var coerceBoolean = external_exports.preprocess(
+  (val) => {
+    if (typeof val === "string") return val.toLowerCase() === "true";
+    return val;
+  },
+  external_exports.boolean()
+);
 var terminalCreateSchema = external_exports.object({
   name: external_exports.string().min(1).describe("Display name for the terminal tab"),
   cwd: external_exports.string().optional().describe("Working directory for the terminal"),
@@ -5400,7 +5407,7 @@ var terminalExecuteSchema = external_exports.object({
   sessionId: external_exports.string().min(1).describe("Session ID of the target terminal"),
   command: external_exports.string().min(1).describe("Command to execute"),
   timeoutMs: external_exports.coerce.number().min(1e3).max(3e5).optional().default(3e4).describe("Timeout in milliseconds (default: 30000, max: 300000)"),
-  waitForCompletion: external_exports.coerce.boolean().optional().default(true).describe("Wait for command to complete before returning (default: true)")
+  waitForCompletion: coerceBoolean.optional().default(true).describe("Wait for command to complete before returning (default: true)")
 });
 var terminalReadOutputSchema = external_exports.object({
   sessionId: external_exports.string().min(1).describe("Session ID of the target terminal"),
@@ -5421,7 +5428,7 @@ var terminalRunSchema = external_exports.object({
   shell: external_exports.string().optional().describe("Override shell (e.g., /bin/zsh, /bin/bash)"),
   agentId: external_exports.string().optional().describe("Identifier for the owning agent/subagent"),
   timeoutMs: external_exports.coerce.number().min(1e3).max(3e5).optional().default(3e4).describe("Timeout in milliseconds (default: 30000, max: 300000)"),
-  waitForCompletion: external_exports.coerce.boolean().optional().default(true).describe("Wait for command to complete before returning (default: true)")
+  waitForCompletion: coerceBoolean.optional().default(true).describe("Wait for command to complete before returning (default: true)")
 });
 var terminalSendInputSchema = external_exports.object({
   sessionId: external_exports.string().min(1).describe("Session ID of the target terminal"),
@@ -5439,21 +5446,13 @@ async function handleTerminalCreate(params, sessionManager2) {
     shell: input.shell,
     agentId: input.agentId
   });
+  const parts = [`Terminal created: ${sessionInfo.name}`, `session: ${sessionInfo.sessionId}`, `cwd: ${sessionInfo.cwd}`];
+  if (sessionInfo.agentId) parts.push(`agent: ${sessionInfo.agentId}`);
   return {
     content: [
       {
         type: "text",
-        text: JSON.stringify(
-          {
-            status: "created",
-            sessionId: sessionInfo.sessionId,
-            name: sessionInfo.name,
-            cwd: sessionInfo.cwd,
-            agentId: sessionInfo.agentId
-          },
-          null,
-          2
-        )
+        text: parts.join(" | ")
       }
     ]
   };
@@ -5493,24 +5492,29 @@ async function handleTerminalExecute(params, sessionManager2) {
     timeoutMs,
     waitForCompletion
   );
-  const response = {
-    sessionId: input.sessionId,
-    commandId: result.commandId,
-    exitCode: result.exitCode,
-    timedOut: result.timedOut,
-    durationMs: result.durationMs,
-    output: result.output
-  };
+  let cleanOutput = result.output.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/\x1b\][^\x07]*\x07/g, "").replace(/\r\n/g, "\n").replace(/\r/g, "").trim();
+  const lines = cleanOutput.split("\n");
+  if (lines.length > 0 && lines[0].trim() === input.command.trim()) {
+    lines.shift();
+    cleanOutput = lines.join("\n").trim();
+  }
+  const statusParts = [`exit: ${result.exitCode ?? "n/a"}`, `${result.durationMs}ms`, input.sessionId];
+  let text = `$ ${input.command}
+${cleanOutput}
+
+[${statusParts.join(" | ")}]`;
   if (result.timedOut) {
-    response.warning = `Command timed out after ${timeoutMs}ms. Output may be incomplete. The terminal session is still active.`;
+    text += `
+[TIMED OUT after ${timeoutMs}ms - session still active, use read to get more output]`;
   }
   return {
     content: [
       {
         type: "text",
-        text: JSON.stringify(response, null, 2)
+        text
       }
-    ]
+    ],
+    isError: result.exitCode !== null && result.exitCode !== 0
   };
 }
 
@@ -5518,67 +5522,66 @@ async function handleTerminalExecute(params, sessionManager2) {
 async function handleTerminalRun(params, sessionManager2) {
   const input = terminalRunSchema.parse(params);
   let sessionId;
+  let isNewSession = false;
   const existing = sessionManager2.listSessions(input.agentId);
   for (const s of existing) {
     if (!s.isActive || input.cwd && s.cwd !== input.cwd) continue;
-    const session2 = sessionManager2.getSession(s.sessionId);
-    if (session2 && !session2.isBusy) {
+    const session = sessionManager2.getSession(s.sessionId);
+    if (session && !session.isBusy) {
       sessionId = s.sessionId;
       break;
     }
   }
   if (!sessionId) {
     const sessionInfo = sessionManager2.createSession({
-      name: input.name ?? `run-${Date.now()}`,
+      name: input.name ?? (() => {
+        const d = /* @__PURE__ */ new Date();
+        const pad = (n) => String(n).padStart(2, "0");
+        return `BashTerm-${pad(d.getFullYear() % 100)}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}-${pad(d.getHours())}-${pad(d.getMinutes())}`;
+      })(),
       cwd: input.cwd,
       env: input.env,
       shell: input.shell,
       agentId: input.agentId
     });
     sessionId = sessionInfo.sessionId;
+    isNewSession = true;
+  }
+  if (isNewSession) {
+    return new Promise((resolve) => {
+      setTimeout(async () => {
+        const result = await executeCommand(sessionId, input, sessionManager2);
+        resolve(result);
+      }, 500);
+    });
   }
+  return executeCommand(sessionId, input, sessionManager2);
+}
+async function executeCommand(sessionId, input, sessionManager2) {
   const session = sessionManager2.getSession(sessionId);
   if (!session) {
     return {
-      content: [
-        {
-          type: "text",
-          text: "Error: Failed to get terminal session."
-        }
-      ],
+      content: [{ type: "text", text: "Error: Failed to get terminal session." }],
       isError: true
     };
   }
   const validation = sessionManager2.validateCommand(input.command);
   if (!validation.valid) {
     return {
-      content: [
-        {
-          type: "text",
-          text: `Command blocked: ${validation.reason}`
-        }
-      ],
+      content: [{ type: "text", text: `Command blocked: ${validation.reason}` }],
       isError: true
     };
   }
   const timeoutMs = input.timeoutMs ?? sessionManager2.getDefaultTimeout();
   const waitForCompletion = input.waitForCompletion ?? true;
-  const result = await session.execute(
-    input.command,
-    timeoutMs,
-    waitForCompletion
-  );
+  const result = await session.execute(input.command, timeoutMs, waitForCompletion);
   let cleanOutput = result.output.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/\x1b\][^\x07]*\x07/g, "").replace(/\r\n/g, "\n").replace(/\r/g, "").trim();
   const lines = cleanOutput.split("\n");
   if (lines.length > 0 && lines[0].trim() === input.command.trim()) {
     lines.shift();
     cleanOutput = lines.join("\n").trim();
   }
-  const statusParts = [
-    `exit: ${result.exitCode ?? "n/a"}`,
-    `${result.durationMs}ms`,
-    sessionId
-  ];
+  const statusParts = [`exit: ${result.exitCode ?? "n/a"}`, `${result.durationMs}ms`, sessionId];
   let text = `$ ${input.command}
 ${cleanOutput}
 
@@ -5588,12 +5591,7 @@ ${cleanOutput}
 [TIMED OUT after ${timeoutMs}ms - session still active, use read to get more output]`;
   }
   return {
-    content: [
-      {
-        type: "text",
-        text
-      }
-    ],
+    content: [{ type: "text", text }],
     isError: result.exitCode !== null && result.exitCode !== 0
   };
 }
@@ -5614,23 +5612,20 @@ async function handleTerminalReadOutput(params, sessionManager2) {
     };
   }
   const result = session.readOutput(input.offset, input.lines);
+  const cleanOutput = result.lines.join("\n").replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/\x1b\][^\x07]*\x07/g, "").replace(/\r\n/g, "\n").replace(/\r/g, "").trim();
+  const status = [
+    `lines: ${result.readFrom}-${result.readFrom + result.readCount}/${result.totalLines}`,
+    `remaining: ${result.remaining}`,
+    input.sessionId
+  ];
+  const text = `${cleanOutput}
+
+[${status.join(" | ")}]`;
   return {
     content: [
       {
         type: "text",
-        text: JSON.stringify(
-          {
-            sessionId: input.sessionId,
-            readFrom: result.readFrom,
-            readCount: result.readCount,
-            totalLines: result.totalLines,
-            remaining: result.remaining,
-            isComplete: result.isComplete,
-            output: result.lines.join("\n")
-          },
-          null,
-          2
-        )
+        text
       }
     ]
   };
@@ -5640,18 +5635,23 @@ async function handleTerminalReadOutput(params, sessionManager2) {
 async function handleTerminalList(params, sessionManager2) {
   const input = terminalListSchema.parse(params ?? {});
   const sessions = sessionManager2.listSessions(input.agentId);
+  if (sessions.length === 0) {
+    return {
+      content: [{ type: "text", text: "No active sessions." }]
+    };
+  }
+  const lines = sessions.map((s) => {
+    const age = Math.round((Date.now() - s.createdAt) / 1e3);
+    const parts = [s.sessionId, s.name, `cwd: ${s.cwd}`, `${age}s old`, `${s.outputLineCount} lines`];
+    if (s.agentId) parts.push(`agent: ${s.agentId}`);
+    return parts.join(" | ");
+  });
   return {
     content: [
       {
         type: "text",
-        text: JSON.stringify(
-          {
-            count: sessions.length,
-            sessions
-          },
-          null,
-          2
-        )
+        text: `${sessions.length} active session(s):
+${lines.join("\n")}`
       }
     ]
   };
@@ -5676,10 +5676,7 @@ async function handleTerminalClose(params, sessionManager2) {
     content: [
       {
         type: "text",
-        text: JSON.stringify({
-          status: "closed",
-          sessionId: input.sessionId
-        })
+        text: `Session closed: ${input.sessionId}`
       }
     ]
   };
@@ -5705,12 +5702,7 @@ async function handleTerminalSendInput(params, sessionManager2) {
     content: [
       {
         type: "text",
-        text: JSON.stringify({
-          status: "sent",
-          sessionId: input.sessionId,
-          inputLength: input.input.length,
-          pressedEnter: input.pressEnter ?? true
-        })
+        text: `Input sent to ${input.sessionId} (${input.input.length} chars${input.pressEnter ?? true ? " + Enter" : ""})`
       }
     ]
   };
@@ -5948,7 +5940,6 @@ var TerminalSession = class {
   isActive = true;
   lastCommandAt;
   shellReady;
-  resolveShellReady;
   constructor(config, maxOutputLines) {
     this.sessionId = generateSessionId();
     this.name = config.name;
@@ -5964,27 +5955,12 @@ var TerminalSession = class {
     if (config.shell) {
       terminalOptions.shellPath = config.shell;
     }
-    this.shellReady = new Promise((resolve) => {
-      this.resolveShellReady = resolve;
-    });
     this.terminal = vscode2.window.createTerminal(terminalOptions);
     this.terminal.show(true);
+    this.shellReady = new Promise((resolve) => {
+      resolve();
+    });
     this.setupShellIntegrationCapture();
-    if (vscode2.window.onDidChangeTerminalShellIntegration) {
-      const disposable = vscode2.window.onDidChangeTerminalShellIntegration((e) => {
-        if (e.terminal === this.terminal) {
-          disposable.dispose();
-          log(`Shell integration ready for session ${this.sessionId}`);
-          this.resolveShellReady();
-        }
-      });
-      setTimeout(() => {
-        disposable.dispose();
-        this.resolveShellReady();
-      }, 3e3);
-    } else {
-      setTimeout(() => this.resolveShellReady(), 1500);
-    }
     log(`Session ${this.sessionId} created: ${config.name} (cwd: ${this.cwd})`);
   }
   setupShellIntegrationCapture() {
@@ -6016,6 +5992,7 @@ var TerminalSession = class {
             this.commandHistory.push(this.currentCommand);
             this.currentCommand = null;
           }
+          this.lastCommandAt = Date.now();
           log(
             `Shell execution ended in session ${this.sessionId} with exit code: ${event.exitCode}`
           );
@@ -6023,11 +6000,10 @@ var TerminalSession = class {
       }
     }
   }
-  /**
-   * Execute a command in this terminal session.
-   */
   async execute(command, timeoutMs, waitForCompletion) {
+    log(`Waiting for shell ready in session ${this.sessionId}...`);
     await this.shellReady;
+    log(`Shell ready, executing command in session ${this.sessionId}`);
     const commandId = generateCommandId();
     const startedAt = Date.now();
     this.lastCommandAt = startedAt;
@@ -6114,9 +6090,6 @@ var TerminalSession = class {
       }
     });
   }
-  /**
-   * Send text input to the terminal (for interactive commands).
-   */
   sendInput(input, pressEnter) {
     this.terminal.sendText(input, pressEnter);
     this.lastCommandAt = Date.now();
@@ -6124,21 +6097,12 @@ var TerminalSession = class {
       `Input sent to session ${this.sessionId}: ${input.slice(0, 50)}${input.length > 50 ? "..." : ""}`
     );
   }
-  /**
-   * Read output from the buffer with pagination.
-   */
   readOutput(offset = 0, maxLines = 500) {
     return readFromBuffer(this.outputBuffer, offset, maxLines);
   }
-  /**
-   * Check if a command is currently executing.
-   */
   get isBusy() {
     return this.currentCommand !== null;
   }
-  /**
-   * Get session info for listing.
-   */
   getInfo() {
     return {
       sessionId: this.sessionId,
@@ -6151,23 +6115,14 @@ var TerminalSession = class {
       outputLineCount: getBufferLineCount(this.outputBuffer)
     };
   }
-  /**
-   * Get the VSCode terminal instance (for matching events).
-   */
   getTerminal() {
     return this.terminal;
   }
-  /**
-   * Check if session has been idle longer than the given duration.
-   */
   isIdle(idleThresholdMs) {
     if (idleThresholdMs <= 0) return false;
     const lastActivity = this.lastCommandAt ?? this.createdAt;
     return Date.now() - lastActivity > idleThresholdMs;
   }
-  /**
-   * Close the terminal session.
-   */
   dispose() {
     this.isActive = false;
     this.shellExecutionDisposable?.dispose();
@@ -6183,7 +6138,6 @@ var SessionManager = class {
   onSessionsChanged = this.onSessionsChangedEmitter.event;
   idleReaperInterval = null;
   constructor() {
-    this.startIdleReaper();
     vscode3.window.onDidCloseTerminal((terminal) => {
       for (const [id, session] of this.sessions) {
         if (session.getTerminal() === terminal) {
@@ -6217,6 +6171,7 @@ var SessionManager = class {
       const config = this.getConfig();
       if (config.idleTimeoutMs <= 0) return;
       for (const [id, session] of this.sessions) {
+        if (session.isBusy) continue;
         if (session.isIdle(config.idleTimeoutMs)) {
           log(`Reaping idle session ${id}`);
           session.dispose();
@@ -6344,7 +6299,16 @@ var sessionManager;
 var statusBarItem;
 function getSocketPath() {
   const tmpDir = os.tmpdir();
-  return path.join(tmpDir, "vscode-terminal-mcp.sock");
+  const crypto3 = require("crypto");
+  const workspace4 = vscode4.workspace.workspaceFolders?.[0]?.uri.fsPath || "";
+  const hash = crypto3.createHash("md5").update(workspace4).digest("hex").slice(0, 8);
+  const socketPath = path.join(tmpDir, `vscode-terminal-mcp-${hash}.sock`);
+  const discoveryPath = path.join(tmpDir, "vscode-terminal-mcp.discovery");
+  try {
+    fs.writeFileSync(discoveryPath, socketPath);
+  } catch {
+  }
+  return socketPath;
 }
 function cleanupSocket(socketPath) {
   try {

package/dist/mcp-entry.js

@@ -27,7 +27,20 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var net = __toESM(require("net"));
 var path = __toESM(require("path"));
 var os = __toESM(require("os"));
-var SOCKET_PATH = path.join(os.tmpdir(), "vscode-terminal-mcp.sock");
+var fs = __toESM(require("fs"));
+function getSocketPath() {
+  const tmpDir = os.tmpdir();
+  const discoveryPath = path.join(tmpDir, "vscode-terminal-mcp.discovery");
+  try {
+    const socketPath = fs.readFileSync(discoveryPath, "utf8").trim();
+    if (socketPath && fs.existsSync(socketPath)) {
+      return socketPath;
+    }
+  } catch {
+  }
+  return path.join(tmpDir, "vscode-terminal-mcp.sock");
+}
+var SOCKET_PATH = getSocketPath();
 var RECONNECT_DELAY_MS = 1e3;
 var MAX_RECONNECT_ATTEMPTS = 30;
 var StdioToIpcBridge = class {

package/package.json

@@ -2,7 +2,7 @@
   "name": "vscode-terminal-mcp",
   "displayName": "Terminal MCP Server",
   "description": "MCP server that provides visible terminal sessions in VSCode for Claude Code and subagents",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "publisher": "sirlordt",
   "license": "MIT",
   "author": "sirlordt",