@docyrus/docyrus 0.0.20 → 0.0.22

package/resources/pi-agent/extensions/pi-mcp-adapter/cli.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import https from "node:https";
+import os from "node:os";
+import { execSync } from "node:child_process";
+
+const REPO_URL = "https://raw.githubusercontent.com/nicobailon/pi-mcp-adapter/main";
+const EXT_DIR = path.join(os.homedir(), ".pi", "agent", "extensions", "pi-mcp-adapter");
+const SETTINGS_FILE = path.join(os.homedir(), ".pi", "agent", "settings.json");
+const EXT_PATH = "~/.pi/agent/extensions/pi-mcp-adapter/index.ts";
+
+const FILES = [
+  "index.ts",
+  "types.ts",
+  "config.ts",
+  "server-manager.ts",
+  "tool-registrar.ts",
+  "resource-tools.ts",
+  "lifecycle.ts",
+  "metadata-cache.ts",
+  "npx-resolver.ts",
+  "oauth-handler.ts",
+  "package.json",
+  "tsconfig.json",
+  "README.md",
+  "CHANGELOG.md",
+  "LICENSE",
+];
+
+function download(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        return download(res.headers.location).then(resolve).catch(reject);
+      }
+      if (res.statusCode !== 200) {
+        return reject(new Error(`Failed to download ${url}: ${res.statusCode}`));
+      }
+      let data = "";
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => resolve(data));
+      res.on("error", reject);
+    }).on("error", reject);
+  });
+}
+
+async function main() {
+  console.log("Installing pi-mcp-adapter...\n");
+
+  fs.mkdirSync(EXT_DIR, { recursive: true });
+  console.log(`Created directory: ${EXT_DIR}`);
+
+  for (const file of FILES) {
+    console.log(`Downloading ${file}...`);
+    const content = await download(`${REPO_URL}/${file}`);
+    fs.writeFileSync(path.join(EXT_DIR, file), content);
+  }
+
+  console.log("\nInstalling dependencies...");
+  try {
+    execSync("npm install --omit=dev", { cwd: EXT_DIR, stdio: "inherit" });
+  } catch {
+    console.error("Warning: npm install failed. You may need to run it manually.");
+  }
+
+  console.log(`\nUpdating settings: ${SETTINGS_FILE}`);
+  
+  let settings = {};
+  if (fs.existsSync(SETTINGS_FILE)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(SETTINGS_FILE, "utf-8"));
+    } catch (err) {
+      console.error(`Warning: Could not parse existing settings.json: ${err.message}`);
+      console.error("Creating new settings file...");
+    }
+  }
+
+  if (!Array.isArray(settings.extensions)) {
+    settings.extensions = [];
+  }
+
+  const hasMcpExt = settings.extensions.some(p => 
+    p === EXT_PATH || 
+    p.includes("/extensions/pi-mcp-adapter/index.ts") || 
+    p.includes("/extensions/pi-mcp-adapter")
+  );
+
+  if (!hasMcpExt) {
+    settings.extensions.push(EXT_PATH);
+    console.log(`Added "${EXT_PATH}" to extensions array`);
+  } else {
+    console.log("Extension already configured in settings.json");
+  }
+
+  fs.mkdirSync(path.dirname(SETTINGS_FILE), { recursive: true });
+  fs.writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2) + "\n");
+
+  console.log("\nInstallation complete!");
+  console.log("\nCreate ~/.pi/agent/mcp.json to configure MCP servers.");
+  console.log("Restart pi to load the extension.");
+}
+
+main().catch((err) => {
+  console.error(`\nInstallation failed: ${err.message}`);
+  process.exit(1);
+});

package/resources/pi-agent/extensions/pi-mcp-adapter/commands.ts

