@bastani/atomic 0.7.17 → 0.8.0-0

package/dist/builtin/mcp/cli.js

@@ -0,0 +1,186 @@
+#!/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 { APP_NAME, CONFIG_DIR_NAME } from "@bastani/atomic";
+
+const HOME = os.homedir();
+const AGENT_DIR_ENV = `${APP_NAME.toUpperCase()}_CODING_AGENT_DIR`;
+
+function expandHome(input) {
+  if (input === "~") return HOME;
+  if (input.startsWith("~/")) return path.resolve(HOME, input.slice(2));
+  return path.resolve(input);
+}
+
+const AGENT_DIR = process.env[AGENT_DIR_ENV]?.trim()
+  ? expandHome(process.env[AGENT_DIR_ENV].trim())
+  : path.join(HOME, CONFIG_DIR_NAME, "agent");
+const PI_CONFIG_PATH = path.join(AGENT_DIR, "mcp.json");
+const GENERIC_GLOBAL_CONFIG_PATH = path.join(HOME, ".config", "mcp", "mcp.json");
+const PROJECT_CONFIG_PATH = path.resolve(process.cwd(), ".mcp.json");
+const PROJECT_PI_CONFIG_PATH = path.resolve(process.cwd(), CONFIG_DIR_NAME, "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.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");
+}
+
+function readJsonFile(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+
+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],
+    ["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 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);
+
+  if (importsToAdd.length === 0) {
+    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,
+    imports: [...existingImports, ...importsToAdd],
+    mcpServers: existingConfig.mcpServers ?? {},
+  };
+
+  log(`\nDetected host configs to import into Pi: ${importsToAdd.join(", ")}`);
+
+  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.");
+  return 0;
+}
+
+export async function main(argv = process.argv.slice(2), log = console.log, error = console.error) {
+  const [command, ...rest] = argv;
+
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    printHelp(log);
+    return 0;
+  }
+
+  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 isEntrypoint = process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).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);
+  });
+}

package/dist/builtin/mcp/commands.ts

