@alan-ai-hq/agent-manager 0.1.113 → 0.1.115

package/dist/mcp-config-adapters.js

@@ -0,0 +1,929 @@
+import { createHash, randomBytes } from "node:crypto";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+let log = {
+    info: (...args) => console.info("[mcp-config-adapters]", ...args),
+    warn: (...args) => console.warn("[mcp-config-adapters]", ...args),
+    debug: () => { },
+};
+export function setMcpAdaptersLogger(logger) {
+    log = logger;
+}
+let homeDirectoryOverride;
+function homeDirectory() {
+    return homeDirectoryOverride ?? homedir();
+}
+class MalformedToolConfigError extends Error {
+}
+function parseJsonSafe(content) {
+    if (!content)
+        return {};
+    try {
+        const parsed = JSON.parse(content);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // Throw one typed error below so the caller can preserve and back up the file.
+    }
+    throw new MalformedToolConfigError("Existing tool config is malformed");
+}
+function readFileOr(path) {
+    return existsSync(path) ? readFileSync(path, "utf-8") : null;
+}
+function acquireConfigLock(path) {
+    mkdirSync(dirname(path), { recursive: true });
+    const lockPath = `${path}.alan-lock`;
+    const startedAt = Date.now();
+    while (true) {
+        try {
+            mkdirSync(lockPath);
+            return () => rmSync(lockPath, { recursive: true, force: true });
+        }
+        catch (error) {
+            const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
+            if (code !== "EEXIST")
+                throw error;
+            try {
+                if (Date.now() - statSync(lockPath).mtimeMs > 30_000) {
+                    rmSync(lockPath, { recursive: true, force: true });
+                    continue;
+                }
+            }
+            catch {
+                continue;
+            }
+            if (Date.now() - startedAt >= 2_000) {
+                throw new Error(`Alan could not safely update ${path}`);
+            }
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+        }
+    }
+}
+function writeFileSafe(path, content) {
+    mkdirSync(dirname(path), { recursive: true });
+    const pendingPath = `${path}.alan-pending-${process.pid}-${randomBytes(6).toString("hex")}`;
+    try {
+        writeFileSync(pendingPath, content, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        renameSync(pendingPath, path);
+    }
+    finally {
+        rmSync(pendingPath, { force: true });
+    }
+}
+function saveMalformedBackup(path, content) {
+    const hash = createHash("sha256").update(content).digest("hex").slice(0, 16);
+    const backupPath = `${path}.alan-backup-${hash}`;
+    if (!existsSync(backupPath))
+        copyFileSync(path, backupPath);
+    return backupPath;
+}
+const claudeAdapter = {
+    cli: "Claude Code",
+    get configPath() {
+        return join(homeDirectory(), ".claude.json");
+    },
+    get guardDir() {
+        return homeDirectory();
+    },
+    merge(existing, servers) {
+        const config = parseJsonSafe(existing);
+        const mcpServers = (config.mcpServers ?? {});
+        for (const s of servers) {
+            if (s.kind === "http") {
+                mcpServers[s.name] = { type: "http", url: s.url, headers: s.headers };
+            }
+            else {
+                mcpServers[s.name] = {
+                    command: s.command,
+                    ...(s.args?.length ? { args: s.args } : {}),
+                    ...(s.env && Object.keys(s.env).length > 0 ? { env: s.env } : {}),
+                };
+            }
+        }
+        config.mcpServers = mcpServers;
+        return JSON.stringify(config, null, 2);
+    },
+    remove(existing, serverNames) {
+        const config = parseJsonSafe(existing);
+        const mcpServers = (config.mcpServers ?? {});
+        for (const name of serverNames)
+            delete mcpServers[name];
+        config.mcpServers = mcpServers;
+        return JSON.stringify(config, null, 2);
+    },
+};
+const codexAdapter = {
+    cli: "Codex",
+    get configPath() {
+        return join(homeDirectory(), ".codex", "config.toml");
+    },
+    get guardDir() {
+        return join(homeDirectory(), ".codex");
+    },
+    merge(existing, servers) {
+        let config = {};
+        if (existing) {
+            try {
+                config = parseToml(existing);
+            }
+            catch {
+                throw new MalformedToolConfigError("Existing tool config is malformed");
+            }
+        }
+        const mcpServers = (config.mcp_servers ?? {});
+        for (const s of servers) {
+            if (s.kind === "http") {
+                // Codex headers are process-local; keep config.toml URL-only so credentials never persist.
+                mcpServers[s.name] = {
+                    url: s.url,
+                    ...(s.name !== "alan" && Object.keys(s.headers).length > 0
+                        ? { http_headers: s.headers }
+                        : {}),
+                };
+            }
+            else {
+                mcpServers[s.name] = {
+                    command: s.command,
+                    ...(s.args?.length ? { args: s.args } : {}),
+                    ...(s.env && Object.keys(s.env).length > 0 ? { env: s.env } : {}),
+                };
+            }
+        }
+        config.mcp_servers = mcpServers;
+        return stringifyToml(config);
+    },
+    remove(existing, serverNames) {
+        if (!existing)
+            return "";
+        let config = {};
+        try {
+            config = parseToml(existing);
+        }
+        catch {
+            return existing;
+        }
+        const mcpServers = (config.mcp_servers ?? {});
+        for (const name of serverNames)
+            delete mcpServers[name];
+        config.mcp_servers = mcpServers;
+        return stringifyToml(config);
+    },
+};
+const cursorAdapter = {
+    cli: "Cursor",
+    get configPath() {
+        return join(homeDirectory(), ".cursor", "mcp.json");
+    },
+    get guardDir() {
+        return join(homeDirectory(), ".cursor");
+    },
+    merge(existing, servers) {
+        const config = parseJsonSafe(existing);
+        const mcpServers = (config.mcpServers ?? {});
+        for (const s of servers) {
+            if (s.kind === "http") {
+                mcpServers[s.name] = {
+                    type: "http",
+                    url: s.url,
+                    headers: s.headers,
+                };
+            }
+            else {
+                mcpServers[s.name] = {
+                    command: s.command,
+                    ...(s.args?.length ? { args: s.args } : {}),
+                    ...(s.env && Object.keys(s.env).length > 0 ? { env: s.env } : {}),
+                };
+            }
+        }
+        config.mcpServers = mcpServers;
+        return JSON.stringify(config, null, 2);
+    },
+    remove(existing, serverNames) {
+        const config = parseJsonSafe(existing);
+        const mcpServers = (config.mcpServers ?? {});
+        for (const name of serverNames)
+            delete mcpServers[name];
+        config.mcpServers = mcpServers;
+        return JSON.stringify(config, null, 2);
+    },
+};
+function createAntigravityAdapter() {
+    return {
+        cli: "Antigravity CLI",
+        get configPath() {
+            return join(homeDirectory(), ".gemini", "config", "mcp_config.json");
+        },
+        get guardDir() {
+            return join(homeDirectory(), ".gemini", "config");
+        },
+        // Antigravity sends `initialize` without ever completing OAuth
+        // (google-antigravity/antigravity-cli#25), so a credential-free entry only
+        // loops 401s against /mcp. Gemini CLI is the Google client that gets one.
+        supportsHeaderlessHttp: false,
+        merge(existing, servers) {
+            const config = parseJsonSafe(existing);
+            const mcpServers = (config.mcpServers ?? {});
+            for (const s of servers) {
+                if (s.kind === "http") {
+                    mcpServers[s.name] = { serverUrl: s.url, headers: s.headers };
+                }
+                else {
+                    mcpServers[s.name] = {
+                        command: s.command,
+                        ...(s.args?.length ? { args: s.args } : {}),
+                        ...(s.env && Object.keys(s.env).length > 0 ? { env: s.env } : {}),
+                    };
+                }
+            }
+            config.mcpServers = mcpServers;
+            return JSON.stringify(config, null, 2);
+        },
+        remove(existing, serverNames) {
+            const config = parseJsonSafe(existing);
+            const mcpServers = (config.mcpServers ?? {});
+            for (const name of serverNames)
+                delete mcpServers[name];
+            config.mcpServers = mcpServers;
+            return JSON.stringify(config, null, 2);
+        },
+    };
+}
+const antigravityAdapter = createAntigravityAdapter();
+// Gemini CLI: `httpUrl` selects streamable HTTP; a headerless entry triggers
+// its automatic OAuth discovery on the first 401.
+const geminiAdapter = {
+    cli: "Gemini CLI",
+    get configPath() {
+        return join(homeDirectory(), ".gemini", "settings.json");
+    },
+    get guardDir() {
+        return join(homeDirectory(), ".gemini");
+    },
+    merge(existing, servers) {
+        const config = parseJsonSafe(existing);
+        const mcpServers = (config.mcpServers ?? {});
+        for (const s of servers) {
+            if (s.kind === "http") {
+                mcpServers[s.name] = { httpUrl: s.url, headers: s.headers };
+            }
+            else {
+                mcpServers[s.name] = {
+                    command: s.command,
+                    ...(s.args?.length ? { args: s.args } : {}),
+                    ...(s.env && Object.keys(s.env).length > 0 ? { env: s.env } : {}),
+                };
+            }
+        }
+        config.mcpServers = mcpServers;
+        return JSON.stringify(config, null, 2);
+    },
+    remove(existing, serverNames) {
+        const config = parseJsonSafe(existing);
+        const mcpServers = (config.mcpServers ?? {});
+        for (const name of serverNames)
+            delete mcpServers[name];
+        config.mcpServers = mcpServers;
+        return JSON.stringify(config, null, 2);
+    },
+};
+const kimiAdapter = {
+    cli: "Kimi CLI",
+    get configPath() {
+        return join(homeDirectory(), ".kimi", "mcp.json");
+    },
+    get guardDir() {
+        return join(homeDirectory(), ".kimi");
+    },
+    merge(existing, servers) {
+        const config = parseJsonSafe(existing);
+        const mcpServers = (config.mcpServers ?? {});
+        for (const s of servers) {
+            if (s.kind === "http") {
+                mcpServers[s.name] = { url: s.url, headers: s.headers };
+            }
+            else {
+                mcpServers[s.name] = {
+                    command: s.command,
+                    ...(s.args?.length ? { args: s.args } : {}),
+                    ...(s.env && Object.keys(s.env).length > 0 ? { env: s.env } : {}),
+                };
+            }
+        }
+        config.mcpServers = mcpServers;
+        return JSON.stringify(config, null, 2);
+    },
+    remove(existing, serverNames) {
+        const config = parseJsonSafe(existing);
+        const mcpServers = (config.mcpServers ?? {});
+        for (const name of serverNames)
+            delete mcpServers[name];
+        config.mcpServers = mcpServers;
+        return JSON.stringify(config, null, 2);
+    },
+};
+const opencodeAdapter = {
+    cli: "OpenCode",
+    get configPath() {
+        return join(homeDirectory(), ".config", "opencode", "opencode.json");
+    },
+    get guardDir() {
+        return join(homeDirectory(), ".config", "opencode");
+    },
+    merge(existing, servers) {
+        const config = parseJsonSafe(existing);
+        const mcp = (config.mcp ?? {});
+        for (const s of servers) {
+            if (s.kind === "http") {
+                mcp[s.name] = { type: "remote", url: s.url, headers: s.headers };
+            }
+            else {
+                mcp[s.name] = {
+                    type: "local",
+                    command: [s.command, ...(s.args ?? [])],
+                    ...(s.env && Object.keys(s.env).length > 0 ? { environment: s.env } : {}),
+                };
+            }
+        }
+        config.mcp = mcp;
+        return JSON.stringify(config, null, 2);
+    },
+    remove(existing, serverNames) {
+        const config = parseJsonSafe(existing);
+        const mcp = (config.mcp ?? {});
+        for (const name of serverNames)
+            delete mcp[name];
+        config.mcp = mcp;
+        return JSON.stringify(config, null, 2);
+    },
+};
+const factoryAdapter = {
+    cli: "Factory Droid",
+    get configPath() {
+        return join(homeDirectory(), ".factory", "mcp.json");
+    },
+    get guardDir() {
+        return join(homeDirectory(), ".factory");
+    },
+    merge(existing, servers) {
+        const config = parseJsonSafe(existing);
+        const mcpServers = (config.mcpServers ?? {});
+        for (const s of servers) {
+            if (s.kind === "http") {
+                mcpServers[s.name] = {
+                    type: "http",
+                    url: s.url,
+                    disabled: false,
+                    ...(s.headers && Object.keys(s.headers).length > 0 ? { headers: s.headers } : {}),
+                };
+            }
+            else {
+                mcpServers[s.name] = {
+                    type: "stdio",
+                    command: s.command,
+                    disabled: false,
+                    ...(s.args?.length ? { args: s.args } : {}),
+                    ...(s.env && Object.keys(s.env).length > 0 ? { env: s.env } : {}),
+                };
+            }
+        }
+        config.mcpServers = mcpServers;
+        return JSON.stringify(config, null, 2);
+    },
+    remove(existing, serverNames) {
+        const config = parseJsonSafe(existing);
+        const mcpServers = (config.mcpServers ?? {});
+        for (const name of serverNames)
+            delete mcpServers[name];
+        config.mcpServers = mcpServers;
+        return JSON.stringify(config, null, 2);
+    },
+};
+const ampAdapter = {
+    cli: "Amp",
+    get configPath() {
+        return join(homeDirectory(), ".config", "amp", "settings.json");
+    },
+    get guardDir() {
+        return join(homeDirectory(), ".config", "amp");
+    },
+    merge(existing, servers) {
+        const config = parseJsonSafe(existing);
+        const mcpServers = (config["amp.mcpServers"] ?? {});
+        for (const s of servers) {
+            if (s.kind === "http") {
+                mcpServers[s.name] = { url: s.url, headers: s.headers };
+            }
+            else {
+                mcpServers[s.name] = {
+                    command: s.command,
+                    ...(s.args?.length ? { args: s.args } : {}),
+                };
+            }
+        }
+        config["amp.mcpServers"] = mcpServers;
+        return JSON.stringify(config, null, 2);
+    },
+    remove(existing, serverNames) {
+        const config = parseJsonSafe(existing);
+        const mcpServers = (config["amp.mcpServers"] ?? {});
+        for (const name of serverNames)
+            delete mcpServers[name];
+        config["amp.mcpServers"] = mcpServers;
+        return JSON.stringify(config, null, 2);
+    },
+};
+const commandCodeAdapter = {
+    cli: "Command Code",
+    get configPath() {
+        return join(homeDirectory(), ".commandcode", "mcp.json");
+    },
+    get guardDir() {
+        return join(homeDirectory(), ".commandcode");
+    },
+    merge(existing, servers) {
+        const config = parseJsonSafe(existing);
+        const mcpServers = (config.mcpServers ?? {});
+        for (const s of servers) {
+            if (s.kind === "http") {
+                mcpServers[s.name] = {
+                    transport: "http",
+                    enabled: true,
+                    url: s.url,
+                    ...(s.headers && Object.keys(s.headers).length > 0 ? { headers: s.headers } : {}),
+                };
+            }
+            else {
+                mcpServers[s.name] = {
+                    transport: "stdio",
+                    enabled: true,
+                    command: s.command,
+                    ...(s.args?.length ? { args: s.args } : {}),
+                    ...(s.env && Object.keys(s.env).length > 0 ? { env: s.env } : {}),
+                };
+            }
+        }
+        config.mcpServers = mcpServers;
+        return JSON.stringify(config, null, 2);
+    },
+    remove(existing, serverNames) {
+        const config = parseJsonSafe(existing);
+        const mcpServers = (config.mcpServers ?? {});
+        for (const name of serverNames)
+            delete mcpServers[name];
+        config.mcpServers = mcpServers;
+        return JSON.stringify(config, null, 2);
+    },
+};
+const ALL_ADAPTERS = [
+    claudeAdapter,
+    codexAdapter,
+    cursorAdapter,
+    antigravityAdapter,
+    geminiAdapter,
+    kimiAdapter,
+    commandCodeAdapter,
+    opencodeAdapter,
+    factoryAdapter,
+    ampAdapter,
+];
+export const _adapters = {
+    claude: claudeAdapter,
+    codex: codexAdapter,
+    cursor: cursorAdapter,
+    antigravity: antigravityAdapter,
+    gemini: geminiAdapter,
+    kimi: kimiAdapter,
+    commandcode: commandCodeAdapter,
+    opencode: opencodeAdapter,
+    factory: factoryAdapter,
+    amp: ampAdapter,
+    setHomeDirectoryForTests(value) {
+        homeDirectoryOverride = value;
+    },
+};
+function serverEntry(adapter, content, name) {
+    if (adapter === codexAdapter) {
+        const parsed = parseToml(content);
+        const servers = parsed.mcp_servers;
+        return servers && typeof servers === "object"
+            ? servers[name]
+            : undefined;
+    }
+    const parsed = parseJsonSafe(content);
+    const key = adapter === opencodeAdapter ? "mcp" : adapter === ampAdapter ? "amp.mcpServers" : "mcpServers";
+    const servers = parsed[key];
+    return servers && typeof servers === "object"
+        ? servers[name]
+        : undefined;
+}
+function canonicalize(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, entry]) => [key, canonicalize(entry)]));
+    }
+    return value;
+}
+function entriesMatch(actual, expected) {
+    return JSON.stringify(canonicalize(actual)) === JSON.stringify(canonicalize(expected));
+}
+const ALAN_SESSION_HEADER_NAMES = new Set([
+    "x-conversation-id",
+    "x-team-id",
+    "x-allowed-tools",
+    "x-alan-run-reference",
+    "x-alan-run-id",
+]);
+function normalizeAlanSessionHeaders(actual, expected) {
+    if (!actual || typeof actual !== "object" || Array.isArray(actual))
+        return actual;
+    if (!expected || typeof expected !== "object" || Array.isArray(expected))
+        return actual;
+    const normalized = { ...actual };
+    const expectedHeaders = expected;
+    const hadAlanSessionMarker = Object.keys(normalized).some((key) => ALAN_SESSION_HEADER_NAMES.has(key.toLowerCase()));
+    for (const key of Object.keys(normalized)) {
+        if (ALAN_SESSION_HEADER_NAMES.has(key.toLowerCase()))
+            delete normalized[key];
+    }
+    if (hadAlanSessionMarker) {
+        const expectedAuthorization = Object.entries(expectedHeaders).find(([key]) => key.toLowerCase() === "authorization");
+        for (const key of Object.keys(normalized)) {
+            if (key.toLowerCase() === "authorization")
+                delete normalized[key];
+        }
+        if (expectedAuthorization) {
+            normalized[expectedAuthorization[0]] = expectedAuthorization[1];
+        }
+    }
+    return normalized;
+}
+function normalizeAlanRuntimeEntry(actual, expected) {
+    if (Array.isArray(actual)) {
+        if (!Array.isArray(expected))
+            return actual;
+        return actual.map((entry, index) => normalizeAlanRuntimeEntry(entry, expected[index]));
+    }
+    if (!actual || typeof actual !== "object" || Array.isArray(actual))
+        return actual;
+    if (!expected || typeof expected !== "object" || Array.isArray(expected))
+        return actual;
+    const expectedRecord = expected;
+    return Object.fromEntries(Object.entries(actual).map(([key, value]) => [
+        key,
+        key.toLowerCase() === "headers" || key.toLowerCase() === "http_headers"
+            ? normalizeAlanSessionHeaders(value, expectedRecord[key])
+            : normalizeAlanRuntimeEntry(value, expectedRecord[key]),
+    ]));
+}
+function matchesAlanManagedEntry(actual, expected) {
+    return (entriesMatch(actual, expected) ||
+        entriesMatch(normalizeAlanRuntimeEntry(actual, expected), expected));
+}
+const LOCAL_ALAN_MCP_HOSTS = new Set(["localhost", "127.0.0.1", "0.0.0.0"]);
+const LEGACY_LOCAL_ALAN_MCP_PORTS = new Set(["8400"]);
+const ALAN_MCP_HOST_SUFFIXES = [".tryalan.ai"];
+function normalizeMcpPathname(pathname) {
+    const trimmed = pathname.replace(/\/+$/, "");
+    return trimmed.length > 0 ? trimmed : "/";
+}
+function urlsShareAlanMcpEndpoint(left, right) {
+    try {
+        const a = new URL(left);
+        const b = new URL(right);
+        return (a.origin === b.origin && normalizeMcpPathname(a.pathname) === normalizeMcpPathname(b.pathname));
+    }
+    catch {
+        return left === right;
+    }
+}
+function configuredAlanMcpUrlsFromEnv() {
+    const urls = [];
+    for (const raw of [
+        process.env.ALAN_MCP_DESKTOP_URL,
+        process.env.ALAN_MCP_PUBLIC_URL,
+        process.env.ALAN_LOCAL_API_URL,
+    ]) {
+        const value = raw?.trim();
+        if (!value)
+            continue;
+        try {
+            const parsed = new URL(value);
+            if (normalizeMcpPathname(parsed.pathname) === "/mcp") {
+                urls.push(parsed.toString());
+                continue;
+            }
+            parsed.pathname = "/mcp";
+            urls.push(parsed.toString());
+        }
+        catch {
+            urls.push(value.endsWith("/mcp") ? value : `${value.replace(/\/$/, "")}/mcp`);
+        }
+    }
+    return urls;
+}
+function extractHttpUrlFromEntry(entry) {
+    if (!entry || typeof entry !== "object")
+        return undefined;
+    const record = entry;
+    for (const key of ["url", "httpUrl", "serverUrl"]) {
+        const value = record[key];
+        if (typeof value === "string" && value.length > 0)
+            return value;
+    }
+    for (const value of Object.values(record)) {
+        if (!value || typeof value !== "object")
+            continue;
+        const nested = extractHttpUrlFromEntry(value);
+        if (nested)
+            return nested;
+    }
+    return undefined;
+}
+function isAlanSelfRegistrationEntry(entry) {
+    const url = extractHttpUrlFromEntry(entry);
+    if (!url)
+        return false;
+    try {
+        const parsed = new URL(url);
+        if (normalizeMcpPathname(parsed.pathname) !== "/mcp")
+            return false;
+        const host = parsed.hostname.toLowerCase();
+        if (LOCAL_ALAN_MCP_HOSTS.has(host) && LEGACY_LOCAL_ALAN_MCP_PORTS.has(parsed.port)) {
+            return true;
+        }
+        if (ALAN_MCP_HOST_SUFFIXES.some((suffix) => host.endsWith(suffix)))
+            return true;
+        return configuredAlanMcpUrlsFromEnv().some((configured) => urlsShareAlanMcpEndpoint(configured, url));
+    }
+    catch {
+        return false;
+    }
+}
+// Alan session headers mark ownership across local/prod URL drift; bare `alan` names do not.
+function hasAlanManagedSignature(entry) {
+    if (!entry || typeof entry !== "object")
+        return false;
+    for (const [key, value] of Object.entries(entry)) {
+        const lower = key.toLowerCase();
+        if ((lower === "headers" || lower === "http_headers") && value && typeof value === "object") {
+            const headerNames = Object.keys(value);
+            if (headerNames.some((name) => ALAN_SESSION_HEADER_NAMES.has(name.toLowerCase()))) {
+                return true;
+            }
+        }
+        // Recurse into nested tables (codex TOML parses http_headers as a child object).
+        if (value && typeof value === "object" && hasAlanManagedSignature(value))
+            return true;
+    }
+    return false;
+}
+function isLegacyAlanProxyEntry(entry) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry))
+        return false;
+    const record = entry;
+    const command = typeof record.command === "string" ? record.command : "";
+    const args = Array.isArray(record.args) ? record.args : [];
+    return /(^|[/\\])alan-agent(?:\.cmd|\.exe)?$/.test(command) && args.includes("mcp-proxy");
+}
+function isHeaderlessHttpServer(server) {
+    return server.kind === "http" && Object.keys(server.headers).length === 0;
+}
+function expectedServerEntry(adapter, server) {
+    return serverEntry(adapter, adapter.merge(null, [server]), server.name);
+}
+function isManagedServerList(entries) {
+    return entries.length === 0 || typeof entries[0] !== "string";
+}
+function isAlanOwnedMcpEntry(entry, desiredEntry, previousEntry) {
+    return (hasAlanManagedSignature(entry) ||
+        isLegacyAlanProxyEntry(entry) ||
+        isAlanSelfRegistrationEntry(entry) ||
+        matchesAlanManagedEntry(entry, desiredEntry) ||
+        (previousEntry !== undefined && matchesAlanManagedEntry(entry, previousEntry)));
+}
+export function syncMcpToAllClis(servers, oldManagedServers = []) {
+    const written = [];
+    const failures = [];
+    for (const adapter of ALL_ADAPTERS) {
+        if (!existsSync(adapter.guardDir)) {
+            log.debug("MCP Adapters", `Skipping ${adapter.cli} — guard dir not found`, {
+                guardDir: adapter.guardDir,
+            });
+            continue;
+        }
+        const releaseLock = acquireConfigLock(adapter.configPath);
+        try {
+            const existing = readFileOr(adapter.configPath);
+            const previousServers = isManagedServerList(oldManagedServers) ? oldManagedServers : [];
+            const previousNames = isManagedServerList(oldManagedServers)
+                ? oldManagedServers.map((server) => server.name)
+                : oldManagedServers;
+            const previousByName = new Map(previousServers.map((server) => [server.name, server]));
+            const adapterServers = adapter.supportsHeaderlessHttp === false
+                ? servers.filter((server) => !isHeaderlessHttpServer(server))
+                : servers;
+            const skippedNames = servers
+                .filter((server) => !adapterServers.includes(server))
+                .map((server) => server.name);
+            if (existing) {
+                for (const server of adapterServers) {
+                    const currentEntry = serverEntry(adapter, existing, server.name);
+                    if (currentEntry === undefined)
+                        continue;
+                    const desiredEntry = expectedServerEntry(adapter, server);
+                    const previous = previousByName.get(server.name);
+                    const previousEntry = previous ? expectedServerEntry(adapter, previous) : undefined;
+                    if (!isAlanOwnedMcpEntry(currentEntry, desiredEntry, previousEntry)) {
+                        throw new Error(`an unowned entry already uses the name ${server.name}`);
+                    }
+                }
+            }
+            const currentNames = new Set(adapterServers.map((s) => s.name));
+            const toRemove = [
+                ...previousNames.filter((name) => !currentNames.has(name)),
+                ...skippedNames.filter((name) => !previousNames.includes(name)),
+            ];
+            if (!existing && skippedNames.length > 0 && adapterServers.length === 0) {
+                log.debug("MCP Adapters", `Skipping ${adapter.cli} — nothing it can authenticate`, {
+                    configPath: adapter.configPath,
+                });
+                continue;
+            }
+            let content;
+            if (toRemove.length > 0) {
+                const ownedNames = existing
+                    ? toRemove.filter((name) => {
+                        const entry = serverEntry(adapter, existing, name);
+                        const previous = previousByName.get(name);
+                        return (hasAlanManagedSignature(entry) ||
+                            isLegacyAlanProxyEntry(entry) ||
+                            isAlanSelfRegistrationEntry(entry) ||
+                            (previous !== undefined &&
+                                matchesAlanManagedEntry(entry, expectedServerEntry(adapter, previous))));
+                    })
+                    : [];
+                const cleaned = adapter.remove(existing, ownedNames);
+                content = adapter.merge(cleaned, adapterServers);
+            }
+            else {
+                content = adapter.merge(existing, adapterServers);
+            }
+            if (existing === content) {
+                log.debug("MCP Adapters", `${adapter.cli} already current`, {
+                    configPath: adapter.configPath,
+                });
+                continue;
+            }
+            writeFileSafe(adapter.configPath, content);
+            written.push(adapter.cli);
+            log.info("MCP Adapters", `Synced to ${adapter.cli}`, {
+                configPath: adapter.configPath,
+                serverCount: servers.length,
+            });
+        }
+        catch (err) {
+            const existing = readFileOr(adapter.configPath);
+            const backupPath = err instanceof MalformedToolConfigError && existing !== null
+                ? saveMalformedBackup(adapter.configPath, existing)
+                : undefined;
+            const message = `${adapter.cli}: ${err instanceof Error ? err.message : String(err)}${backupPath ? `; review ${backupPath}` : ""}`;
+            failures.push(message);
+            log.warn("MCP Adapters", `Failed to sync to ${adapter.cli}`, {
+                error: message,
+            });
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    if (failures.length > 0)
+        throw new Error(failures.join(" | "));
+    return written;
+}
+export function removeMcpFromAllClis(managedServers) {
+    if (managedServers.length === 0)
+        return;
+    const ownershipKnown = isManagedServerList(managedServers);
+    for (const adapter of ALL_ADAPTERS) {
+        if (!existsSync(adapter.guardDir))
+            continue;
+        const releaseLock = acquireConfigLock(adapter.configPath);
+        try {
+            const existing = readFileOr(adapter.configPath);
+            if (!existing)
+                continue;
+            const ownedNames = ownershipKnown
+                ? managedServers
+                    .filter((server) => matchesAlanManagedEntry(serverEntry(adapter, existing, server.name), expectedServerEntry(adapter, server)))
+                    .map((server) => server.name)
+                : [];
+            if (ownedNames.length === 0)
+                continue;
+            const content = adapter.remove(existing, ownedNames);
+            writeFileSafe(adapter.configPath, content);
+            log.info("MCP Adapters", `Cleaned up ${adapter.cli}`, {
+                removed: ownedNames,
+            });
+        }
+        catch (err) {
+            const existing = readFileOr(adapter.configPath);
+            const backupPath = err instanceof MalformedToolConfigError && existing !== null
+                ? saveMalformedBackup(adapter.configPath, existing)
+                : undefined;
+            log.warn("MCP Adapters", `Failed to clean up ${adapter.cli}`, {
+                error: `${err instanceof Error ? err.message : String(err)}${backupPath ? `; review ${backupPath}` : ""}`,
+            });
+        }
+        finally {
+            releaseLock();
+        }
+    }
+}
+const DEFAULT_ALAN_MCP_NAMES = ["alan"];
+// Prefer false negatives; bare `alan` server names are not enough.
+export function inspectAlanMcpPresence(expectedServers = [], candidateNames = DEFAULT_ALAN_MCP_NAMES) {
+    const configuredClis = [];
+    const inspectedClis = [];
+    const serverNamesFound = new Set();
+    const names = new Set([
+        ...candidateNames,
+        ...expectedServers.map((server) => server.name),
+    ]);
+    const expectedByName = new Map(expectedServers.map((server) => [server.name, server]));
+    for (const adapter of ALL_ADAPTERS) {
+        if (!existsSync(adapter.guardDir))
+            continue;
+        inspectedClis.push(adapter.cli);
+        const existing = readFileOr(adapter.configPath);
+        if (!existing)
+            continue;
+        let foundOnCli = false;
+        for (const name of names) {
+            let entry;
+            try {
+                entry = serverEntry(adapter, existing, name);
+            }
+            catch {
+                // Malformed config — cannot prove Alan MCP is present.
+                continue;
+            }
+            if (entry === undefined)
+                continue;
+            const expected = expectedByName.get(name);
+            const matchesExpected = expected
+                ? matchesAlanManagedEntry(entry, expectedServerEntry(adapter, expected))
+                : false;
+            if (!hasAlanManagedSignature(entry) &&
+                !isLegacyAlanProxyEntry(entry) &&
+                !matchesExpected &&
+                !isAlanSelfRegistrationEntry(entry)) {
+                continue;
+            }
+            foundOnCli = true;
+            serverNamesFound.add(name);
+        }
+        if (foundOnCli)
+            configuredClis.push(adapter.cli);
+    }
+    return {
+        configured: configuredClis.length > 0,
+        configuredClis,
+        inspectedClis,
+        serverNamesFound: [...serverNamesFound],
+    };
+}
+export function toManagedMcpServers(mcpServers) {
+    const result = [];
+    for (const [name, config] of Object.entries(mcpServers)) {
+        if (!config || typeof config !== "object")
+            continue;
+        const c = config;
+        if (c.command && typeof c.command === "string") {
+            result.push({
+                name,
+                kind: "stdio",
+                command: c.command,
+                args: c.args ?? undefined,
+                env: c.env ?? undefined,
+            });
+        }
+        else {
+            result.push({
+                name,
+                kind: "http",
+                url: c.url ?? "",
+                headers: c.headers ?? {},
+            });
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=mcp-config-adapters.js.map