@@ -0,0 +1,211 @@
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { McpExtensionState } from "./state.js";
+import type { McpConfig, ServerEntry, McpPanelCallbacks, McpPanelResult } from "./types.js";
+import { getServerProvenance, writeDirectToolsConfig } from "./config.js";
+import { lazyConnect, updateMetadataCache, updateStatusBar, getFailureAgeSeconds } from "./init.js";
+import { loadMetadataCache } from "./metadata-cache.js";
+import { getStoredTokens } from "./oauth-handler.js";
+import { getScopedMcpOAuthTokensPath } from "./paths.js";
+import { buildToolMetadata } from "./tool-metadata.js";
+
+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 (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");
+  }
+
+  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);
+      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<void> {
+  if (!ctx.hasUI) return;
+
+  const definition = config.mcpServers[serverName];
+  if (!definition) {
+    ctx.ui.notify(`Server "${serverName}" not found in config`, "error");
+    return;
+  }
+
+  if (definition.auth !== "oauth") {
+    ctx.ui.notify(
+      `Server "${serverName}" does not use OAuth authentication.\n` +
+      `Current auth mode: ${definition.auth ?? "none"}`,
+      "error"
+    );
+    return;
+  }
+
+  if (!definition.url) {
+    ctx.ui.notify(
+      `Server "${serverName}" has no URL configured (OAuth requires HTTP transport)`,
+      "error"
+    );
+    return;
+  }
+
+  const tokenPath = getScopedMcpOAuthTokensPath(serverName);
+
+  ctx.ui.notify(
+    `OAuth setup for "${serverName}":\n\n` +
+    `1. Obtain an access token from your OAuth provider\n` +
+    `2. Create the token file:\n` +
+    `   ${tokenPath}\n\n` +
+    `3. Add your token:\n` +
+    `   {\n` +
+    `     "access_token": "your-token-here",\n` +
+    `     "token_type": "bearer"\n` +
+    `   }\n\n` +
+    `4. Run /mcp reconnect to connect with the token`,
+    "info"
+  );
+}
+
+export async function openMcpPanel(
+  state: McpExtensionState,
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  configOverridePath?: string,
+): Promise<void> {
+  const config = state.config;
+  const cache = loadMetadataCache();
+  const provenanceMap = getServerProvenance(pi.getFlag("mcp-config") as string | undefined ?? configOverridePath);
+
+  const callbacks: McpPanelCallbacks = {
+    reconnect: async (serverName: string) => {
+      return lazyConnect(state, serverName);
+    },
+    getConnectionStatus: (serverName: string) => {
+      const definition = config.mcpServers[serverName];
+      if (definition?.auth === "oauth" && getStoredTokens(serverName) === undefined) {
+        return "needs-auth";
+      }
+      const connection = state.manager.getConnection(serverName);
+      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;
+    },
+  };
+
+  const { createMcpPanel } = await import("./mcp-panel.js");
+
+  return 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);
+            ctx.ui.notify("Direct tools updated. Restart pi to apply.", "info");
+          }
+          done();
+          resolve();
+        });
+      },
+      { overlay: true, overlayOptions: { anchor: "center", width: 82 } },
+    );
+  });
+}

package/resources/pi-agent/extensions/pi-mcp-adapter/config.ts

