@runpod/mcp-server 3.1.0 → 3.3.0

package/dist/wizard-FBLOZ6YM.mjs

@@ -0,0 +1,901 @@
+#!/usr/bin/env node
+
+// src/install/wizard.ts
+import { execFileSync } from "child_process";
+import * as p from "@clack/prompts";
+
+// src/install/clients.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { execSync, spawnSync } from "child_process";
+import * as jsonc from "jsonc-parser";
+var SERVER_NAME = "runpod";
+var NPM_PACKAGE = "@runpod/mcp-server@latest";
+var HOSTED_URL = process.env.RUNPOD_MCP_URL ?? "https://mcp.getrunpod.io/";
+function localServerConfig(apiKey, serverProperty) {
+  const config = {
+    command: "npx",
+    args: ["-y", NPM_PACKAGE],
+    env: { RUNPOD_API_KEY: apiKey }
+  };
+  return serverProperty === "servers" ? { type: "stdio", ...config } : config;
+}
+function hostedServerConfig(strategy, serverProperty, url) {
+  if (strategy === "mcp-remote") {
+    return { command: "npx", args: ["-y", "mcp-remote", url] };
+  }
+  return serverProperty === "servers" ? { type: "http", url } : { url };
+}
+function describeDialect(dialect) {
+  return dialect === "json" ? "JSON" : "JSONC";
+}
+function parseFailure(content, dialect) {
+  if (dialect === "json") {
+    try {
+      JSON.parse(content);
+      return void 0;
+    } catch (error) {
+      return errMessage(error);
+    }
+  }
+  const errors = [];
+  jsonc.parse(content, errors, { allowTrailingComma: true });
+  return errors.length > 0 ? `JSONC parse error at offset ${errors[0].offset}` : void 0;
+}
+function parseAsClient(content, dialect) {
+  if (dialect !== "json") {
+    return jsonc.parse(content, [], { allowTrailingComma: true });
+  }
+  try {
+    return JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+}
+function readBackEntry(content, serverProperty, dialect) {
+  const parsed = parseAsClient(content, dialect);
+  if (typeof parsed !== "object" || parsed === null) return void 0;
+  const servers = parsed[serverProperty];
+  if (typeof servers !== "object" || servers === null) return void 0;
+  return servers[SERVER_NAME];
+}
+function reliesOnLeniency(content) {
+  if (content.trim() === "") return false;
+  try {
+    JSON.parse(content);
+    return false;
+  } catch {
+    return parseFailure(content, "jsonc") === void 0;
+  }
+}
+function upsertJsonServer(configPath, serverProperty, value, dialect) {
+  if (!path.isAbsolute(configPath)) {
+    return {
+      success: false,
+      message: `refusing to write "${configPath}": not an absolute path, so it would resolve against the current directory. This usually means an environment variable (APPDATA, XDG_CONFIG_HOME) is set to an empty or relative value.`
+    };
+  }
+  try {
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    const content = fs.existsSync(configPath) ? fs.readFileSync(configPath, "utf8") : "";
+    const edits = jsonc.modify(content, [serverProperty, SERVER_NAME], value, {
+      formattingOptions: { tabSize: 2, insertSpaces: true }
+    });
+    const updated = jsonc.applyEdits(content, edits).replace(/^\uFEFF/, "");
+    const failure = parseFailure(updated, dialect);
+    if (failure) {
+      const wasAlreadyBroken = content.trim() !== "" && parseFailure(content, dialect) !== void 0;
+      return {
+        success: false,
+        message: wasAlreadyBroken ? `${configPath} could not be parsed as ${describeDialect(dialect)} before this change either (${failure}), so it was left untouched \u2014 this client would not load the entry. Fix the file (or move it aside) and re-run.` : `writing to ${configPath} would leave it unparseable (${failure}), so it was left untouched.`
+      };
+    }
+    const landed = readBackEntry(updated, serverProperty, dialect);
+    if (JSON.stringify(landed) !== JSON.stringify(value)) {
+      return {
+        success: false,
+        message: `${configPath} was left untouched: the entry would have been written where this client does not read it, so it would have had no effect. This usually means "${serverProperty}" appears more than once in the file \u2014 the last one wins, so merge them into a single block and re-run.`
+      };
+    }
+    fs.writeFileSync(configPath, updated, { encoding: "utf8", mode: 384 });
+    if (dialect === "unverified" && reliesOnLeniency(updated)) {
+      return {
+        success: true,
+        message: "written, but this config uses comments or trailing commas and whether this client accepts them is unverified \u2014 if the Runpod server does not appear, remove them"
+      };
+    }
+    return { success: true };
+  } catch (error) {
+    return { success: false, message: errMessage(error) };
+  }
+}
+function removeJsonServer(configPath, serverProperty, dialect) {
+  if (!path.isAbsolute(configPath)) {
+    return {
+      success: false,
+      message: `refusing to touch "${configPath}": not an absolute path. Check APPDATA / XDG_CONFIG_HOME.`
+    };
+  }
+  try {
+    if (!fs.existsSync(configPath)) {
+      return { success: true, message: "nothing to remove" };
+    }
+    const content = fs.readFileSync(configPath, "utf8");
+    if (content.trim() === "") {
+      return { success: true, message: "nothing to remove" };
+    }
+    const existingFailure = parseFailure(content, dialect);
+    if (existingFailure !== void 0) {
+      return {
+        success: false,
+        message: `could not safely remove the Runpod entry from ${configPath}: the existing config is not valid ${describeDialect(dialect)} (${existingFailure}). The original file was left unchanged; repair it or delete the entry by hand.`
+      };
+    }
+    let edits;
+    try {
+      edits = jsonc.modify(content, [serverProperty, SERVER_NAME], void 0, {
+        formattingOptions: { tabSize: 2, insertSpaces: true }
+      });
+    } catch (error) {
+      if (/empty document/i.test(errMessage(error))) {
+        return { success: true, message: "nothing to remove" };
+      }
+      throw error;
+    }
+    if (edits.length === 0) {
+      return readBackEntry(content, serverProperty, dialect) === void 0 ? { success: true, message: "nothing to remove" } : {
+        success: false,
+        message: `the Runpod entry is still present in ${configPath} and could not be removed automatically \u2014 "${serverProperty}" appears more than once, so the edit targeted a block this client does not read. Delete the entry by hand.`
+      };
+    }
+    const updated = jsonc.applyEdits(content, edits);
+    const brokeIt = parseFailure(updated, dialect) !== void 0;
+    const stillThere = readBackEntry(updated, serverProperty, dialect) !== void 0;
+    if (brokeIt || stillThere) {
+      return {
+        success: false,
+        message: `could not remove the Runpod entry from ${configPath} without ${brokeIt ? "making the config unparseable" : "leaving the entry present"}. The original file was left unchanged so its comments and formatting are preserved; delete the Runpod entry by hand.`
+      };
+    }
+    fs.writeFileSync(configPath, updated, "utf8");
+    return { success: true };
+  } catch (error) {
+    return { success: false, message: errMessage(error) };
+  }
+}
+function errMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function exists(p2) {
+  try {
+    return fs.existsSync(p2);
+  } catch {
+    return false;
+  }
+}
+function jsonClient(opts) {
+  const serverProperty = opts.serverProperty ?? "mcpServers";
+  const hostedStrategy = opts.hostedStrategy ?? "http";
+  return {
+    id: opts.id,
+    name: opts.name,
+    detect: () => Promise.resolve(
+      (opts.detectPaths?.() ?? [path.dirname(opts.configPath())]).some(exists)
+    ),
+    add: (mode) => {
+      const value = mode.kind === "local" ? localServerConfig(mode.apiKey, serverProperty) : hostedServerConfig(hostedStrategy, serverProperty, mode.url);
+      return Promise.resolve(
+        upsertJsonServer(opts.configPath(), serverProperty, value, opts.dialect)
+      );
+    },
+    dialect: opts.dialect,
+    remove: () => Promise.resolve(
+      removeJsonServer(opts.configPath(), serverProperty, opts.dialect)
+    ),
+    describeTarget: () => opts.configPath()
+  };
+}
+function claudeCandidates(platform, homedir2, appdata) {
+  if (platform === "win32") {
+    const win = path.win32;
+    const defaultAppdata = win.join(homedir2, "AppData", "Roaming");
+    return [
+      {
+        path: win.join(homedir2, ".local", "bin", "claude.exe"),
+        trustedRoot: homedir2
+      },
+      // npm -g installs a .cmd shim. runClaude bypasses it and resolves the real
+      // native or JavaScript target from the installed package manifest.
+      //
+      // absoluteEnvDir, not `?? `: an empty or relative APPDATA yielded the relative
+      // `npm\claude.cmd`. Candidates are probed before any lookup, so a relative
+      // candidate would resolve against the current directory and receive the live
+      // API key.
+      {
+        path: win.join(
+          absoluteEnvDir(appdata, () => defaultAppdata),
+          "npm",
+          "claude.cmd"
+        ),
+        trustedRoot: defaultAppdata
+      }
+    ];
+  }
+  return [
+    // Where the current native installer puts it (verified on a real install:
+    // ~/.local/bin/claude -> versions/2.1.220). Same reasoning as the Windows
+    // .local\bin\claude.exe entry — it also covers an install whose PATH entry is
+    // missing, which the lookup can never find. Without it, POSIX detection depended
+    // entirely on PATH.
+    {
+      path: path.posix.join(homedir2, ".local", "bin", "claude"),
+      trustedRoot: homedir2
+    },
+    {
+      path: path.posix.join(homedir2, ".claude", "local", "claude"),
+      trustedRoot: homedir2
+    },
+    { path: "/usr/local/bin/claude", trustedRoot: "/usr/local" },
+    { path: "/opt/homebrew/bin/claude", trustedRoot: "/opt/homebrew" }
+  ];
+}
+function pathIsInside(candidate, directory, pathApi) {
+  const relative = pathApi.relative(
+    pathApi.resolve(directory),
+    pathApi.resolve(candidate)
+  );
+  return relative === "" || !relative.startsWith(`..${pathApi.sep}`) && relative !== ".." && !pathApi.isAbsolute(relative);
+}
+function isNodeModulesBin(candidate) {
+  return /(^|[\\/])node_modules[\\/]\.bin([\\/]|$)/i.test(candidate);
+}
+function pickClaudeBinary(stdout, platform, cwd) {
+  if (platform === "win32") return null;
+  const hits = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  return hits.find(
+    (hit) => path.posix.isAbsolute(hit) && !isNodeModulesBin(hit) && (cwd === void 0 || !pathIsInside(hit, cwd, path.posix))
+  ) ?? null;
+}
+var PROJECT_BOUNDARY_MARKERS = [
+  ".git",
+  "package.json",
+  "pnpm-workspace.yaml",
+  "pnpm-lock.yaml",
+  "package-lock.json",
+  "yarn.lock",
+  "bun.lock",
+  "bun.lockb"
+];
+function projectBoundary(cwd, home2) {
+  let current = cwd;
+  let boundary = null;
+  while (true) {
+    if (current === home2) return boundary;
+    if (PROJECT_BOUNDARY_MARKERS.some(
+      (marker) => exists(path.join(current, marker))
+    )) {
+      boundary = current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) return boundary;
+    current = parent;
+  }
+}
+function trustedClaudeBinary(binary, cwd, home2, requiredRoot) {
+  try {
+    const canonicalBinary = fs.realpathSync.native(binary);
+    const canonicalCwd = fs.realpathSync.native(cwd);
+    let canonicalHome;
+    if (home2 !== void 0) {
+      try {
+        canonicalHome = fs.realpathSync.native(home2);
+      } catch {
+        canonicalHome = void 0;
+      }
+    }
+    const projectRoot = projectBoundary(canonicalCwd, canonicalHome);
+    const canonicalRequiredRoot = requiredRoot === void 0 ? void 0 : fs.realpathSync.native(requiredRoot);
+    if (isNodeModulesBin(canonicalBinary) || canonicalRequiredRoot !== void 0 && !pathIsInside(canonicalBinary, canonicalRequiredRoot, path) || projectRoot !== null && pathIsInside(canonicalBinary, projectRoot, path)) {
+      return null;
+    }
+    return canonicalBinary;
+  } catch {
+    return null;
+  }
+}
+var CMD_META = /[()\][%!^"`<>&|;, *?\t\n\v\r]/;
+function findClaudeBinary(options = {}) {
+  const platform = options.platform ?? process.platform;
+  let homedir2 = options.homedir;
+  if (homedir2 === void 0) {
+    try {
+      homedir2 = os.userInfo().homedir;
+    } catch {
+      homedir2 = null;
+    }
+  }
+  const appdata = options.appdata ?? process.env.APPDATA;
+  const cwd = options.cwd ?? process.cwd();
+  const candidates = homedir2 == null ? [] : claudeCandidates(platform, homedir2, appdata);
+  for (const candidate of candidates) {
+    if (!path.isAbsolute(candidate.path) && !path.win32.isAbsolute(candidate.path))
+      continue;
+    if (exists(candidate.path)) {
+      const trusted = trustedClaudeBinary(
+        candidate.path,
+        cwd,
+        homedir2 ?? void 0,
+        candidate.trustedRoot
+      );
+      if (trusted !== null) return trusted;
+    }
+  }
+  try {
+    if (platform === "win32") return null;
+    const out = execSync("command -v claude", {
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf8"
+    });
+    const binary = pickClaudeBinary(out, platform);
+    return binary === null ? null : trustedClaudeBinary(binary, cwd, homedir2 ?? void 0);
+  } catch {
+    return null;
+  }
+}
+function describeCommand(binary, args) {
+  const quote = (s) => /\s/.test(s) || CMD_META.test(s) ? `"${s}"` : s;
+  return [binary, ...args].map(quote).join(" ");
+}
+var KEY_PLACEHOLDER = "YOUR_RUNPOD_API_KEY";
+function describeCommandRedacted(binary, args) {
+  return describeCommand(
+    binary,
+    args.map(
+      (arg) => arg.startsWith("RUNPOD_API_KEY=") ? `RUNPOD_API_KEY=${KEY_PLACEHOLDER}` : arg
+    )
+  );
+}
+function redactSecret(text, secret) {
+  if (!secret) return text;
+  return text.split(secret).join(KEY_PLACEHOLDER);
+}
+function sanitizedClaudeEnv() {
+  const env = { ...process.env };
+  for (const key of Object.keys(env)) {
+    if (["path", "comspec", "pathext", "node_options", "node_path"].includes(
+      key.toLowerCase()
+    )) {
+      delete env[key];
+    }
+  }
+  if (process.platform === "win32") {
+    env.Path = path.dirname(process.execPath);
+  } else {
+    env.PATH = [
+      path.dirname(process.execPath),
+      "/usr/local/bin",
+      "/opt/homebrew/bin",
+      "/usr/bin",
+      "/bin"
+    ].join(path.delimiter);
+  }
+  return env;
+}
+function windowsNpmClaudeTarget(binary) {
+  if (process.platform !== "win32" || !binary.toLowerCase().endsWith(".cmd")) {
+    return null;
+  }
+  try {
+    const npmRoot = fs.realpathSync.native(path.dirname(binary));
+    const packageRoot = fs.realpathSync.native(
+      path.join(npmRoot, "node_modules", "@anthropic-ai", "claude-code")
+    );
+    if (!pathIsInside(packageRoot, npmRoot, path)) return null;
+    const manifestPath = fs.realpathSync.native(
+      path.join(packageRoot, "package.json")
+    );
+    if (!pathIsInside(manifestPath, packageRoot, path)) return null;
+    const manifest = JSON.parse(
+      fs.readFileSync(manifestPath, "utf8")
+    );
+    if (manifest === null || typeof manifest !== "object") return null;
+    const bin = manifest.bin;
+    const target = typeof bin === "string" ? bin : bin !== null && typeof bin === "object" ? bin.claude : void 0;
+    if (typeof target !== "string" || target.trim() === "") return null;
+    const entrypoint = fs.realpathSync.native(
+      path.resolve(packageRoot, target)
+    );
+    if (!pathIsInside(entrypoint, packageRoot, path)) return null;
+    if (/\.(?:exe|com)$/i.test(entrypoint)) {
+      return { command: entrypoint, argsPrefix: [] };
+    }
+    if (/\.(?:c?js|mjs)$/i.test(entrypoint)) {
+      return { command: process.execPath, argsPrefix: [entrypoint] };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function runClaude(binary, args, secret) {
+  const isWindowsCmd = process.platform === "win32" && binary.toLowerCase().endsWith(".cmd");
+  const npmTarget = windowsNpmClaudeTarget(binary);
+  if (isWindowsCmd && npmTarget === null) {
+    return {
+      success: false,
+      refused: true,
+      message: `could not locate a trusted Claude Code npm entrypoint beside ${binary}. Run the shim yourself, substituting your key:
+    ${describeCommandRedacted(binary, args)}`
+    };
+  }
+  const command = npmTarget?.command ?? binary;
+  const commandArgs = [...npmTarget?.argsPrefix ?? [], ...args];
+  const result = spawnSync(command, commandArgs, {
+    stdio: "pipe",
+    encoding: "utf8",
+    env: sanitizedClaudeEnv()
+  });
+  if (result.error)
+    return {
+      success: false,
+      message: redactSecret(errMessage(result.error), secret)
+    };
+  const stdio = `${result.stdout ?? ""}${result.stderr ?? ""}`;
+  if (result.status === 0) return { success: true, output: stdio };
+  if (result.status === null) {
+    return { success: false, message: `killed by ${result.signal}` };
+  }
+  if (stdio.includes("already exists")) {
+    return {
+      success: true,
+      // Deliberately not "to replace the API key": this branch is also reached in
+      // hosted mode, where there is no key — and the pre-existing entry may be of the
+      // other kind entirely, which is exactly what the user needs to know.
+      message: `already configured, existing entry left unchanged \u2014 it was NOT updated to what you just chose (to replace it, run \`${describeCommand(binary, ["mcp", "remove", SERVER_NAME, "--scope", "user"])}\` first, then re-run this wizard)`
+    };
+  }
+  return {
+    success: false,
+    message: redactSecret(
+      stdio.trim() || `${path.basename(binary)} exited with code ${result.status}`,
+      secret
+    )
+  };
+}
+function absoluteEnvDir(value, fallback) {
+  if (!value || !value.trim()) return fallback();
+  if (!path.isAbsolute(value) && !path.win32.isAbsolute(value))
+    return fallback();
+  return value;
+}
+function claudeUserConfigPath() {
+  const configured = process.env.CLAUDE_CONFIG_DIR;
+  return path.join(
+    configured ? path.resolve(configured) : os.homedir(),
+    ".claude.json"
+  );
+}
+function readClaudeConfigState(configPath) {
+  const unknown = {
+    configPath,
+    userScope: void 0,
+    localScopeDirs: []
+  };
+  if (!path.isAbsolute(configPath)) return unknown;
+  let raw;
+  try {
+    if (!fs.existsSync(configPath)) {
+      return { configPath, userScope: false, localScopeDirs: [] };
+    }
+    raw = fs.readFileSync(configPath, "utf8");
+  } catch {
+    return unknown;
+  }
+  const errors = [];
+  const parsed = jsonc.parse(raw.replace(/^\uFEFF/, ""), errors, {
+    allowTrailingComma: true
+  });
+  if (errors.length > 0 || typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return unknown;
+  }
+  const has = (servers) => typeof servers === "object" && servers !== null && Object.prototype.hasOwnProperty.call(servers, SERVER_NAME);
+  const own = (key) => Object.prototype.hasOwnProperty.call(parsed, key) ? parsed[key] : void 0;
+  const projects = own("projects");
+  const localScopeDirs = typeof projects === "object" && projects !== null && !Array.isArray(projects) ? Object.entries(projects).filter(([, project]) => has(project?.mcpServers)).map(([dir]) => dir) : [];
+  return { configPath, userScope: has(own("mcpServers")), localScopeDirs };
+}
+function describeDirs(dirs) {
+  if (dirs.length === 1) return dirs[0];
+  return `${dirs.length} project directories (${dirs.slice(0, 3).join(", ")}${dirs.length > 3 ? ", \u2026" : ""})`;
+}
+function interpretRemoveResult(result, state, binary = "claude") {
+  if (result.refused) return result;
+  const alsoElsewhere = state.localScopeDirs.length > 0 ? ` A separate local-scope ${SERVER_NAME} entry (which may carry its own API key) also exists in ${describeDirs(state.localScopeDirs)} \u2014 this wizard does not touch those. Remove with \`${describeCommand(binary, ["mcp", "remove", SERVER_NAME, "--scope", "local"])}\` from each.` : "";
+  if (state.userScope === true) {
+    return {
+      success: false,
+      message: `the ${SERVER_NAME} entry is STILL in Claude Code's user config (${state.configPath}), so your API key is still on disk. ${result.success ? "Most likely that file is not writable \u2014 the CLI reports success anyway." : `The removal command itself failed: ${result.message ?? "no output"}`}${alsoElsewhere}`
+    };
+  }
+  if (state.userScope === false) {
+    return {
+      success: true,
+      message: (result.success ? "removed from your user config" : "nothing to remove in your user config") + alsoElsewhere
+    };
+  }
+  if (result.success) {
+    return {
+      success: true,
+      message: `removal reported success, but ${state.configPath} could not be read to confirm it`
+    };
+  }
+  return { success: false, message: result.message };
+}
+function interpretAddResult(result, state, binary) {
+  if (result.refused || !result.success) return result;
+  if (state.userScope === false) {
+    return {
+      success: false,
+      message: `Claude Code reported success but no ${SERVER_NAME} entry is in its user config afterwards (${state.configPath}) \u2014 that file is most likely not writable. Nothing was configured.`
+    };
+  }
+  if (state.userScope === true && state.localScopeDirs.length > 0) {
+    return {
+      success: true,
+      message: `${result.message ? `${result.message}; ` : ""}note a local-scope ${SERVER_NAME} entry also exists in ${describeDirs(state.localScopeDirs)} and takes precedence over the user config there, so Claude Code will keep using it in those projects \u2014 remove it with \`${describeCommand(binary, ["mcp", "remove", SERVER_NAME, "--scope", "local"])}\` run from each`
+    };
+  }
+  if (state.userScope === void 0) {
+    return {
+      success: true,
+      message: `${result.message ? `${result.message}; ` : ""}could not read ${state.configPath} to confirm the entry landed`
+    };
+  }
+  return { success: true, message: result.message };
+}
+function createClaudeCodeClient(resolveBinary, readState = () => readClaudeConfigState(claudeUserConfigPath())) {
+  return {
+    id: "claude-code",
+    name: "Claude Code",
+    detect: () => Promise.resolve(resolveBinary() !== null),
+    add: (mode) => {
+      const args = mode.kind === "local" ? [
+        "mcp",
+        "add",
+        SERVER_NAME,
+        "--scope",
+        "user",
+        "-e",
+        `RUNPOD_API_KEY=${mode.apiKey}`,
+        "--",
+        "npx",
+        "-y",
+        NPM_PACKAGE
+      ] : [
+        "mcp",
+        "add",
+        "--transport",
+        "http",
+        "--scope",
+        "user",
+        SERVER_NAME,
+        mode.url
+      ];
+      const binary = resolveBinary();
+      if (!binary) {
+        return Promise.resolve({
+          success: false,
+          message: `claude CLI not found in the standard install locations. If Claude Code is installed somewhere custom, register it yourself${mode.kind === "local" ? ", substituting your key" : ""}:
+    ${describeCommandRedacted("claude", args)}`
+        });
+      }
+      const result = runClaude(
+        binary,
+        args,
+        mode.kind === "local" ? mode.apiKey : void 0
+      );
+      if (!result.success) return Promise.resolve(result);
+      return Promise.resolve(interpretAddResult(result, readState(), binary));
+    },
+    remove: () => {
+      const binary = resolveBinary();
+      if (!binary) {
+        return Promise.resolve({
+          success: false,
+          message: `claude CLI not found in the standard install locations. If Claude Code is installed somewhere custom, remove the entry yourself:
+    ${describeCommand("claude", ["mcp", "remove", SERVER_NAME, "--scope", "user"])}`
+        });
+      }
+      const result = runClaude(binary, [
+        "mcp",
+        "remove",
+        "--scope",
+        "user",
+        SERVER_NAME
+      ]);
+      if (result.refused) return Promise.resolve(result);
+      return Promise.resolve(
+        interpretRemoveResult(result, readState(), binary)
+      );
+    },
+    describeTarget: () => "Claude Code user config (via `claude mcp` CLI)"
+  };
+}
+var claudeCodeClient = createClaudeCodeClient(findClaudeBinary);
+var home = os.homedir();
+function appDataDir() {
+  return absoluteEnvDir(
+    process.env.APPDATA,
+    () => path.join(home, "AppData", "Roaming")
+  );
+}
+function claudeDesktopConfigPath() {
+  if (process.platform === "win32") {
+    return path.join(appDataDir(), "Claude", "claude_desktop_config.json");
+  }
+  if (process.platform === "darwin") {
+    return path.join(
+      home,
+      "Library",
+      "Application Support",
+      "Claude",
+      "claude_desktop_config.json"
+    );
+  }
+  return path.join(
+    absoluteEnvDir(
+      process.env.XDG_CONFIG_HOME,
+      () => path.join(home, ".config")
+    ),
+    "Claude",
+    "claude_desktop_config.json"
+  );
+}
+function vsCodeConfigPath() {
+  if (process.platform === "win32") {
+    return path.join(appDataDir(), "Code", "User", "mcp.json");
+  }
+  if (process.platform === "darwin") {
+    return path.join(
+      home,
+      "Library",
+      "Application Support",
+      "Code",
+      "User",
+      "mcp.json"
+    );
+  }
+  return path.join(
+    absoluteEnvDir(
+      process.env.XDG_CONFIG_HOME,
+      () => path.join(home, ".config")
+    ),
+    "Code",
+    "User",
+    "mcp.json"
+  );
+}
+var CLIENTS = [
+  claudeCodeClient,
+  jsonClient({
+    id: "cursor",
+    name: "Cursor",
+    // A VS Code fork, and its MCP reader keeps VS Code's tolerance — comments and
+    // trailing commas both parse. Read out of the shipped bundle, not assumed from
+    // "Electron app"; see ConfigDialect.
+    dialect: "jsonc",
+    configPath: () => path.join(home, ".cursor", "mcp.json")
+  }),
+  jsonClient({
+    id: "windsurf",
+    name: "Windsurf",
+    // Not installed on any machine this was checked on, so its parser was never read.
+    // Lenient-and-disclosed rather than a guess in either direction.
+    dialect: "unverified",
+    // Windsurf is stdio-only, so it reaches the hosted server via mcp-remote.
+    hostedStrategy: "mcp-remote",
+    configPath: () => path.join(home, ".codeium", "windsurf", "mcp_config.json")
+  }),
+  jsonClient({
+    id: "claude-desktop",
+    name: "Claude Desktop",
+    // Genuinely strict: its reader is a bare `JSON.parse(readFileSync(...))` with no
+    // preprocessing and no retry, so a comment or trailing comma is fatal.
+    dialect: "json",
+    // Claude Desktop config files are stdio-only; use the mcp-remote bridge.
+    hostedStrategy: "mcp-remote",
+    configPath: claudeDesktopConfigPath,
+    // Detect by the application/support directory, which exists once the app runs.
+    detectPaths: () => [path.dirname(claudeDesktopConfigPath())]
+  }),
+  jsonClient({
+    id: "vscode",
+    name: "Visual Studio Code",
+    serverProperty: "servers",
+    // The one client that genuinely reads JSONC — comments and trailing commas in
+    // mcp.json are supported and common.
+    dialect: "jsonc",
+    configPath: vsCodeConfigPath,
+    detectPaths: () => [path.dirname(vsCodeConfigPath())]
+  })
+];
+
+// src/install/verify-key.ts
+var VERIFY_API_KEY_TIMEOUT_MS = 1e4;
+async function verifyApiKey(apiKey, timeoutMs = VERIFY_API_KEY_TIMEOUT_MS) {
+  try {
+    const base = process.env.RUNPOD_REST_API_URL ?? "https://rest.runpod.io/v1";
+    const response = await fetch(`${base}/pods`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      // Without this the wizard sits at "Verifying…" forever against a host
+      // that accepts the connection and goes quiet, with no way out but ^C.
+      // An abort lands in the catch below and is reported as "check failed",
+      // which is exactly what it is.
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (response.ok) return true;
+    if (response.status === 401 || response.status === 403) return false;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/install/wizard.ts
+var API_KEYS_URL = "https://www.runpod.io/console/user/settings";
+function openBrowser(url) {
+  try {
+    if (process.platform === "darwin") {
+      execFileSync("open", [url], { stdio: "ignore" });
+    } else if (process.platform === "win32") {
+      execFileSync("cmd", ["/c", "start", "", url], { stdio: "ignore" });
+    } else {
+      execFileSync("xdg-open", [url], { stdio: "ignore" });
+    }
+  } catch {
+  }
+}
+function bail(message = "Cancelled.") {
+  p.cancel(message);
+  process.exit(0);
+}
+async function promptForApiKey() {
+  const fromEnv = process.env.RUNPOD_API_KEY?.trim();
+  if (fromEnv) {
+    const useEnv = await p.confirm({
+      message: "Use the RUNPOD_API_KEY from your environment?"
+    });
+    if (p.isCancel(useEnv)) bail();
+    if (useEnv) return fromEnv;
+  }
+  const create = await p.confirm({
+    message: "Open the Runpod console to create or copy an API key?"
+  });
+  if (p.isCancel(create)) bail();
+  if (create) {
+    openBrowser(API_KEYS_URL);
+    p.log.info(`Opening ${API_KEYS_URL}`);
+  }
+  const apiKey = await p.password({
+    message: "Paste your Runpod API key",
+    validate: (value) => !value || value.trim().length === 0 ? "API key cannot be empty" : void 0
+  });
+  if (p.isCancel(apiKey)) bail();
+  return apiKey.trim();
+}
+async function selectClients(detected, verb) {
+  const options = CLIENTS.map((client) => ({
+    value: client.id,
+    label: client.name,
+    hint: detected.get(client.id) ? "detected" : void 0
+  }));
+  const selected = await p.multiselect({
+    message: `Which agents should we ${verb}?`,
+    options,
+    // Pre-select detected clients so the common case is a single Enter press.
+    initialValues: CLIENTS.filter((c) => detected.get(c.id)).map((c) => c.id),
+    required: true
+  });
+  if (p.isCancel(selected)) bail();
+  return CLIENTS.filter((c) => selected.includes(c.id));
+}
+async function detectAll() {
+  const entries = await Promise.all(
+    CLIENTS.map(async (c) => [c.id, await c.detect()])
+  );
+  return new Map(entries);
+}
+async function selectMode() {
+  const kind = await p.select({
+    message: "How do you want to connect to Runpod?",
+    options: [
+      {
+        value: "hosted",
+        label: "Sign in with Runpod (recommended)",
+        hint: "hosted, OAuth, no API key stored"
+      },
+      {
+        value: "local",
+        label: "Run locally with an API key",
+        hint: "runs on this machine via npx"
+      }
+    ],
+    initialValue: "hosted"
+  });
+  if (p.isCancel(kind)) bail();
+  if (kind === "hosted") {
+    return { kind: "hosted", url: HOSTED_URL };
+  }
+  const apiKey = await promptForApiKey();
+  const verifySpinner = p.spinner();
+  verifySpinner.start("Verifying API key");
+  const valid = await verifyApiKey(apiKey);
+  if (valid === true) {
+    verifySpinner.stop("API key verified.");
+  } else if (valid === false) {
+    verifySpinner.stop("API key rejected by Runpod.");
+    const proceed = await p.confirm({
+      message: "The key did not authenticate. Continue anyway?",
+      initialValue: false
+    });
+    if (p.isCancel(proceed) || !proceed) bail();
+  } else {
+    verifySpinner.stop("Could not verify the key (offline?). Continuing.");
+  }
+  return { kind: "local", apiKey };
+}
+async function runAdd() {
+  const detected = await detectAll();
+  const clients = await selectClients(detected, "set up");
+  const mode = await selectMode();
+  const results = [];
+  for (const client of clients) {
+    const spinner2 = p.spinner();
+    spinner2.start(`Configuring ${client.name}`);
+    const result = await client.add(mode);
+    if (result.success) {
+      spinner2.stop(`${client.name} configured.`);
+      results.push(
+        `\u2713 ${client.name} \u2014 ${result.message ? `${result.message}; ` : ""}${client.describeTarget()}`
+      );
+    } else {
+      spinner2.stop(`${client.name} failed.`);
+      results.push(`\u2717 ${client.name} \u2014 ${result.message ?? "unknown error"}`);
+    }
+  }
+  p.note(results.join("\n"), "Results");
+  p.outro(
+    mode.kind === "hosted" ? 'Restart your agent, then complete "Sign in with Runpod" when it connects.' : "Restart your agent (or reconnect MCP) to load the Runpod tools."
+  );
+}
+async function runRemove() {
+  const detected = await detectAll();
+  const clients = await selectClients(detected, "remove Runpod from");
+  const results = [];
+  for (const client of clients) {
+    const spinner2 = p.spinner();
+    spinner2.start(`Removing from ${client.name}`);
+    const result = await client.remove();
+    spinner2.stop(
+      result.success ? `${client.name} cleaned up.` : `${client.name} failed.`
+    );
+    results.push(
+      `${result.success ? "\u2713" : "\u2717"} ${client.name}${result.message ? ` \u2014 ${result.message}` : ""}`
+    );
+  }
+  p.note(results.join("\n"), "Results");
+  p.outro("Done.");
+}
+async function runWizard(subcommand) {
+  p.intro("Runpod MCP server installer");
+  if (subcommand === "remove") {
+    await runRemove();
+  } else {
+    await runAdd();
+  }
+}
+export {
+  runWizard
+};
+//# sourceMappingURL=wizard-FBLOZ6YM.mjs.map