@njuptlzf/mcp-adapter 2.29.0-0.0.1

package/bin/mcp-server.ts

@@ -0,0 +1,282 @@
+#!/usr/bin/env npx tsx
+/**
+ * bin/mcp-server.ts — Universal MCP stdio server entry point.
+ *
+ * Stage 2 (fork-host, not fork-engine): this entry point now installs the
+ * UPSTREAM engine (`index.ts`'s `createMcpAdapter`) onto a `UniversalMcpHost`
+ * that presents the Pi `ExtensionAPI` surface. The fork's parallel engine
+ * (`adapters/entry.ts`) is no longer used here.
+ *
+ * D-04/D-05: the host is agent-agnostic; no per-agent adapter import.
+ * D-06/D-07: protocol forwarders are injected when the Agent Client declares
+ *   sampling/elicitation capabilities.
+ * D-11: pure forwarding — no config.settings checks. Client capability
+ *   declaration is the only gate.
+ *
+ * Pitfall 1 (flow reordering): MCP Server is created and connected BEFORE
+ *   fireSessionStart(), enabling runtime capability discovery and forwarder
+ *   injection before initializeMcp() runs.
+ * Pitfall 5: Uses server.getClientCapabilities() NOT the server's own
+ *   capabilities method.
+ * Pitfall 4: Sets ctx.hasUI = true when forwarders are injected, satisfying
+ *   init.ts conditions without modifying init.ts.
+ *
+ * Usage:
+ *   mcp-server                           # auto-discover .mcp.json
+ *   mcp-server --config /path/to/mcp.json # explicit config path
+ *   mcp-server --help                     # show usage
+ *
+ * Registration in agent config:
+ *   {
+ *     "mcpServers": {
+ *       "mcp-adapter": {
+ *         "command": "mcp-server"
+ *       }
+ *     }
+ *   }
+ *
+ * This file is fork-only (upstream has no bin/ directory).
+ */
+
+import { createMcpAdapter } from "../index.ts";
+import { UniversalMcpHost } from "../adapters/universal-host.ts";
+import { ProtocolSamplingForwarder } from "../adapters/protocol-sampling-forwarder.ts";
+import { ProtocolElicitationForwarder } from "../adapters/protocol-elicitation-forwarder.ts";
+import { loadMcpConfig } from "../config.ts";
+import { createUniversalResolver } from "../interfaces/agent-paths.ts";
+import type { AgentChannel, FormConfig, UISystem } from "../interfaces/host-types.ts";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+	CallToolRequestSchema,
+	ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+const SERVER_NAME = "mcp-adapter";
+const SERVER_VERSION = "2.29.0-0.0.1";
+const GENERIC_GLOBAL_CONFIG_PATH = createUniversalResolver().globalConfigPath();
+
+// ---------------------------------------------------------------------------
+// CLI argument parsing
+// ---------------------------------------------------------------------------
+
+function showHelp(): void {
+	console.log(`
+Usage: mcp-server [options]
+
+Universal MCP stdio server — bridges mcp-adapter proxy tool into any
+MCP-compatible agent via stdio transport.
+
+Options:
+  --config <path>   Path to mcp.json config file
+  --help            Show this help message
+  --version         Show version
+
+Environment:
+  MCP_CONFIG_PATH   Alternative way to specify config path
+
+Config discovery (in priority order):
+  1. --config flag
+  2. MCP_CONFIG_PATH env var
+  3. .mcp.json in current working directory
+  4. ~/.config/mcp/mcp.json (shared global)
+`);
+}
+
+function parseArgs(argv: string[]): { configPath?: string; showHelp: boolean; showVersion: boolean } {
+	let configPath: string | undefined;
+	let showHelp = false;
+	let showVersion = false;
+
+	for (let i = 2; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--help" || arg === "-h") {
+			showHelp = true;
+		} else if (arg === "--version" || arg === "-v") {
+			showVersion = true;
+		} else if (arg === "--config") {
+			configPath = argv[++i];
+			if (!configPath) {
+				console.error("Error: --config requires a path argument");
+				process.exit(1);
+			}
+		} else if (arg.startsWith("--config=")) {
+			configPath = arg.slice("--config=".length);
+		} else {
+			console.error(`Unknown option: ${arg}`);
+			console.error("Run 'mcp-server --help' for usage.");
+			process.exit(1);
+		}
+	}
+
+	// Fall back to env var if no --config flag (D-02: universal config path discovery)
+	if (!configPath && process.env.MCP_CONFIG_PATH) {
+		configPath = process.env.MCP_CONFIG_PATH;
+	}
+
+	return { configPath, showHelp, showVersion };
+}
+
+// ---------------------------------------------------------------------------
+// main() — reordered flow per Pitfall 1
+// ---------------------------------------------------------------------------
+
+async function main(): Promise<void> {
+	// Step 1: Parse args, handle help/version
+	const args = parseArgs(process.argv);
+
+	if (args.showHelp) {
+		showHelp();
+		return;
+	}
+
+	if (args.showVersion) {
+		console.log(SERVER_VERSION);
+		return;
+	}
+
+	// Step 2: Load config using universal resolver (D-02: no agent-specific paths).
+	// The upstream engine loads metadata cache itself; here we only pre-load
+	// config for the startup log and pass it programmatically.
+	const config = loadMcpConfig(args.configPath, process.cwd(), GENERIC_GLOBAL_CONFIG_PATH);
+	const serverCount = Object.keys(config.mcpServers || {}).length;
+	console.error(`[mcp-server] Config loaded: ${serverCount} server(s) configured`);
+
+	if (serverCount === 0) {
+		console.error("[mcp-server] Warning: no MCP servers configured. Create a .mcp.json file or use --config <path>.");
+	}
+
+	// Step 3: Install the UPSTREAM engine onto a UniversalMcpHost (Stage 2).
+	const host = new UniversalMcpHost();
+	const install = createMcpAdapter({ config });
+	install(host);
+
+	// Step 4: Attach AgentChannel — routes host sendMessage to stderr
+	// (MCP stdio uses stdout for protocol; stderr is for diagnostics)
+	const channel: AgentChannel = {
+		send: (msg: unknown) => {
+			const text = typeof msg === "string" ? msg : JSON.stringify(msg);
+			console.error(`[mcp-server] adapter message: ${text}`);
+		},
+	};
+	host.attachChannel(channel);
+
+	// Step 5: Create MCP Server
+	const server = new Server(
+		{ name: SERVER_NAME, version: SERVER_VERSION },
+		{ capabilities: { tools: {} } },
+	);
+
+	// Step 6: Set request handlers (ListTools filtered to the active tool surface)
+	server.setRequestHandler(ListToolsRequestSchema, async () => {
+		const active = host.getActiveTools();
+		const visibleNames = active.length > 0 ? active : [...host.tools.keys()];
+		const mcpTools = visibleNames
+			.map((name) => host.tools.get(name))
+			.filter((tool): tool is NonNullable<typeof tool> => Boolean(tool))
+			.map((tool) => ({
+				name: tool.name,
+				description: tool.description || `MCP proxy tool: ${tool.name}`,
+				inputSchema: tool.parameters || { type: "object", properties: {} },
+			}));
+		console.error(`[mcp-server] list-tools: ${mcpTools.length} tools`);
+		return { tools: mcpTools };
+	});
+
+	// The context is built before the transport handshake so capability
+	// discovery can mutate it (Pitfall 4) before fireSessionStart() consumes it.
+	const ctx = {
+		cwd: process.cwd(),
+		hasUI: false,
+		mode: undefined as string | undefined,
+		ui: undefined as UISystem | undefined,
+		modelRegistry: undefined as unknown,
+		model: undefined as unknown,
+		signal: undefined as AbortSignal | undefined,
+		reload: undefined as (() => Promise<void>) | undefined,
+		samplingProvider: undefined as unknown,
+	};
+
+	server.setRequestHandler(CallToolRequestSchema, async (request) => {
+		const { name, arguments: callArgs } = request.params;
+		const tool = host.tools.get(name);
+		if (!tool) {
+			throw new Error(`Unknown tool: ${name}`);
+		}
+		try {
+			const result = await tool.execute(
+				`call-${Date.now()}`,
+				callArgs || {},
+				undefined,
+				undefined,
+				ctx,
+			);
+			// Upstream engine tools return MCP-shaped results ({ content: [...] });
+			// pass those through verbatim and stringify anything else.
+			if (result && typeof result === "object" && "content" in result) {
+				return result;
+			}
+			const text = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+			return { content: [{ type: "text" as const, text }] };
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			return {
+				content: [{ type: "text" as const, text: `Error: ${message}` }],
+				isError: true,
+			};
+		}
+	});
+
+	// Step 7: CRITICAL — Connect transport BEFORE fireSessionStart (Pitfall 1)
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+
+	// Step 8: CRITICAL — Check client capabilities via getClientCapabilities() (Pitfall 5)
+	const clientCaps = server.getClientCapabilities();
+
+	// Step 9: If client declares sampling capability — inject ProtocolSamplingForwarder
+	// D-11: No config.settings.sampling check — pure forwarding.
+	if (clientCaps?.sampling) {
+		const samplingForwarder = new ProtocolSamplingForwarder(server);
+		ctx.samplingProvider = samplingForwarder;
+		// Pitfall 4: Set hasUI so init.ts sampling condition passes
+		ctx.hasUI = true;
+		console.error("[mcp-server] Sampling capability detected — ProtocolSamplingForwarder injected");
+	}
+
+	// Step 10: If client declares elicitation.form capability — inject ProtocolElicitationForwarder
+	// D-11: No config.settings.elicitation check — pure forwarding.
+	if (clientCaps?.elicitation?.form) {
+		const elicitationForwarder = new ProtocolElicitationForwarder(server);
+		const ui: UISystem = {
+			notify: (message: string, level: "info" | "warning" | "error"): void => {
+				const consoleMethod: "info" | "warn" | "error" =
+					level === "error" ? "error" : level === "warning" ? "warn" : "info";
+				console[consoleMethod](`[mcp-server] ${message}`);
+			},
+			form: (config: FormConfig) => elicitationForwarder.form(config),
+		};
+		ctx.ui = ui;
+		// Pitfall 4: Set hasUI so init.ts elicitation condition passes
+		ctx.hasUI = true;
+		console.error("[mcp-server] Elicitation.form capability detected — ProtocolElicitationForwarder injected");
+	}
+
+	// Step 11: Fire session_start — triggers initializeMcp which reads ctx
+	// with forwarders injected. T-12-11: wrap in try/catch, non-fatal.
+	try {
+		await host.fireSessionStart(ctx);
+		console.error("[mcp-server] Session started, lazy connections initialized");
+	} catch (err) {
+		console.error(`[mcp-server] Session start error: ${(err as Error).message}`);
+		// Non-fatal — servers connect lazily on first tool call
+	}
+
+	// Step 12: Server ready
+	console.error("[mcp-server] MCP server ready via stdio");
+}
+
+main().catch((err: unknown) => {
+	console.error(`[mcp-server] Fatal error: ${err instanceof Error ? err.message : String(err)}`);
+	process.exit(1);
+});