@@ -0,0 +1,227 @@
+// config.ts - Config loading with import support
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve, dirname } from "node:path";
+import type { McpConfig, ServerEntry, McpSettings, ImportKind, ServerProvenance } from "./types.js";
+import { getScopedMcpConfigPath } from "./paths.js";
+
+const DEFAULT_CONFIG_PATH = getScopedMcpConfigPath();
+const PROJECT_CONFIG_NAME = ".pi/mcp.json";
+
+// Import source paths for other tools
+const IMPORT_PATHS: Record<ImportKind, string> = {
+  "cursor": join(homedir(), ".cursor", "mcp.json"),
+  "claude-code": join(homedir(), ".claude", "claude_desktop_config.json"),
+  "claude-desktop": join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json"),
+  "codex": join(homedir(), ".codex", "config.json"),
+  "windsurf": join(homedir(), ".windsurf", "mcp.json"),
+  "vscode": ".vscode/mcp.json", // Relative to project
+};
+
+export function loadMcpConfig(overridePath?: string): McpConfig {
+  const configPath = overridePath ? resolve(overridePath) : DEFAULT_CONFIG_PATH;
+  
+  // Load base config
+  let config: McpConfig = { mcpServers: {} };
+  
+  if (existsSync(configPath)) {
+    try {
+      const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+      config = validateConfig(raw);
+    } catch (error) {
+      console.warn(`Failed to load MCP config from ${configPath}:`, error);
+    }
+  }
+  
+  // Process imports from other tools
+  if (config.imports?.length) {
+    for (const importKind of config.imports) {
+      const importPath = IMPORT_PATHS[importKind];
+      if (!importPath) continue;
+      
+      const fullPath = importPath.startsWith(".") 
+        ? resolve(process.cwd(), importPath) 
+        : importPath;
+      
+      if (!existsSync(fullPath)) continue;
+      
+      try {
+        const imported = JSON.parse(readFileSync(fullPath, "utf-8"));
+        const servers = extractServers(imported, importKind);
+        
+        // Merge - local config takes precedence over imports
+        for (const [name, def] of Object.entries(servers)) {
+          if (!config.mcpServers[name]) {
+            config.mcpServers[name] = def;
+          }
+        }
+      } catch (error) {
+        console.warn(`Failed to import MCP config from ${importKind}:`, error);
+      }
+    }
+  }
+  
+  // Check for project-local config (skip if it's the same as the main config)
+  const projectPath = resolve(process.cwd(), PROJECT_CONFIG_NAME);
+  if (existsSync(projectPath) && projectPath !== configPath) {
+    try {
+      const projectConfig = JSON.parse(readFileSync(projectPath, "utf-8"));
+      const validated = validateConfig(projectConfig);
+      
+      // Project config overrides everything
+      config.mcpServers = { ...config.mcpServers, ...validated.mcpServers };
+      if (validated.settings) {
+        config.settings = { ...config.settings, ...validated.settings };
+      }
+    } catch (error) {
+      console.warn(`Failed to load project MCP config:`, error);
+    }
+  }
+  
+  return config;
+}
+
+function validateConfig(raw: unknown): McpConfig {
+  if (!raw || typeof raw !== "object") {
+    return { mcpServers: {} };
+  }
+  
+  const obj = raw as Record<string, unknown>;
+  const servers = obj.mcpServers ?? obj["mcp-servers"] ?? {};
+  
+  // Must be a plain object, not an array or null
+  if (typeof servers !== "object" || servers === null || Array.isArray(servers)) {
+    return { mcpServers: {} };
+  }
+  
+  return {
+    mcpServers: servers as Record<string, ServerEntry>,
+    imports: Array.isArray(obj.imports) ? obj.imports as ImportKind[] : undefined,
+    settings: obj.settings as McpSettings | undefined,
+  };
+}
+
+function extractServers(config: unknown, kind: ImportKind): Record<string, ServerEntry> {
+  if (!config || typeof config !== "object") return {};
+  
+  const obj = config as Record<string, unknown>;
+  
+  let servers: unknown;
+  switch (kind) {
+    case "claude-desktop":
+    case "claude-code":
+    case "codex":
+      servers = obj.mcpServers;
+      break;
+    case "cursor":
+    case "windsurf":
+    case "vscode":
+      servers = obj.mcpServers ?? obj["mcp-servers"];
+      break;
+    default:
+      return {};
+  }
+  
+  if (!servers || typeof servers !== "object" || Array.isArray(servers)) {
+    return {};
+  }
+  
+  return servers as Record<string, ServerEntry>;
+}
+
+export function getServerProvenance(overridePath?: string): Map<string, ServerProvenance> {
+  const provenance = new Map<string, ServerProvenance>();
+  const userPath = overridePath ? resolve(overridePath) : DEFAULT_CONFIG_PATH;
+
+  let userConfig: McpConfig = { mcpServers: {} };
+  if (existsSync(userPath)) {
+    try {
+      userConfig = validateConfig(JSON.parse(readFileSync(userPath, "utf-8")));
+    } catch {}
+  }
+  for (const name of Object.keys(userConfig.mcpServers)) {
+    provenance.set(name, { path: userPath, kind: "user" });
+  }
+
+  if (userConfig.imports?.length) {
+    for (const importKind of userConfig.imports) {
+      const importPath = IMPORT_PATHS[importKind];
+      if (!importPath) continue;
+      const fullPath = importPath.startsWith(".")
+        ? resolve(process.cwd(), importPath)
+        : importPath;
+      if (!existsSync(fullPath)) continue;
+      try {
+        const imported = JSON.parse(readFileSync(fullPath, "utf-8"));
+        const servers = extractServers(imported, importKind);
+        for (const name of Object.keys(servers)) {
+          if (!provenance.has(name)) {
+            provenance.set(name, { path: userPath, kind: "import", importKind });
+          }
+        }
+      } catch {}
+    }
+  }
+
+  const projectPath = resolve(process.cwd(), PROJECT_CONFIG_NAME);
+  if (existsSync(projectPath) && projectPath !== userPath) {
+    try {
+      const projectConfig = validateConfig(JSON.parse(readFileSync(projectPath, "utf-8")));
+      for (const name of Object.keys(projectConfig.mcpServers)) {
+        provenance.set(name, { path: projectPath, kind: "project" });
+      }
+    } catch {}
+  }
+
+  return provenance;
+}
+
+export function writeDirectToolsConfig(
+  changes: Map<string, true | string[] | false>,
+  provenance: Map<string, ServerProvenance>,
+  fullConfig: McpConfig,
+): void {
+  const byPath = new Map<string, { name: string; value: true | string[] | false; prov: ServerProvenance }[]>();
+
+  for (const [serverName, value] of changes) {
+    const prov = provenance.get(serverName);
+    if (!prov) continue;
+
+    const targetPath = prov.path;
+
+    if (!byPath.has(targetPath)) byPath.set(targetPath, []);
+    byPath.get(targetPath)!.push({ name: serverName, value, prov });
+  }
+
+  for (const [filePath, entries] of byPath) {
+    let raw: Record<string, unknown> = {};
+    if (existsSync(filePath)) {
+      try {
+        raw = JSON.parse(readFileSync(filePath, "utf-8"));
+      } catch {}
+    }
+    if (!raw || typeof raw !== "object") raw = {};
+
+    const servers = (raw.mcpServers ?? raw["mcp-servers"] ?? {}) as Record<string, ServerEntry>;
+    if (typeof servers !== "object" || Array.isArray(servers)) continue;
+
+    for (const { name, value, prov } of entries) {
+      if (prov.kind === "import") {
+        const fullDef = fullConfig.mcpServers[name];
+        if (fullDef) {
+          servers[name] = { ...fullDef, directTools: value };
+        }
+      } else if (servers[name]) {
+        servers[name] = { ...servers[name], directTools: value };
+      }
+    }
+
+    const key = raw["mcp-servers"] && !raw.mcpServers ? "mcp-servers" : "mcpServers";
+    raw[key] = servers;
+
+    mkdirSync(dirname(filePath), { recursive: true });
+    const tmpPath = `${filePath}.${process.pid}.tmp`;
+    writeFileSync(tmpPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
+    renameSync(tmpPath, filePath);
+  }
+}

package/resources/pi-agent/extensions/pi-mcp-adapter/consent-manager.ts

@@ -0,0 +1,64 @@
+import { ConsentError } from "./errors.js";
+import { logger } from "./logger.js";
+
+export type ToolConsentMode = "never" | "once-per-server" | "always";
+
+export class ConsentManager {
+  private approvedServers = new Set<string>();
+  private deniedServers = new Set<string>();
+  private log = logger.child({ component: "ConsentManager" });
+
+  constructor(private mode: ToolConsentMode = "once-per-server") {
+    this.log.debug("Initialized", { mode });
+  }
+
+  requiresPrompt(serverName: string): boolean {
+    if (this.mode === "never") return false;
+    if (this.deniedServers.has(serverName)) return true;
+    if (this.mode === "always") return true;
+    return !this.approvedServers.has(serverName);
+  }
+
+  shouldCacheConsent(): boolean {
+    return this.mode !== "always";
+  }
+
+  registerDecision(serverName: string, approved: boolean): void {
+    this.deniedServers.delete(serverName);
+    this.approvedServers.delete(serverName);
+
+    if (approved) {
+      this.approvedServers.add(serverName);
+      this.log.debug("Consent granted", { server: serverName });
+      return;
+    }
+
+    this.deniedServers.add(serverName);
+    this.log.debug("Consent denied", { server: serverName });
+  }
+
+  ensureApproved(serverName: string): void {
+    if (this.mode === "never") return;
+    if (this.deniedServers.has(serverName)) {
+      throw new ConsentError(serverName, { denied: true });
+    }
+    if (!this.approvedServers.has(serverName)) {
+      throw new ConsentError(serverName, { requiresApproval: true });
+    }
+    if (this.mode === "always") {
+      this.approvedServers.delete(serverName);
+    }
+  }
+
+  clear(serverName?: string): void {
+    if (serverName) {
+      this.approvedServers.delete(serverName);
+      this.deniedServers.delete(serverName);
+      this.log.debug("Cleared consent for server", { server: serverName });
+      return;
+    }
+    this.approvedServers.clear();
+    this.deniedServers.clear();
+    this.log.debug("Cleared all consent records");
+  }
+}