@@ -0,0 +1,420 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { McpExtensionState } from "./state.ts";
+import type { McpAuthResult, McpConfig, ServerEntry, McpPanelCallbacks, McpPanelResult, ImportKind } from "./types.ts";
+import {
+  ensureCompatibilityImports,
+  getMcpDiscoverySummary,
+  getServerProvenance,
+  previewCompatibilityImports,
+  previewSharedServerEntry,
+  previewStarterProjectConfig,
+  writeDirectToolsConfig,
+  writeSharedServerEntry,
+  writeStarterProjectConfig,
+} from "./config.ts";
+import { lazyConnect, updateMetadataCache, updateStatusBar, getFailureAgeSeconds } from "./init.ts";
+import { loadMetadataCache } from "./metadata-cache.ts";
+import { buildToolMetadata } from "./tool-metadata.ts";
+import { supportsOAuth, authenticate, removeAuth } from "./mcp-auth-flow.ts";
+import { getAuthForUrl } from "./mcp-auth.ts";
+import { loadOnboardingState, markSetupCompleted as persistSetupCompleted, markSharedConfigHintShown } from "./onboarding-state.ts";
+import { openPath } from "./utils.ts";
+
+export async function showStatus(state: McpExtensionState, ctx: ExtensionContext): Promise<void> {
+  if (!ctx.hasUI) return;
+
+  const lines: string[] = ["MCP Server Status:", ""];
+
+  for (const name of Object.keys(state.config.mcpServers)) {
+    const connection = state.manager.getConnection(name);
+    const metadata = state.toolMetadata.get(name);
+    const toolCount = metadata?.length ?? 0;
+    const failedAgo = getFailureAgeSeconds(state, name);
+    let status = "not connected";
+    let statusIcon = "○";
+    let failed = false;
+
+    if (connection?.status === "connected") {
+      status = "connected";
+      statusIcon = "✓";
+    } else if (connection?.status === "needs-auth") {
+      status = "needs auth";
+      statusIcon = "⚠";
+    } else if (failedAgo !== null) {
+      status = `failed ${failedAgo}s ago`;
+      statusIcon = "✗";
+      failed = true;
+    } else if (metadata !== undefined) {
+      status = "cached";
+    }
+
+    const toolSuffix = failed ? "" : ` (${toolCount} tools${status === "cached" ? ", cached" : ""})`;
+    lines.push(`${statusIcon} ${name}: ${status}${toolSuffix}`);
+  }
+
+  if (Object.keys(state.config.mcpServers).length === 0) {
+    lines.push("No MCP servers configured");
+    lines.push("Run /mcp setup to adopt imports or scaffold a starter .mcp.json");
+  }
+
+  ctx.ui.notify(lines.join("\n"), "info");
+}
+
+export async function showTools(state: McpExtensionState, ctx: ExtensionContext): Promise<void> {
+  if (!ctx.hasUI) return;
+
+  const allTools = [...state.toolMetadata.values()].flat().map(m => m.name);
+
+  if (allTools.length === 0) {
+    ctx.ui.notify("No MCP tools available", "info");
+    return;
+  }
+
+  const lines = [
+    "MCP Tools:",
+    "",
+    ...allTools.map(t => `  ${t}`),
+    "",
+    `Total: ${allTools.length} tools`,
+  ];
+
+  ctx.ui.notify(lines.join("\n"), "info");
+}
+
+export async function reconnectServers(
+  state: McpExtensionState,
+  ctx: ExtensionContext,
+  targetServer?: string
+): Promise<void> {
+  if (targetServer && !state.config.mcpServers[targetServer]) {
+    if (ctx.hasUI) {
+      ctx.ui.notify(`Server "${targetServer}" not found in config`, "error");
+    }
+    return;
+  }
+
+  const entries = targetServer
+    ? [[targetServer, state.config.mcpServers[targetServer]] as [string, ServerEntry]]
+    : Object.entries(state.config.mcpServers);
+
+  for (const [name, definition] of entries) {
+    try {
+      await state.manager.close(name);
+
+      const connection = await state.manager.connect(name, definition);
+      if (connection.status === "needs-auth") {
+        if (ctx.hasUI) {
+          ctx.ui.notify(`MCP: ${name} requires OAuth. Run /mcp-auth ${name} first.`, "warning");
+        }
+        continue;
+      }
+      const prefix = state.config.settings?.toolPrefix ?? "server";
+
+      const { metadata, failedTools } = buildToolMetadata(connection.tools, connection.resources, definition, name, prefix);
+      state.toolMetadata.set(name, metadata);
+      updateMetadataCache(state, name);
+      state.failureTracker.delete(name);
+
+      if (ctx.hasUI) {
+        ctx.ui.notify(
+          `MCP: Reconnected to ${name} (${connection.tools.length} tools, ${connection.resources.length} resources)`,
+          "info"
+        );
+        if (failedTools.length > 0) {
+          ctx.ui.notify(`MCP: ${name} - ${failedTools.length} tools skipped`, "warning");
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      state.failureTracker.set(name, Date.now());
+      if (ctx.hasUI) {
+        ctx.ui.notify(`MCP: Failed to reconnect to ${name}: ${message}`, "error");
+      }
+    }
+  }
+
+  updateStatusBar(state);
+}
+
+export async function authenticateServer(
+  serverName: string,
+  config: McpConfig,
+  ctx: ExtensionContext
+): Promise<McpAuthResult> {
+  if (!ctx.hasUI) return { ok: false, message: "OAuth authentication requires an interactive session." };
+
+  const definition = config.mcpServers[serverName];
+  if (!definition) {
+    const message = `Server "${serverName}" not found in config`;
+    ctx.ui.notify(message, "error");
+    return { ok: false, message };
+  }
+
+  if (!supportsOAuth(definition)) {
+    const message = `Server "${serverName}" does not use OAuth authentication. Set "auth": "oauth" or omit auth for auto-detection.`;
+    ctx.ui.notify(
+      `Server "${serverName}" does not use OAuth authentication.\n` +
+      `Set "auth": "oauth" or omit auth for auto-detection.`,
+      "error"
+    );
+    return { ok: false, message };
+  }
+
+  if (!definition.url) {
+    const message = `Server "${serverName}" has no URL configured (OAuth requires HTTP transport)`;
+    ctx.ui.notify(message, "error");
+    return { ok: false, message };
+  }
+
+  try {
+    ctx.ui.setStatus("mcp-auth", `Authenticating ${serverName}...`);
+    const status = await authenticate(serverName, definition.url, definition);
+
+    if (status === "authenticated") {
+      const message = `OAuth authentication successful for "${serverName}"! Run /mcp reconnect ${serverName} to connect with the new token.`;
+      ctx.ui.notify(
+        `OAuth authentication successful for "${serverName}"!\n` +
+        `Run /mcp reconnect ${serverName} to connect with the new token.`,
+        "info"
+      );
+      return { ok: true, message };
+    }
+
+    const message = `OAuth authentication failed for "${serverName}".`;
+    ctx.ui.notify(message, "error");
+    return { ok: false, message };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    ctx.ui.notify(`Failed to authenticate "${serverName}": ${message}`, "error");
+    return { ok: false, message };
+  } finally {
+    ctx.ui.setStatus("mcp-auth", undefined);
+  }
+}
+
+export async function logoutServer(
+  serverName: string,
+  state: McpExtensionState,
+  ctx: ExtensionContext
+): Promise<{ ok: boolean; message: string }> {
+  const definition = state.config.mcpServers[serverName];
+  if (!definition) {
+    const message = `Server "${serverName}" not found in config`;
+    if (ctx.hasUI) ctx.ui.notify(message, "error");
+    return { ok: false, message };
+  }
+
+  await removeAuth(serverName);
+  await state.manager.close(serverName);
+  updateStatusBar(state);
+
+  const message = `OAuth credentials cleared for "${serverName}". Run /mcp-auth ${serverName} to authenticate again.`;
+  if (ctx.hasUI) ctx.ui.notify(message, "info");
+  return { ok: true, message };
+}
+
+export interface PanelFlowResult {
+  configChanged: boolean;
+}
+
+function buildSharedConfigNoticeLines(configOverridePath: string | undefined, cwd: string): { lines: string[]; fingerprint: string | null } {
+  const discovery = getMcpDiscoverySummary(configOverridePath, cwd);
+  const onboardingState = loadOnboardingState();
+  if (!discovery.hasSharedServers || onboardingState.sharedConfigHintShown) {
+    return { lines: [], fingerprint: null };
+  }
+
+  const sharedSources = discovery.sources.filter((source) => source.kind === "shared" && source.serverCount > 0);
+  const sourceList = sharedSources.map((source) => source.path).join(", ");
+  return {
+    lines: [
+      `Using standard MCP config from ${sourceList}.`,
+      "Pi only writes compatibility imports and adapter-specific overrides into Pi-owned files when needed.",
+    ],
+    fingerprint: discovery.fingerprint,
+  };
+}
+
+export async function openMcpSetup(
+  _state: McpExtensionState,
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  configOverridePath?: string,
+  mode: "empty" | "setup" = "setup",
+): Promise<PanelFlowResult> {
+  if (!ctx.hasUI) return { configChanged: false };
+
+  const discovery = getMcpDiscoverySummary(configOverridePath, ctx.cwd);
+  const onboardingState = loadOnboardingState();
+  const { createMcpSetupPanel } = await import("./mcp-setup-panel.ts");
+  let configChanged = false;
+
+  const callbacks = {
+    previewImports: (imports: ImportKind[]) => previewCompatibilityImports(imports, configOverridePath),
+    previewStarterProject: () => previewStarterProjectConfig(ctx.cwd),
+    previewRepoPrompt: () => {
+      const repoPrompt = getMcpDiscoverySummary(configOverridePath, ctx.cwd).repoPrompt;
+      if (!repoPrompt.entry || !repoPrompt.targetPath || !repoPrompt.serverName) return null;
+      return previewSharedServerEntry(repoPrompt.targetPath, repoPrompt.serverName, repoPrompt.entry);
+    },
+    adoptImports: async (imports: ImportKind[]) => {
+      const result = ensureCompatibilityImports(imports, configOverridePath);
+      if (result.added.length > 0) configChanged = true;
+      return result;
+    },
+    scaffoldProjectConfig: async () => {
+      const path = writeStarterProjectConfig(ctx.cwd);
+      configChanged = true;
+      return { path };
+    },
+    addRepoPrompt: async () => {
+      const repoPrompt = getMcpDiscoverySummary(configOverridePath, ctx.cwd).repoPrompt;
+      if (!repoPrompt.entry || !repoPrompt.targetPath || !repoPrompt.serverName) {
+        throw new Error("RepoPrompt is not available to add from this setup screen.");
+      }
+      const path = writeSharedServerEntry(repoPrompt.targetPath, repoPrompt.serverName, repoPrompt.entry);
+      configChanged = true;
+      return { path, serverName: repoPrompt.serverName };
+    },
+    openPath: async (targetPath: string) => {
+      await openPath(pi, targetPath);
+    },
+    markSetupCompleted: () => {
+      persistSetupCompleted(discovery.fingerprint);
+    },
+  };
+
+  return new Promise<PanelFlowResult>((resolve) => {
+    ctx.ui.custom(
+      (tui, _theme, _keybindings, done) => {
+        return createMcpSetupPanel(discovery, callbacks, { mode, onboardingState }, tui, () => {
+          done(undefined);
+          resolve({ configChanged });
+        });
+      },
+      { overlay: true, overlayOptions: { anchor: "center", width: 92 } },
+    );
+  });
+}
+
+function buildMcpPanelCallbacks(
+  state: McpExtensionState,
+  config: McpConfig,
+  ctx: ExtensionContext,
+): McpPanelCallbacks {
+  return {
+    reconnect: (serverName: string) => lazyConnect(state, serverName),
+    canAuthenticate: (serverName: string) => {
+      const definition = config.mcpServers[serverName];
+      return definition ? supportsOAuth(definition) : false;
+    },
+    authenticate: (serverName: string) => authenticateServer(serverName, config, ctx),
+    getConnectionStatus: (serverName: string) => {
+      const definition = config.mcpServers[serverName];
+      const connection = state.manager.getConnection(serverName);
+      if (connection?.status === "needs-auth") {
+        return "needs-auth";
+      }
+      if (
+        definition?.auth === "oauth"
+        && definition.url
+        && definition.oauth !== false
+        && definition.oauth?.grantType !== "client_credentials"
+        && !getAuthForUrl(serverName, definition.url)?.tokens
+      ) {
+        return "needs-auth";
+      }
+      if (connection?.status === "connected") return "connected";
+      if (getFailureAgeSeconds(state, serverName) !== null) return "failed";
+      return "idle";
+    },
+    refreshCacheAfterReconnect: (serverName: string) => {
+      const freshCache = loadMetadataCache();
+      return freshCache?.servers?.[serverName] ?? null;
+    },
+  };
+}
+
+export async function openMcpPanel(
+  state: McpExtensionState,
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  configOverridePath?: string,
+): Promise<PanelFlowResult> {
+  if (Object.keys(state.config.mcpServers).length === 0) {
+    return openMcpSetup(state, pi, ctx, configOverridePath, "empty");
+  }
+
+  const config = state.config;
+  const cache = loadMetadataCache();
+  const configPath = pi.getFlag("mcp-config") as string | undefined ?? configOverridePath;
+  const provenanceMap = getServerProvenance(configPath, ctx.cwd);
+  const { lines: noticeLines, fingerprint } = buildSharedConfigNoticeLines(configPath, ctx.cwd);
+
+  const callbacks = buildMcpPanelCallbacks(state, config, ctx);
+
+  const { createMcpPanel } = await import("./mcp-panel.ts");
+  let configChanged = false;
+
+  await new Promise<void>((resolve) => {
+    ctx.ui.custom(
+      (tui, _theme, _keybindings, done) => {
+        return createMcpPanel(config, cache, provenanceMap, callbacks, tui, (result: McpPanelResult) => {
+          if (!result.cancelled && result.changes.size > 0) {
+            writeDirectToolsConfig(result.changes, provenanceMap, config);
+            configChanged = true;
+            ctx.ui.notify("Direct tools updated. Pi will reload after this panel closes.", "info");
+          }
+          done(undefined);
+          resolve();
+        }, { noticeLines });
+      },
+      { overlay: true, overlayOptions: { anchor: "center", width: 82 } },
+    );
+  });
+
+  if (noticeLines.length > 0 && fingerprint) {
+    markSharedConfigHintShown(fingerprint);
+  }
+
+  return { configChanged };
+}
+
+export async function openMcpAuthPanel(
+  state: McpExtensionState,
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  configOverridePath?: string,
+): Promise<PanelFlowResult> {
+  if (!ctx.hasUI) return { configChanged: false };
+
+  const config = state.config;
+  const oauthServers = Object.entries(config.mcpServers).filter(([, definition]) => supportsOAuth(definition));
+  if (oauthServers.length === 0) {
+    ctx.ui.notify("No OAuth-capable MCP servers are configured.", "warning");
+    return { configChanged: false };
+  }
+
+  const cache = loadMetadataCache();
+  const configPath = pi.getFlag("mcp-config") as string | undefined ?? configOverridePath;
+  const provenanceMap = getServerProvenance(configPath, ctx.cwd);
+  const callbacks = buildMcpPanelCallbacks(state, config, ctx);
+  const { createMcpPanel } = await import("./mcp-panel.ts");
+
+  await new Promise<void>((resolve) => {
+    ctx.ui.custom(
+      (tui, _theme, _keybindings, done) => {
+        return createMcpPanel(config, cache, provenanceMap, callbacks, tui, () => {
+          done(undefined);
+          resolve();
+        }, {
+          authOnly: true,
+          noticeLines: ["Select an OAuth MCP server and press Enter or ctrl+a to authenticate."],
+        });
+      },
+      { overlay: true, overlayOptions: { anchor: "center", width: 82 } },
+    );
+  });
+
+  return { configChanged: false };
+}