package/cli.js

@@ -0,0 +1,392 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { pathToFileURL } from "node:url";
+import stripJsonComments from "strip-json-comments";
+
+const HOME = os.homedir();
+
+function expandHome(input) {
+  if (input === "~") return HOME;
+  if (input.startsWith("~/")) return path.resolve(HOME, input.slice(2));
+  return path.resolve(input);
+}
+
+function readPiConfig() {
+  const dir = process.env.PI_PACKAGE_DIR?.trim();
+  if (!dir) return undefined;
+  try {
+    return JSON.parse(fs.readFileSync(path.join(path.resolve(dir), "package.json"), "utf8")).piConfig;
+  } catch {
+    return undefined;
+  }
+}
+
+function getConfigDirName() {
+  const configDir = readPiConfig()?.configDir;
+  return typeof configDir === "string" && configDir.trim() ? configDir.trim() : ".pi";
+}
+
+function getAgentDir() {
+  const piConfig = readPiConfig();
+  const appName = typeof piConfig?.name === "string" && piConfig.name.trim() ? piConfig.name.trim() : "pi";
+  const configured = process.env[`${appName.toUpperCase()}_CODING_AGENT_DIR`]?.trim();
+  if (configured) return expandHome(configured);
+  return path.join(HOME, getConfigDirName(), "agent");
+}
+
+const AGENT_DIR = getAgentDir();
+const PI_CONFIG_PATH = path.join(AGENT_DIR, "mcp.json");
+const GENERIC_GLOBAL_CONFIG_PATH = path.join(HOME, ".config", "mcp", "mcp.json");
+const AGENTS_GLOBAL_CONFIG_PATH = path.join(HOME, ".agents", "mcp.json");
+const AGENTS_NESTED_GLOBAL_CONFIG_PATH = path.join(HOME, ".agents", "mcp", "mcp.json");
+const PROJECT_CONFIG_PATH = path.resolve(process.cwd(), ".mcp.json");
+const PROJECT_PI_CONFIG_PATH = path.resolve(process.cwd(), getConfigDirName(), "mcp.json");
+
+const IMPORT_PATHS = {
+  cursor: [path.join(HOME, ".cursor", "mcp.json")],
+  "claude-code": [
+    path.join(HOME, ".claude", "mcp.json"),
+    path.join(HOME, ".claude.json"),
+    path.join(HOME, ".claude", "claude_desktop_config.json"),
+  ],
+  "claude-desktop": [path.join(HOME, "Library", "Application Support", "Claude", "claude_desktop_config.json")],
+  codex: [
+    path.join(HOME, ".codex", "config.toml"),
+    path.join(HOME, ".codex", "config.json"),
+  ],
+  opencode: [
+    path.join(HOME, ".config", "opencode", "opencode.json"),
+    path.resolve(process.cwd(), "opencode.json"),
+  ],
+  windsurf: [path.join(HOME, ".windsurf", "mcp.json")],
+  vscode: [path.resolve(process.cwd(), ".vscode", "mcp.json")],
+};
+
+function printHelp(log = console.log) {
+  log("pi-mcp-adapter helper\n");
+  log("Install the package with:");
+  log("  pi install npm:pi-mcp-adapter\n");
+  log("Then optionally run:");
+  log("  pi-mcp-adapter init       Detect host configs and scaffold Pi imports");
+  log("  pi-mcp-adapter init --dry-run");
+  log("  pi-mcp-adapter init --discover-host-configs  Opt in to host config fallback discovery");
+  log("");
+  log("Bearer token storage (servers configured with auth: \"bearer\" and bearerTokenStore: true):");
+  log("  pi-mcp-adapter token set <server>     Store a token read from stdin (masked prompt or pipe; never argv)");
+  log("  pi-mcp-adapter token status <server>  Report whether a stored token matches the configured URL");
+  log("  pi-mcp-adapter token remove <server>  Remove the stored token");
+}
+
+function readJsonFile(filePath) {
+  return JSON.parse(stripJsonComments(fs.readFileSync(filePath, "utf-8"), { trailingCommas: true }));
+}
+
+function loadPiConfig() {
+  if (!fs.existsSync(PI_CONFIG_PATH)) {
+    return { mcpServers: {} };
+  }
+
+  const raw = readJsonFile(PI_CONFIG_PATH);
+  const mcpServers = raw.mcpServers ?? raw["mcp-servers"] ?? {};
+  if (!mcpServers || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
+    throw new Error(`Invalid MCP config at ${PI_CONFIG_PATH}: expected \"mcpServers\" to be an object`);
+  }
+
+  const normalized = { ...raw };
+  delete normalized["mcp-servers"];
+
+  const imports = Array.isArray(raw.imports) ? raw.imports.filter((value) => typeof value === "string") : undefined;
+  return {
+    ...normalized,
+    mcpServers,
+    imports,
+  };
+}
+
+function findAvailableImports() {
+  const found = [];
+
+  for (const [kind, candidates] of Object.entries(IMPORT_PATHS)) {
+    const existing = candidates.find((candidate) => fs.existsSync(candidate));
+    if (existing) {
+      found.push({ kind, path: existing });
+    }
+  }
+
+  return found;
+}
+
+function printDiscovery(log, imports) {
+  log("Config discovery:\n");
+
+  const paths = [
+    ["User-global standard MCP", GENERIC_GLOBAL_CONFIG_PATH],
+    ["User-global .agents MCP", AGENTS_GLOBAL_CONFIG_PATH],
+    ["User-global .agents nested MCP", AGENTS_NESTED_GLOBAL_CONFIG_PATH],
+    ["Pi global override", PI_CONFIG_PATH],
+    ["Project standard MCP", PROJECT_CONFIG_PATH],
+    ["Project Pi override", PROJECT_PI_CONFIG_PATH],
+  ];
+
+  for (const [label, filePath] of paths) {
+    const prefix = fs.existsSync(filePath) ? "✓" : "-";
+    log(`${prefix} ${label}: ${filePath}`);
+  }
+
+  log("\nCompatibility imports:\n");
+  if (imports.length === 0) {
+    log("- No host-specific MCP configs detected");
+    return;
+  }
+
+  for (const entry of imports) {
+    log(`✓ ${entry.kind}: ${entry.path}`);
+  }
+}
+
+function writePiConfig(config) {
+  fs.mkdirSync(path.dirname(PI_CONFIG_PATH), { recursive: true });
+  fs.writeFileSync(PI_CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
+}
+
+async function runInit(argv, log = console.log) {
+  const dryRun = argv.includes("--dry-run");
+  const discoverHostConfigs = argv.includes("--discover-host-configs");
+  const foundImports = findAvailableImports();
+  const existingConfig = loadPiConfig();
+  const existingImports = new Set(existingConfig.imports ?? []);
+  const importsToAdd = foundImports
+    .map((entry) => entry.kind)
+    .filter((kind) => !existingImports.has(kind));
+
+  printDiscovery(log, foundImports);
+
+  const discoverySettingChanged = discoverHostConfigs && existingConfig.settings?.hostConfigDiscovery !== "on";
+  if (importsToAdd.length === 0 && !discoverySettingChanged) {
+    log("\nNo Pi config changes needed.");
+    log("Standard MCP configs are discovered automatically, and host-specific imports are already configured or unavailable.");
+    return 0;
+  }
+
+  const nextConfig = {
+    ...existingConfig,
+    ...(discoverySettingChanged ? { settings: { ...existingConfig.settings, hostConfigDiscovery: "on" } } : {}),
+    ...(importsToAdd.length > 0 ? { imports: [...existingImports, ...importsToAdd] } : {}),
+    mcpServers: existingConfig.mcpServers ?? {},
+  };
+
+  if (importsToAdd.length > 0) {
+    log(`\nDetected host configs to import into Pi: ${importsToAdd.join(", ")}`);
+  }
+  if (discoverySettingChanged) {
+    log("Opting in to host-specific fallback discovery (standard and Pi-owned configs still take precedence).");
+  }
+
+  if (dryRun) {
+    log(`Dry run: would update ${PI_CONFIG_PATH}`);
+    return 0;
+  }
+
+  writePiConfig(nextConfig);
+  log(`Updated ${PI_CONFIG_PATH}`);
+  log("Pi will now keep reading standard MCP configs automatically, while these imports cover host-specific config formats.");
+  if (discoverySettingChanged) {
+    log("Host config discovery is explicit and does not write to or execute commands from external host files.");
+  }
+  return 0;
+}
+
+async function importTokenModules(error) {
+  try {
+    const [store, config, utils] = await Promise.all([
+      import("./mcp-bearer-store.ts"),
+      import("./config.ts"),
+      import("./utils.ts"),
+    ]);
+    return { store, config, utils };
+  } catch (err) {
+    error("Token commands need a Node.js version that can load TypeScript modules (Node 22.18+ or 23+).");
+    error(`Import failed: ${err instanceof Error ? err.message : String(err)}`);
+    return undefined;
+  }
+}
+
+function readTokenFromStdin(stdin) {
+  if (stdin.isTTY) return readTokenMasked(stdin);
+  return new Promise((resolve, reject) => {
+    let data = "";
+    stdin.setEncoding("utf8");
+    stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    stdin.on("end", () => resolve(data.replace(/[\r\n]+$/, "")));
+    stdin.on("error", reject);
+  });
+}
+
+// Raw-mode masked prompt: the token never echoes to the terminal.
+function readTokenMasked(stdin) {
+  return new Promise((resolve, reject) => {
+    process.stderr.write("Enter bearer token (input hidden): ");
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    let token = "";
+    const onData = (chunk) => {
+      for (const char of chunk) {
+        if (char === "\u0003") {
+          cleanup();
+          reject(new Error("Token entry cancelled"));
+          return;
+        }
+        if (char === "\r" || char === "\n") {
+          cleanup();
+          resolve(token);
+          return;
+        }
+        if (char === "\u007f" || char === "\b") {
+          token = token.slice(0, -1);
+          continue;
+        }
+        token += char;
+      }
+    };
+    const cleanup = () => {
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.off("data", onData);
+      process.stderr.write("\n");
+    };
+    stdin.on("data", onData);
+  });
+}
+
+async function runToken(argv, log, error, stdin) {
+  const [action, serverName, ...extra] = argv;
+  if (!["set", "status", "remove"].includes(action) || !serverName) {
+    error("Usage: pi-mcp-adapter token <set|status|remove> <server>");
+    error("`token set` reads the token from stdin only. Never pass the token as an argument.");
+    return 1;
+  }
+  if (extra.length > 0) {
+    error("Unexpected extra arguments. The token must not be passed on the command line; pipe it on stdin or use the interactive prompt.");
+    return 1;
+  }
+
+  const modules = await importTokenModules(error);
+  if (!modules) return 1;
+
+  // Argv-derived text is sanitized before terminal output, and the resolved
+  // URL is never printed: it can embed userinfo or interpolated secrets.
+  const safeName = modules.utils.sanitizeTerminalText(serverName);
+  const definition = modules.config.loadMcpConfig(undefined, process.cwd()).mcpServers[serverName];
+  if (!definition) {
+    error(`Server "${safeName}" not found in the effective MCP config.`);
+    return 1;
+  }
+  if (definition.auth !== "bearer" || definition.bearerTokenStore !== true) {
+    error(`Server "${safeName}" is not configured for bearerTokenStore. Set "auth": "bearer" and "bearerTokenStore": true.`);
+    return 1;
+  }
+  // resolveServerUrl embeds the interpolated URL in its exceptions, so catch
+  // and redact: the URL can carry userinfo or interpolated secrets.
+  let serverUrl;
+  try {
+    serverUrl = modules.utils.resolveServerUrl(definition);
+  } catch {
+    error(`Server "${safeName}" has an invalid or unresolvable URL. Fix the server's url in the MCP config and retry.`);
+    return 1;
+  }
+  if (!serverUrl) {
+    error(`Server "${safeName}" has no URL configured.`);
+    return 1;
+  }
+
+  if (action === "set") {
+    const token = await readTokenFromStdin(stdin);
+    if (!token) {
+      error("No token provided on stdin.");
+      return 1;
+    }
+    try {
+      modules.store.saveBearerTokenForUrl(serverName, token, serverUrl);
+    } catch (err) {
+      error(modules.utils.sanitizeTerminalText(err instanceof Error ? err.message : String(err)));
+      return 1;
+    }
+    log(`Bearer token stored for "${safeName}" and bound to the configured server URL.`);
+    if (definition.bearerToken !== undefined || definition.bearerTokenEnv !== undefined) {
+      log("Note: this server also configures bearerToken or bearerTokenEnv, which take precedence over the stored token.");
+    }
+    return 0;
+  }
+
+  if (action === "status") {
+    const status = modules.store.inspectBearerTokenForUrl(serverName, serverUrl);
+    if (status.status === "present") {
+      log(`Bearer token is stored for "${safeName}".`);
+      return 0;
+    }
+    if (status.status === "url-mismatch") {
+      log(`Bearer token is stored for "${safeName}", but its URL does not match the current server URL. Run \`pi-mcp-adapter token set ${safeName}\` to rebind it.`);
+      return 1;
+    }
+    if (status.status === "unavailable") {
+      error(status.message);
+      return 1;
+    }
+    log(`No bearer token is stored for "${safeName}".`);
+    return 1;
+  }
+
+  try {
+    modules.store.removeBearerToken(serverName);
+  } catch (err) {
+    error(modules.utils.sanitizeTerminalText(err instanceof Error ? err.message : String(err)));
+    return 1;
+  }
+  log(`Bearer token removed for "${safeName}".`);
+  return 0;
+}
+
+export async function main(argv = process.argv.slice(2), log = console.log, error = console.error, stdin = process.stdin) {
+  const [command, ...rest] = argv;
+
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    printHelp(log);
+    return 0;
+  }
+
+  if (command === "token") {
+    return runToken(rest, log, error, stdin);
+  }
+
+  if (command === "install") {
+    error("The custom downloader has been retired.");
+    error("Use `pi install npm:pi-mcp-adapter` instead, then optionally run `pi-mcp-adapter init`.");
+    return 1;
+  }
+
+  if (command === "init") {
+    return runInit(rest, log);
+  }
+
+  error(`Unknown command: ${command}`);
+  printHelp(log);
+  return 1;
+}
+
+const resolvedEntrypoint = process.argv[1] ? fs.realpathSync(process.argv[1]) : undefined;
+const isEntrypoint = resolvedEntrypoint && import.meta.url === pathToFileURL(resolvedEntrypoint).href;
+
+if (isEntrypoint) {
+  main().then((code) => {
+    process.exitCode = code;
+  }).catch((err) => {
+    console.error(`\nHelper failed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  });
+}