s-app-scoder-agent 0.8.20 → 0.9.2

package/dist/mcp-import.js

@@ -0,0 +1,204 @@
+/**
+ * Phase 5 — MCP config import: parse server configs from third-party formats
+ * (Claude Desktop, OpenCode, .mcp.json) and merge them into our format.
+ *
+ * Supports:
+ * - Claude Desktop: `~/.claude/config.json` → `mcpServers` (stdio + env)
+ * - OpenCode:       `opencode.json`          → `mcp` (stdio or http)
+ * - Standard:       `.mcp.json`             → array of `{name, command, url, …}`
+ */
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** Normalise a Claude Desktop mcpServers entry to our McpServerConfig. */
+function fromClaudeDesktop(raw, _name) {
+    const cfg = {};
+    if (typeof raw.command === "string") {
+        cfg.command = raw.command;
+        if (Array.isArray(raw.args))
+            cfg.args = raw.args;
+    }
+    else if (typeof raw.url === "string") {
+        cfg.url = raw.url;
+        if (typeof raw.headers === "object" && raw.headers !== null) {
+            cfg.headers = raw.headers;
+        }
+    }
+    if (typeof raw.env === "object" && raw.env !== null) {
+        cfg.env = raw.env;
+    }
+    if (typeof raw.autoApprove === "boolean") {
+        // Claude Desktop autoApprove maps to our trust levels:
+        // autoApprove=true → "auto" (trust the server to run without prompt)
+        // autoApprove=false → "ask" (default, prompt before each tool call)
+        // We deliberately do NOT set trust here — let the global mode apply.
+    }
+    return cfg;
+}
+/** Normalise an OpenCode mcp config entry to our McpServerConfig. */
+function fromOpenCode(raw, _name) {
+    const cfg = {};
+    if (typeof raw.command === "string") {
+        cfg.command = raw.command;
+        if (Array.isArray(raw.args))
+            cfg.args = raw.args;
+    }
+    else if (typeof raw.url === "string") {
+        cfg.url = raw.url;
+        if (typeof raw.headers === "object" && raw.headers !== null) {
+            cfg.headers = raw.headers;
+        }
+    }
+    if (typeof raw.env === "object" && raw.env !== null) {
+        cfg.env = raw.env;
+    }
+    if (raw.disabled === true)
+        cfg.enabled = false;
+    return cfg;
+}
+/** Parse Claude Desktop `mcpServers` config from a JSON string. */
+function parseClaude(raw, sourcePath) {
+    const parsed = JSON.parse(raw);
+    const servers = [];
+    const entries = parsed?.mcpServers ?? parsed?.mcp?.servers ?? {};
+    for (const [key, value] of Object.entries(entries)) {
+        if (!value || typeof value !== "object")
+            continue;
+        const rec = value;
+        if (rec.enabled === false)
+            continue;
+        const config = fromClaudeDesktop(rec, key);
+        if (!config.command && !config.url)
+            continue;
+        servers.push({ source: sourcePath, name: key, originalKey: key, config });
+    }
+    return servers;
+}
+/** Parse OpenCode `mcp` config from a JSON string. */
+function parseOpenCode(raw, sourcePath) {
+    const parsed = JSON.parse(raw);
+    const servers = [];
+    const entries = parsed?.mcp ?? parsed?.servers ?? {};
+    for (const [key, value] of Object.entries(entries)) {
+        if (!value || typeof value !== "object")
+            continue;
+        const rec = value;
+        // OpenCode: "disabled" flag; our config: "enabled: false". Both mean skip.
+        if (rec.disabled === true || rec.enabled === false)
+            continue;
+        const config = fromOpenCode(rec, key);
+        if (!config.command && !config.url)
+            continue;
+        servers.push({ source: sourcePath, name: key, originalKey: key, config });
+    }
+    return servers;
+}
+/** Parse standard `.mcp.json` array of server configs. */
+function parseMcpJson(raw, sourcePath) {
+    const parsed = JSON.parse(raw);
+    const servers = [];
+    const entries = Array.isArray(parsed) ? parsed : [parsed];
+    for (const entry of entries) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const rec = entry;
+        const name = typeof rec.name === "string" ? rec.name : "unknown";
+        if (rec.enabled === false)
+            continue;
+        const cfg = {};
+        if (typeof rec.command === "string") {
+            cfg.command = rec.command;
+            if (Array.isArray(rec.args))
+                cfg.args = rec.args;
+        }
+        else if (typeof rec.url === "string") {
+            cfg.url = rec.url;
+            if (typeof rec.headers === "object" && rec.headers !== null) {
+                cfg.headers = rec.headers;
+            }
+        }
+        if (typeof rec.timeoutMs === "number")
+            cfg.timeoutMs = rec.timeoutMs;
+        if (typeof rec.env === "object" && rec.env !== null) {
+            cfg.env = rec.env;
+        }
+        if (typeof rec.trust === "string")
+            cfg.trust = rec.trust;
+        if (typeof rec.enabled === "boolean")
+            cfg.enabled = rec.enabled;
+        if (!cfg.command && !cfg.url)
+            continue;
+        servers.push({ source: sourcePath, name, originalKey: name, config: cfg });
+    }
+    return servers;
+}
+/** Detect format and parse a source file; throws on unreadable/invalid JSON. */
+export function parseConfigFile(raw, sourcePath) {
+    // Heuristic: if it has `mcpServers` top-level → Claude Desktop.
+    // If it has `mcp` top-level (object or array) → OpenCode or standard MCP.
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Invalid JSON in ${sourcePath}`);
+    }
+    if ("mcpServers" in parsed)
+        return parseClaude(raw, sourcePath);
+    if ("mcp" in parsed)
+        return parseOpenCode(raw, sourcePath);
+    // Fallback: treat as standard MCP JSON array.
+    return parseMcpJson(raw, sourcePath);
+}
+/**
+ * Load + parse one config file by path.
+ * Returns `null` when the file does not exist; throws on unreadable/invalid.
+ */
+export function loadConfigFile(path) {
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+    return parseConfigFile(raw, path);
+}
+export function discoverConfigs() {
+    const found = [];
+    const checks = [
+        [join(homedir(), ".claude", "config.json"), "claude"],
+        [join(homedir(), ".config", "claude", "config.json"), "claude"],
+        [join(process.cwd(), "opencode.json"), "opencode"],
+        [join(process.cwd(), ".mcp.json"), "mcp-json"],
+    ];
+    for (const [path, format] of checks) {
+        try {
+            const raw = readFileSync(path, "utf8");
+            const servers = parseConfigFile(raw, path);
+            if (servers.length > 0)
+                found.push({ source: path, format, serverCount: servers.length });
+        }
+        catch { /* not present */ }
+    }
+    return found;
+}
+/** Merge imported servers into an existing config map. */
+export function mergeConfigs(existing, imported, opts = {}) {
+    const added = [];
+    const skipped = [];
+    const updated = [];
+    for (const srv of imported) {
+        const existingCfg = existing[srv.name];
+        if (existingCfg && !opts.force) {
+            skipped.push(srv);
+            continue;
+        }
+        if (existingCfg && opts.force)
+            updated.push(srv.name);
+        if (!opts.dryRun)
+            existing[srv.name] = srv.config;
+        added.push(srv);
+    }
+    return { added, skipped, updated };
+}