@snapback/cli 1.1.12 → 1.1.15

package/dist/{chunk-KPETDXQO.js → chunk-OI2HNNT6.js}

@@ -1,16 +1,92 @@
-#!/usr/bin/env node
-import { __name } from './chunk-BW7RALUZ.js';
-import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
+#!/usr/bin/env node --no-warnings=ExperimentalWarning
+import { __name } from './chunk-7ADPL4Q3.js';
+import { readFileSync, mkdirSync, writeFileSync, existsSync } from 'fs';
 import { homedir, platform } from 'os';
 import { join, resolve, dirname } from 'path';
 import { randomUUID } from 'crypto';
-import { execSync } from 'child_process';
+import { exec, execSync } from 'child_process';
+import { promisify } from 'util';
 
+process.env.SNAPBACK_CLI='true';
 var __defProp = Object.defineProperty;
 var __name2 = /* @__PURE__ */ __name((target, value) => __defProp(target, "name", {
   value,
   configurable: true
 }), "__name");
+var CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+function getCacheFilePath() {
+  return join(homedir(), ".snapback", "mcp-configs", "paths.json");
+}
+__name(getCacheFilePath, "getCacheFilePath");
+__name2(getCacheFilePath, "getCacheFilePath");
+function readCache() {
+  try {
+    const raw = readFileSync(getCacheFilePath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version === 1 && typeof parsed.discovered === "object") {
+      return parsed;
+    }
+  } catch {
+  }
+  return {
+    version: 1,
+    discovered: {}
+  };
+}
+__name(readCache, "readCache");
+__name2(readCache, "readCache");
+function writeCache(cache) {
+  try {
+    const dir = join(homedir(), ".snapback", "mcp-configs");
+    mkdirSync(dir, {
+      recursive: true
+    });
+    writeFileSync(getCacheFilePath(), JSON.stringify(cache, null, 2));
+  } catch {
+  }
+}
+__name(writeCache, "writeCache");
+__name2(writeCache, "writeCache");
+function getCachedPath(clientName) {
+  const cache = readCache();
+  const entry = cache.discovered[clientName];
+  if (!entry) return null;
+  const age = Date.now() - new Date(entry.discoveredAt).getTime();
+  if (age > CACHE_TTL_MS) return null;
+  if (!existsSync(entry.path)) {
+    delete cache.discovered[clientName];
+    writeCache(cache);
+    return null;
+  }
+  return entry.path;
+}
+__name(getCachedPath, "getCachedPath");
+__name2(getCachedPath, "getCachedPath");
+function setCachedPath(clientName, configPath) {
+  const cache = readCache();
+  cache.discovered[clientName] = {
+    path: configPath,
+    discoveredAt: /* @__PURE__ */ (/* @__PURE__ */ new Date()).toISOString(),
+    platform: process.platform
+  };
+  writeCache(cache);
+}
+__name(setCachedPath, "setCachedPath");
+__name2(setCachedPath, "setCachedPath");
+function evictCachedPath(clientName) {
+  const cache = readCache();
+  if (cache.discovered[clientName]) {
+    delete cache.discovered[clientName];
+    writeCache(cache);
+  }
+}
+__name(evictCachedPath, "evictCachedPath");
+__name2(evictCachedPath, "evictCachedPath");
+function getAllCachedPaths() {
+  return readCache().discovered;
+}
+__name(getAllCachedPaths, "getAllCachedPaths");
+__name2(getAllCachedPaths, "getAllCachedPaths");
 var CLIENT_CONFIGS = {
   claude: /* @__PURE__ */ __name2((home) => {
     switch (platform()) {
@@ -35,11 +111,17 @@ var CLIENT_CONFIGS = {
     ] : [],
     join(_home, ".cursor/mcp.json")
   ], "cursor"),
+  // Windsurf only has a global config — no project-level support (confirmed by Windsurf docs, June 2025)
   windsurf: /* @__PURE__ */ __name2((home) => [
     join(home, ".codeium/windsurf/mcp_config.json")
   ], "windsurf"),
-  continue: /* @__PURE__ */ __name2((home) => [
-    join(home, ".continue/config.json")
+  // Continue: global config.json or config.yaml; project-level .continue/mcpServers/mcp.json
+  continue: /* @__PURE__ */ __name2((home, cwd) => [
+    ...cwd ? [
+      join(cwd, ".continue/mcpServers/mcp.json")
+    ] : [],
+    join(home, ".continue/config.json"),
+    join(home, ".continue/config.yaml")
   ], "continue"),
   // New clients
   vscode: /* @__PURE__ */ __name2((_home, cwd) => [
@@ -47,9 +129,16 @@ var CLIENT_CONFIGS = {
       join(cwd, ".vscode/mcp.json")
     ] : []
   ], "vscode"),
-  zed: /* @__PURE__ */ __name2((home) => [
+  // Zed: global ~/.config/zed/settings.json, plus project-level .zed/settings.json
+  zed: /* @__PURE__ */ __name2((home, cwd) => [
+    ...cwd ? [
+      join(cwd, ".zed/settings.json")
+    ] : [],
     join(home, ".config/zed/settings.json")
   ], "zed"),
+  // Cline / Roo Code store their actual settings in VS Code extension globalStorage,
+  // but `snap tools configure --cline/--roo-code` writes to these paths as a side-channel.
+  // Detection via these paths is best-effort; users may need `snap mcp link --client cline` instead.
   cline: /* @__PURE__ */ __name2((home) => [
     join(home, ".cline/mcp.json")
   ], "cline"),
@@ -63,21 +152,31 @@ var CLIENT_CONFIGS = {
     join(home, ".roo-code/mcp.json")
   ], "roo-code"),
   // Qoder (VS Code fork) - supports both project-level and global configs
-  qoder: /* @__PURE__ */ __name2((home) => {
-    switch (platform()) {
-      case "darwin":
-        return [
-          join(home, "Library/Application Support/Qoder/SharedClientCache/extension/local/mcp.json")
-        ];
-      case "win32":
-        return [
-          join(process.env.APPDATA || "", "Qoder/mcp.json")
-        ];
-      default:
-        return [
-          join(home, ".config/Qoder/mcp.json")
-        ];
-    }
+  qoder: /* @__PURE__ */ __name2((home, cwd) => {
+    const workspaceConfig = cwd ? [
+      join(cwd, ".qoder-mcp-config.json")
+    ] : [];
+    const globalConfigs = (() => {
+      switch (platform()) {
+        case "darwin":
+          return [
+            join(home, "Library/Application Support/Qoder/SharedClientCache/mcp.json"),
+            join(home, "Library/Application Support/Qoder/SharedClientCache/extension/local/mcp.json")
+          ];
+        case "win32":
+          return [
+            join(process.env.APPDATA || "", "Qoder/mcp.json")
+          ];
+        default:
+          return [
+            join(home, ".config/Qoder/mcp.json")
+          ];
+      }
+    })();
+    return [
+      ...workspaceConfig,
+      ...globalConfigs
+    ];
   }, "qoder")
 };
 var CLIENT_DISPLAY_NAMES = {
@@ -99,7 +198,12 @@ function detectAIClients(options = {}) {
   const clients = [];
   const seenPaths = /* @__PURE__ */ new Set();
   for (const [name, getPaths] of Object.entries(CLIENT_CONFIGS)) {
-    const paths = getPaths(home, cwd);
+    const candidates = getPaths(home, cwd);
+    const cachedPath = getCachedPath(name);
+    const paths = cachedPath && candidates.includes(cachedPath) ? [
+      cachedPath,
+      ...candidates.filter((p) => p !== cachedPath)
+    ] : candidates;
     for (const configPath of paths) {
       if (seenPaths.has(configPath)) {
         continue;
@@ -108,6 +212,7 @@ function detectAIClients(options = {}) {
       const exists = existsSync(configPath);
       let hasSnapback = false;
       if (exists) {
+        setCachedPath(name, configPath);
         try {
           const content = readFileSync(configPath, "utf-8");
           if (configPath.endsWith(".yaml") || configPath.endsWith(".yml")) {
@@ -160,20 +265,34 @@ function checkForSnapback(config, format) {
     case "claude":
     case "cursor":
     case "windsurf":
-    case "vscode":
     case "cline":
     case "roo-code":
+      if ("mcpServers" in configObj && typeof configObj.mcpServers === "object" && configObj.mcpServers !== null) {
+        const servers = configObj.mcpServers;
+        return "snapback" in servers || `snapback-${format}` in servers;
+      }
+      return false;
     case "qoder":
       if ("mcpServers" in configObj && typeof configObj.mcpServers === "object" && configObj.mcpServers !== null) {
         const servers = configObj.mcpServers;
-        return "snapback" in servers;
+        return Object.keys(servers).some((k) => k === "snapback" || k.startsWith("snapback-"));
+      }
+      return false;
+    case "vscode":
+      if ("servers" in configObj && typeof configObj.servers === "object" && configObj.servers !== null) {
+        const servers = configObj.servers;
+        return "snapback" in servers || "snapback-vscode" in servers;
       }
       return false;
     case "gemini":
     case "zed":
+      if ("context_servers" in configObj && typeof configObj.context_servers === "object" && configObj.context_servers !== null) {
+        const servers = configObj.context_servers;
+        return "snapback" in servers || "snapback-zed" in servers;
+      }
       if ("mcpServers" in configObj && typeof configObj.mcpServers === "object" && configObj.mcpServers !== null) {
         const servers = configObj.mcpServers;
-        return "snapback" in servers;
+        return "snapback" in servers || `snapback-${format}` in servers;
       }
       return false;
     case "continue":
@@ -212,6 +331,64 @@ function readClientConfig(client) {
 }
 __name(readClientConfig, "readClientConfig");
 __name2(readClientConfig, "readClientConfig");
+function detectWorkspaceConfig(workspaceRoot) {
+  const root = workspaceRoot || process.cwd();
+  const qoderConfig = join(root, ".qoder-mcp-config.json");
+  if (existsSync(qoderConfig)) {
+    try {
+      const content = readFileSync(qoderConfig, "utf-8");
+      if (content.includes("snapback")) {
+        return {
+          path: qoderConfig,
+          type: "qoder"
+        };
+      }
+    } catch {
+    }
+  }
+  const cursorConfig = join(root, ".cursor", "mcp.json");
+  if (existsSync(cursorConfig)) {
+    try {
+      const content = readFileSync(cursorConfig, "utf-8");
+      if (content.includes("snapback")) {
+        return {
+          path: cursorConfig,
+          type: "cursor"
+        };
+      }
+    } catch {
+    }
+  }
+  const vscodeConfig = join(root, ".vscode", "mcp.json");
+  if (existsSync(vscodeConfig)) {
+    try {
+      const content = readFileSync(vscodeConfig, "utf-8");
+      if (content.includes("snapback")) {
+        return {
+          path: vscodeConfig,
+          type: "vscode"
+        };
+      }
+    } catch {
+    }
+  }
+  const windsurfConfig = join(root, ".windsurf", "mcp.json");
+  if (existsSync(windsurfConfig)) {
+    try {
+      const content = readFileSync(windsurfConfig, "utf-8");
+      if (content.includes("snapback")) {
+        return {
+          path: windsurfConfig,
+          type: "windsurf"
+        };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+__name(detectWorkspaceConfig, "detectWorkspaceConfig");
+__name2(detectWorkspaceConfig, "detectWorkspaceConfig");
 function getSnapbackConfigDir() {
   const isWindows = process.platform === "win32";
   if (isWindows) {
@@ -308,6 +485,90 @@ function resetIdentityCache() {
 }
 __name(resetIdentityCache, "resetIdentityCache");
 __name2(resetIdentityCache, "resetIdentityCache");
+var execAsync = promisify(exec);
+async function detectMCPProcesses() {
+  try {
+    const { stdout } = await execAsync('ps aux | grep -E "(mcp.*--stdio|--stdio.*mcp|uvx.*mcp-server|npx.*mcp|node.*mcp)" | grep -v grep', {
+      timeout: 5e3
+    });
+    const processes = parseProcessOutput(stdout);
+    const snapbackProcesses = processes.filter((p) => p.isSnapback);
+    return {
+      allProcesses: processes,
+      snapbackProcesses,
+      snapbackRunning: snapbackProcesses.length > 0,
+      totalCount: processes.length,
+      checkedAt: /* @__PURE__ */ new Date()
+    };
+  } catch {
+    return {
+      allProcesses: [],
+      snapbackProcesses: [],
+      snapbackRunning: false,
+      totalCount: 0,
+      checkedAt: /* @__PURE__ */ new Date()
+    };
+  }
+}
+__name(detectMCPProcesses, "detectMCPProcesses");
+__name2(detectMCPProcesses, "detectMCPProcesses");
+function parseProcessOutput(output) {
+  const lines = output.trim().split("\n").filter((line) => line.trim());
+  const processes = [];
+  for (const line of lines) {
+    const match = line.match(/^(\S+)\s+(\d+)\s+.*?\s+(.+)$/);
+    if (!match) {
+      continue;
+    }
+    const [, , pidStr, command] = match;
+    const pid = Number.parseInt(pidStr, 10);
+    if (Number.isNaN(pid)) {
+      continue;
+    }
+    const serverName = extractServerName(command);
+    const isSnapback = command.toLowerCase().includes("snapback");
+    processes.push({
+      pid,
+      command: command.trim(),
+      serverName,
+      isSnapback
+    });
+  }
+  return processes;
+}
+__name(parseProcessOutput, "parseProcessOutput");
+__name2(parseProcessOutput, "parseProcessOutput");
+function extractServerName(command) {
+  const patterns = [
+    // snapback mcp --stdio
+    /snapback[/\s]/i,
+    // mcp-server-fetch
+    /mcp-server-(\w+)/,
+    // @modelcontextprotocol/server-sequential-thinking
+    /server-(\w+)/,
+    // context7-mcp
+    /(\w+)-mcp/,
+    // fly mcp server
+    /fly.*mcp/i,
+    // supabase-mcp
+    /supabase-mcp/i
+  ];
+  for (const pattern of patterns) {
+    const match = command.match(pattern);
+    if (match) {
+      return match[1] || match[0];
+    }
+  }
+  return "mcp";
+}
+__name(extractServerName, "extractServerName");
+__name2(extractServerName, "extractServerName");
+async function isSnapbackMCPRunning() {
+  const health = await detectMCPProcesses();
+  return health.snapbackRunning;
+}
+__name(isSnapbackMCPRunning, "isSnapbackMCPRunning");
+__name2(isSnapbackMCPRunning, "isSnapbackMCPRunning");
 function validateClientConfig(client) {
   const issues = [];
   if (!existsSync(client.configPath)) {
@@ -504,7 +765,15 @@ function validateSnapbackConfig(config, issues) {
           severity: "error",
           code: "MISSING_STDIO_ARG",
           message: "Args must include '--stdio' flag",
-          fix: "Run: snap tools configure --force"
+          fix: "Run: snap mcp repair --client <name>"
+        });
+      }
+      if (config.args.includes("shim")) {
+        issues.push({
+          severity: "error",
+          code: "DEPRECATED_SHIM_COMMAND",
+          message: "Args contain deprecated 'shim' command - use '--stdio' instead",
+          fix: "Run: snap mcp repair --client <name>"
         });
       }
       if (!config.args.includes("--workspace")) {
@@ -623,14 +892,15 @@ function isCommandExecutable2(command) {
 }
 __name(isCommandExecutable2, "isCommandExecutable2");
 __name2(isCommandExecutable2, "isCommandExecutable");
+var STDIO_ONLY_CLIENTS = /* @__PURE__ */ new Set([
+  "claude"
+]);
 function getSnapbackMCPConfig(options = {}) {
-  const { apiKey, workspaceId, serverUrl, useNpx = false, useBinary = false, customCommand, additionalEnv, workspaceRoot, useLocalDev = false, localCliPath } = options;
+  const { apiKey, workspaceId, serverUrl, useBinary = false, customCommand, additionalEnv, workspaceRoot, useLocalDev = false, localCliPath, client, useDoppler = false, dopplerProject = "snapback-shared", dopplerConfig = "dev", useSse = false, useStreamableHttp = false } = options;
+  const useNpx = options.useNpx ?? (client ? STDIO_ONLY_CLIENTS.has(client) : false);
   const env = {
     ...additionalEnv
   };
-  if (workspaceId) {
-    env.SNAPBACK_WORKSPACE_ID = workspaceId;
-  }
   if (apiKey) {
     env.SNAPBACK_API_KEY = apiKey;
   }
@@ -643,9 +913,65 @@ function getSnapbackMCPConfig(options = {}) {
       }
     };
   }
+  if (useSse || useStreamableHttp) {
+    const url = serverUrl || "https://mcp.snapback.dev/mcp";
+    const headers2 = {};
+    if (workspaceId) {
+      headers2["x-workspace-id"] = workspaceId;
+    }
+    if (apiKey) {
+      headers2["x-api-key"] = apiKey;
+    }
+    return {
+      url,
+      ...Object.keys(headers2).length > 0 && {
+        headers: headers2
+      }
+    };
+  }
+  if (useDoppler && localCliPath) {
+    const tier = apiKey ? "pro" : "free";
+    const nodePath = resolveNodePath();
+    const dopplerArgs = [
+      "run",
+      "--project",
+      dopplerProject,
+      "--config",
+      dopplerConfig,
+      "--",
+      nodePath,
+      localCliPath,
+      "mcp",
+      "--stdio",
+      "--tier",
+      tier
+    ];
+    if (workspaceRoot) {
+      dopplerArgs.push("--workspace", workspaceRoot);
+    }
+    return {
+      command: "doppler",
+      args: dopplerArgs
+    };
+  }
   if (useNpx) {
+    const isClaudeDesktop = client === "claude";
+    if (isClaudeDesktop) {
+      const args2 = [
+        "--yes",
+        "@snapback/mcpb"
+      ];
+      if (workspaceRoot) {
+        args2.push(workspaceRoot);
+      }
+      return {
+        command: "npx",
+        args: args2
+      };
+    }
     const tier = apiKey ? "pro" : "free";
     const args = [
+      "--yes",
       "@snapback/cli",
       "mcp",
       "--stdio",
@@ -663,12 +989,19 @@ function getSnapbackMCPConfig(options = {}) {
       }
     };
   }
-  if (serverUrl || !useLocalDev && !useBinary) {
-    const url = serverUrl || "https://snapback-mcp.fly.dev";
+  if (serverUrl || !useLocalDev && !useBinary && !useDoppler) {
+    const url = serverUrl || "https://mcp.snapback.dev/mcp";
+    const headers2 = {};
+    if (workspaceId) {
+      headers2["x-workspace-id"] = workspaceId;
+    }
+    if (apiKey) {
+      headers2["x-api-key"] = apiKey;
+    }
     return {
       url,
-      ...Object.keys(env).length > 0 && {
-        env
+      ...Object.keys(headers2).length > 0 && {
+        headers: headers2
       }
     };
   }
@@ -712,10 +1045,17 @@ function getSnapbackMCPConfig(options = {}) {
       }
     };
   }
+  const headers = {};
+  if (workspaceId) {
+    headers["x-workspace-id"] = workspaceId;
+  }
+  if (apiKey) {
+    headers["x-api-key"] = apiKey;
+  }
   return {
-    url: "https://snapback-mcp.fly.dev",
-    ...Object.keys(env).length > 0 && {
-      env
+    url: "https://mcp.snapback.dev/mcp",
+    ...Object.keys(headers).length > 0 && {
+      headers
     }
   };
 }
@@ -773,6 +1113,10 @@ function removeSnapbackConfig(client) {
       case "claude":
       case "cursor":
       case "windsurf":
+      case "cline":
+      case "roo-code":
+      case "gemini":
+      case "qoder":
         if (config.mcpServers?.[serverKey]) {
           delete config.mcpServers[serverKey];
         }
@@ -780,6 +1124,28 @@ function removeSnapbackConfig(client) {
           delete config.mcpServers.snapback;
         }
         break;
+      case "vscode": {
+        const vscodeConfig = config;
+        const servers = vscodeConfig.servers;
+        if (servers?.[serverKey]) {
+          delete servers[serverKey];
+        }
+        if (servers?.snapback) {
+          delete servers.snapback;
+        }
+        break;
+      }
+      case "zed": {
+        const zedConfig = config;
+        const contextServers = zedConfig.context_servers;
+        if (contextServers?.[serverKey]) {
+          delete contextServers[serverKey];
+        }
+        if (contextServers?.snapback) {
+          delete contextServers.snapback;
+        }
+        break;
+      }
       case "continue": {
         const experimental = config.experimental;
         if (experimental?.modelContextProtocolServers) {
@@ -790,6 +1156,7 @@ function removeSnapbackConfig(client) {
       }
     }
     writeFileSync(client.configPath, JSON.stringify(config, null, 2));
+    evictCachedPath(client.name);
     return {
       success: true
     };
@@ -815,13 +1182,9 @@ function mergeConfig(existing, snapbackConfig, format) {
   switch (format) {
     case "claude":
     case "cursor":
-    case "windsurf":
-    case "vscode":
     case "cline":
     case "roo-code":
     case "gemini":
-    case "zed":
-    case "qoder":
       return {
         ...existing,
         mcpServers: {
@@ -829,6 +1192,58 @@ function mergeConfig(existing, snapbackConfig, format) {
           [serverKey]: snapbackConfig
         }
       };
+    case "windsurf":
+      return {
+        ...existing,
+        mcpServers: {
+          ...existing.mcpServers || {},
+          [serverKey]: {
+            ...snapbackConfig,
+            disabled: false,
+            alwaysAllow: []
+          }
+        }
+      };
+    case "qoder": {
+      const qoderType = snapbackConfig.url ? "sse" : "stdio";
+      return {
+        ...existing,
+        mcpServers: {
+          ...existing.mcpServers || {},
+          [serverKey]: {
+            type: qoderType,
+            ...snapbackConfig
+          }
+        }
+      };
+    }
+    case "vscode": {
+      const vscodeConfig = existing;
+      const servers = vscodeConfig.servers || {};
+      const { mcpServers: _, ...rest } = vscodeConfig;
+      return {
+        ...rest,
+        servers: {
+          ...servers,
+          [serverKey]: {
+            type: "stdio",
+            ...snapbackConfig
+          }
+        }
+      };
+    }
+    case "zed": {
+      const zedConfig = existing;
+      const contextServers = zedConfig.context_servers || {};
+      const { mcpServers: _, ...rest } = zedConfig;
+      return {
+        ...rest,
+        context_servers: {
+          ...contextServers,
+          [serverKey]: snapbackConfig
+        }
+      };
+    }
     case "continue": {
       const continueConfig = existing;
       const experimental = continueConfig.experimental || {};
@@ -863,6 +1278,87 @@ function mergeConfig(existing, snapbackConfig, format) {
 }
 __name(mergeConfig, "mergeConfig");
 __name2(mergeConfig, "mergeConfig");
+function patchApiKeyInClientConfig(client, apiKey) {
+  try {
+    if (!existsSync(client.configPath)) return false;
+    const raw = readFileSync(client.configPath, "utf-8");
+    const config = JSON.parse(raw);
+    const serverKey = getServerKey(client.format);
+    let patched = false;
+    const patchEntry = /* @__PURE__ */ __name2((entry) => {
+      if (typeof entry !== "object" || entry === null) return false;
+      const e = entry;
+      if (e.url && typeof e.url === "string") {
+        if (!e.headers || typeof e.headers !== "object") {
+          e.headers = {};
+        }
+        e.headers["x-api-key"] = apiKey;
+        const headers = e.headers;
+        if (headers.Authorization?.includes("<your-token>")) {
+          delete headers.Authorization;
+        }
+        return true;
+      }
+      if (!e.env || typeof e.env !== "object") {
+        e.env = {};
+      }
+      e.env.SNAPBACK_API_KEY = apiKey;
+      return true;
+    }, "patchEntry");
+    switch (client.format) {
+      case "claude":
+      case "cursor":
+      case "windsurf":
+      case "cline":
+      case "roo-code":
+      case "gemini": {
+        const servers = config.mcpServers || {};
+        const entry = servers[serverKey] ?? servers.snapback;
+        if (entry) patched = patchEntry(entry);
+        break;
+      }
+      case "qoder": {
+        const servers = config.mcpServers || {};
+        for (const key of Object.keys(servers)) {
+          if (key === "snapback" || key.startsWith("snapback-")) {
+            patched = patchEntry(servers[key]) || patched;
+          }
+        }
+        break;
+      }
+      case "vscode": {
+        const servers = config.servers || {};
+        const entry = servers[serverKey] ?? servers.snapback;
+        if (entry) patched = patchEntry(entry);
+        break;
+      }
+      case "zed": {
+        const servers = config.context_servers || {};
+        const entry = servers[serverKey] ?? servers.snapback;
+        if (entry) patched = patchEntry(entry);
+        break;
+      }
+      case "continue": {
+        const exp = config.experimental || {};
+        const list = exp.modelContextProtocolServers || [];
+        for (const item of list) {
+          if (typeof item.name === "string" && item.name.startsWith("snapback")) {
+            patched = patchEntry(item) || patched;
+          }
+        }
+        break;
+      }
+    }
+    if (patched) {
+      writeFileSync(client.configPath, JSON.stringify(config, null, 2));
+    }
+    return patched;
+  } catch {
+    return false;
+  }
+}
+__name(patchApiKeyInClientConfig, "patchApiKeyInClientConfig");
+__name2(patchApiKeyInClientConfig, "patchApiKeyInClientConfig");
 function validateConfig(client) {
   try {
     const content = readFileSync(client.configPath, "utf-8");
@@ -872,15 +1368,33 @@ function validateConfig(client) {
       case "claude":
       case "cursor":
       case "windsurf":
-      case "vscode":
       case "cline":
       case "roo-code":
       case "gemini":
-      case "zed":
       case "qoder": {
         const serverConfig = config.mcpServers?.[serverKey] || config.mcpServers?.snapback;
         return Boolean(serverConfig?.command || serverConfig?.url);
       }
+      case "vscode": {
+        const vscodeConfig = config;
+        const servers = vscodeConfig.servers;
+        const serverConfig = servers?.[serverKey] || servers?.snapback;
+        if (typeof serverConfig === "object" && serverConfig !== null) {
+          const cfg = serverConfig;
+          return Boolean(cfg.command || cfg.url);
+        }
+        return false;
+      }
+      case "zed": {
+        const zedConfig = config;
+        const contextServers = zedConfig.context_servers;
+        const serverConfig = contextServers?.[serverKey] || contextServers?.snapback;
+        if (typeof serverConfig === "object" && serverConfig !== null) {
+          const cfg = serverConfig;
+          return Boolean(cfg.command || cfg.url);
+        }
+        return false;
+      }
       case "continue": {
         const expCfg = config.experimental;
         const srvs = expCfg?.modelContextProtocolServers;
@@ -1007,6 +1521,7 @@ function attemptFix(client, issue, _validation, options) {
     case "MISSING_ARGS":
     case "MISSING_MCP_ARG":
     case "MISSING_STDIO_ARG":
+    case "DEPRECATED_SHIM_COMMAND":
     case "INVALID_URL":
       return performFullReconfiguration(client, options);
     case "COMMAND_NOT_EXECUTABLE": {
@@ -1072,7 +1587,8 @@ function performFullReconfiguration(client, options) {
         workspaceId: options.workspaceId,
         workspaceRoot,
         useLocalDev: true,
-        localCliPath: cliPath
+        localCliPath: cliPath,
+        client: client.format
       });
       const nodePath = resolveNodePath();
       console.error(`[MCP Repair] Using node path: ${nodePath}`);
@@ -1080,9 +1596,10 @@ function performFullReconfiguration(client, options) {
       mcpConfig = getSnapbackMCPConfig({
         apiKey: options.apiKey,
         workspaceId: options.workspaceId,
-        useLocalDev: false
+        useLocalDev: false,
+        client: client.format
       });
-      console.error("[MCP Repair] Using remote HTTP mode (CLI not found locally)");
+      console.error("[MCP Repair] Using default mode (CLI not found locally)");
     }
     const writeResult = writeClientConfig(client, mcpConfig);
     if (writeResult.success) {
@@ -1155,6 +1672,4 @@ function findCliPath() {
 __name(findCliPath, "findCliPath");
 __name2(findCliPath, "findCliPath");
 
-export { createManagedMetadata, detectAIClients, getClient, getClientConfigPath, getConfiguredClients, getOrCreateIdentity, getServerKey, getSnapbackConfigDir, getSnapbackMCPConfig, injectWorkspacePath, isCommandExecutable2, isOwnedByThisInstall, readClientConfig, removeSnapbackConfig, repairClientConfig, resetIdentityCache, resolveNodePath, validateClientConfig, validateConfig, validateWorkspacePath, writeClientConfig };
-//# sourceMappingURL=chunk-KPETDXQO.js.map
-//# sourceMappingURL=chunk-KPETDXQO.js.map
+export { createManagedMetadata, detectAIClients, detectMCPProcesses, detectWorkspaceConfig, evictCachedPath, getAllCachedPaths, getCachedPath, getClient, getClientConfigPath, getConfiguredClients, getOrCreateIdentity, getServerKey, getSnapbackConfigDir, getSnapbackMCPConfig, injectWorkspacePath, isCommandExecutable2, isOwnedByThisInstall, isSnapbackMCPRunning, patchApiKeyInClientConfig, readClientConfig, removeSnapbackConfig, repairClientConfig, resetIdentityCache, resolveNodePath, setCachedPath, validateClientConfig, validateConfig, validateWorkspacePath, writeClientConfig };