@switchboard-mcp/core 0.1.0

package/dist/import/import-plan.js

@@ -0,0 +1,677 @@
+import { constants, readdirSync, readFileSync, statSync } from "node:fs";
+import { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { deepMerge, loadSwitchboardConfig } from "../config/load-config.js";
+import { resolveRepoConfigPaths } from "../config/paths.js";
+import { resolveProjectClientConfigPath } from "../install/client-config.js";
+import { normalizeNamespace } from "../namespaces/namespaces.js";
+import { switchboardConfigSchema } from "../schemas/config.js";
+export const importPlanSchemaVersion = "switchboard.import-plan.v1";
+const providerEnvPrefixes = {
+    github: [/^GITHUB_/i, /^GH_TOKEN$/i, /^GH_/i],
+    vercel: [/^VERCEL_/i],
+    stripe: [/^STRIPE_/i],
+    supabase: [/^SUPABASE_/i],
+    posthog: [/^POSTHOG_/i, /^NEXT_PUBLIC_POSTHOG_/i]
+};
+export async function createSwitchboardImportPlan(options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const repoName = basename(cwd);
+    const loaded = loadSwitchboardConfig({ cwd });
+    const profileNames = new Set(Object.keys(loaded.config.profiles));
+    const switchboardProfiles = Object.entries(loaded.config.profiles).map(([name, profile]) => ({
+        name,
+        provider: profile.provider ?? null,
+        namespace: profile.namespace ?? null
+    }));
+    const clients = detectClientConfigs(cwd, repoName);
+    const envFiles = detectEnvFiles(cwd);
+    const detectedServers = clients.flatMap((client) => client.servers.filter((server) => server.name !== "switchboard"));
+    const createProfileActions = uniqueServersByProfile(detectedServers)
+        .filter((server) => !profileNames.has(server.suggestedProfileName))
+        .map((server) => createProfileAction(server));
+    const secretActions = uniqueSecretRefs(detectedServers).map((secret) => ({
+        kind: "store-secret",
+        title: `Store ${secret.envName} as ${secret.ref}`,
+        status: "planned",
+        provider: providerFromEnvName(secret.envName),
+        command: {
+            command: "switchboard",
+            args: ["secrets", "set", secret.ref, "--value-stdin"]
+        },
+        reason: "The existing MCP config references this secret-looking env name; Switchboard will keep values out of repo and client config."
+    }));
+    const clientsMissingSwitchboard = clients.filter((client) => client.status !== "detected" ||
+        !client.servers.some((server) => server.routesThroughSwitchboard));
+    const installActions = clientsMissingSwitchboard
+        .map((client) => ({
+        kind: "install-client",
+        title: `Route ${client.client} through Switchboard MCP`,
+        status: "planned",
+        client: client.client,
+        command: {
+            command: "switchboard",
+            args: ["install", client.client, "--write"]
+        },
+        reason: "Importing profiles is separate from client installation so existing client config stays reversible."
+    }));
+    const reviewActions = switchboardProfiles.map((profile) => ({
+        kind: "review-existing-profile",
+        title: `Review existing Switchboard profile ${profile.name}`,
+        status: "already-configured",
+        profileName: profile.name,
+        provider: providerFromProfile(profile.provider),
+        reason: "Existing Switchboard profiles are preserved; import dry-run only plans around them."
+    }));
+    const secretCommands = secretActions.map((action) => action.command);
+    const installClients = clientsMissingSwitchboard.map((client) => ({
+        command: "switchboard",
+        args: ["install", client.client, "--write"]
+    }));
+    const actions = [
+        ...createProfileActions,
+        ...secretActions,
+        ...installActions,
+        ...reviewActions
+    ];
+    const warnings = buildWarnings({ clients, envFiles, detectedServers });
+    const safetyNotes = [
+        "Dry run only: this command does not write .switchboard.yaml or client config.",
+        "Secret values are never read from env files or client config; only env variable names are reported.",
+        "Imported MCP servers should be treated as setup candidates until doctor and preset checks pass.",
+        "Run client install separately so existing Codex/Claude config remains backup-protected and reversible."
+    ];
+    const nextActions = [
+        "switchboard import --dry-run",
+        ...secretCommands.map((command) => renderCommand(command)),
+        ...installClients.map((command) => renderCommand(command))
+    ];
+    return {
+        ok: true,
+        schemaVersion: importPlanSchemaVersion,
+        mode: "dry-run",
+        repo: { cwd, name: repoName },
+        detected: {
+            clients,
+            switchboardProfiles,
+            envFiles
+        },
+        actions,
+        commands: {
+            dryRun: { command: "switchboard", args: ["import", "--dry-run"] },
+            writePreview: { command: "switchboard", args: ["import", "--write"] },
+            installClients,
+            secretCommands
+        },
+        warnings,
+        safetyNotes,
+        nextActions: [...new Set(nextActions)]
+    };
+}
+export async function writeSwitchboardImportPlan(options = {}) {
+    const plan = await createSwitchboardImportPlan(options);
+    const cwd = plan.repo.cwd;
+    const targetPath = resolveRepoConfigPaths({ cwd }).repoConfigPath ?? join(cwd, ".switchboard.yaml");
+    const importableServers = uniqueServersByProfile(plan.detected.clients.flatMap((client) => client.servers.filter((server) => !server.routesThroughSwitchboard &&
+        server.command !== null &&
+        !plan.detected.switchboardProfiles.some((profile) => profile.name === server.suggestedProfileName))));
+    if (importableServers.length === 0) {
+        return {
+            ok: true,
+            schemaVersion: importPlanSchemaVersion,
+            action: "noop",
+            targetPath,
+            backupPath: null,
+            plan,
+            createdProfiles: [],
+            nextContent: null
+        };
+    }
+    assertNoNamespaceCollisions(plan, importableServers);
+    const existing = await readOptionalTextFileAsync(targetPath);
+    const nextContent = renderMergedImportConfig(existing, importableServers);
+    await mkdir(dirname(targetPath), { recursive: true });
+    const backupPath = existing
+        ? await backupExistingFile(targetPath, options.now)
+        : null;
+    await writeFile(targetPath, nextContent, "utf8");
+    return {
+        ok: true,
+        schemaVersion: importPlanSchemaVersion,
+        action: existing ? "updated" : "created",
+        targetPath,
+        backupPath,
+        plan,
+        createdProfiles: importableServers.map((server) => server.suggestedProfileName),
+        nextContent
+    };
+}
+function assertNoNamespaceCollisions(plan, servers) {
+    const existing = new Map();
+    for (const profile of plan.detected.switchboardProfiles) {
+        existing.set(normalizeNamespace(profile.namespace ?? profile.name), profile.name);
+    }
+    const planned = new Map();
+    for (const server of servers) {
+        const namespace = normalizeNamespace(server.suggestedNamespace);
+        const existingProfile = existing.get(namespace);
+        if (existingProfile && existingProfile !== server.suggestedProfileName) {
+            throw new Error(`namespace "${namespace}" would collide with existing profile "${existingProfile}"`);
+        }
+        const plannedProfile = planned.get(namespace);
+        if (plannedProfile && plannedProfile !== server.suggestedProfileName) {
+            throw new Error(`namespace "${namespace}" would collide between planned profiles "${plannedProfile}" and "${server.suggestedProfileName}"`);
+        }
+        planned.set(namespace, server.suggestedProfileName);
+    }
+}
+function renderMergedImportConfig(existingContent, servers) {
+    const rendered = renderImportConfig(servers);
+    if (!existingContent?.trim()) {
+        return `${stringifyYaml(rendered, { lineWidth: 0 })}`;
+    }
+    const existing = parseConfigYaml(existingContent, ".switchboard.yaml");
+    const merged = deepMerge(existing, rendered);
+    const parsed = switchboardConfigSchema.safeParse(merged);
+    if (!parsed.success) {
+        throw new Error(parsed.error.issues.map((issue) => issue.message).join("\n"));
+    }
+    return `${stringifyYaml(ensureDefaultWorkspaceProfiles(parsed.data), {
+        lineWidth: 0
+    })}`;
+}
+function renderImportConfig(servers) {
+    const profiles = Object.fromEntries(servers.map((server) => [
+        server.suggestedProfileName,
+        {
+            provider: server.provider === "unknown" ? "generic" : server.provider,
+            namespace: server.suggestedNamespace,
+            readOnly: false,
+            mode: "guarded",
+            enforcement: "switchboard",
+            upstream: {
+                type: "stdio",
+                command: server.command ?? "",
+                ...(server.args.length > 0 ? { args: server.args } : {}),
+                ...renderImportedEnv(server)
+            }
+        }
+    ]));
+    return {
+        version: 1,
+        defaults: {},
+        profiles,
+        workspaces: {
+            default: {
+                paths: ["."],
+                profiles: servers.map((server) => server.suggestedProfileName)
+            }
+        },
+        policies: {}
+    };
+}
+function renderImportedEnv(server) {
+    const env = Object.fromEntries(server.suggestedSecretRefs.map((secret) => [
+        secret.envName,
+        { secretRef: secret.ref }
+    ]));
+    return Object.keys(env).length > 0 ? { env } : {};
+}
+function ensureDefaultWorkspaceProfiles(config) {
+    const defaultWorkspace = config.workspaces.default;
+    if (!defaultWorkspace) {
+        return config;
+    }
+    return {
+        ...config,
+        workspaces: {
+            ...config.workspaces,
+            default: {
+                ...defaultWorkspace,
+                paths: unique(defaultWorkspace.paths),
+                profiles: unique(defaultWorkspace.profiles)
+            }
+        }
+    };
+}
+function parseConfigYaml(content, label) {
+    const parsed = content.trim().length === 0 ? {} : parseYaml(content);
+    if (parsed === null || parsed === undefined) {
+        return {};
+    }
+    if (typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`${label} must be a YAML mapping`);
+    }
+    return parsed;
+}
+function uniqueServersByProfile(servers) {
+    const byProfile = new Map();
+    for (const server of servers) {
+        byProfile.set(server.suggestedProfileName, server);
+    }
+    return [...byProfile.values()];
+}
+function detectClientConfigs(cwd, repoName) {
+    return [
+        detectCodexConfig(resolveProjectClientConfigPath("codex", cwd), repoName),
+        detectClaudeConfig(resolveProjectClientConfigPath("claude", cwd), repoName)
+    ];
+}
+function detectCodexConfig(targetPath, repoName) {
+    const content = readOptionalTextFile(targetPath);
+    if (content === null) {
+        return missingClient("codex", targetPath);
+    }
+    try {
+        return {
+            client: "codex",
+            targetPath,
+            status: "detected",
+            message: "Codex project MCP config was found.",
+            servers: codexServerSections(content).map((section) => detectedServerFromEntry({
+                repoName,
+                name: section.name,
+                command: parseTomlString(section.assignments.command),
+                args: parseTomlStringArray(section.assignments.args),
+                envKeys: [
+                    ...parseTomlInlineObjectKeys(section.assignments.env),
+                    ...section.envKeys
+                ]
+            }))
+        };
+    }
+    catch (error) {
+        return invalidClient("codex", targetPath, error);
+    }
+}
+function detectClaudeConfig(targetPath, repoName) {
+    const content = readOptionalTextFile(targetPath);
+    if (content === null) {
+        return missingClient("claude", targetPath);
+    }
+    try {
+        const parsed = JSON.parse(content);
+        const mcpServers = isRecord(parsed.mcpServers) ? parsed.mcpServers : {};
+        return {
+            client: "claude",
+            targetPath,
+            status: "detected",
+            message: "Claude project MCP config was found.",
+            servers: Object.entries(mcpServers).map(([name, value]) => detectedServerFromEntry({
+                repoName,
+                name,
+                command: isRecord(value) && typeof value.command === "string"
+                    ? value.command
+                    : null,
+                args: isRecord(value) && Array.isArray(value.args)
+                    ? value.args.filter((arg) => typeof arg === "string")
+                    : [],
+                envKeys: isRecord(value) && isRecord(value.env)
+                    ? Object.keys(value.env).sort()
+                    : []
+            }))
+        };
+    }
+    catch (error) {
+        return invalidClient("claude", targetPath, error);
+    }
+}
+function missingClient(client, targetPath) {
+    return {
+        client,
+        targetPath,
+        status: "missing",
+        message: `${client} project MCP config was not found.`,
+        servers: []
+    };
+}
+function invalidClient(client, targetPath, error) {
+    return {
+        client,
+        targetPath,
+        status: "invalid",
+        message: messageFromError(error),
+        servers: []
+    };
+}
+function detectedServerFromEntry(options) {
+    const routesThroughSwitchboard = options.name === "switchboard";
+    const provider = routesThroughSwitchboard
+        ? "unknown"
+        : inferProvider({
+            name: options.name,
+            command: options.command,
+            args: options.args,
+            envKeys: options.envKeys
+        });
+    const environment = inferEnvironment(options);
+    const profileBase = provider === "unknown" ? options.name : `${provider}_${options.repoName}`;
+    const suggestedProfileName = safeIdentifier(environment === "unknown" ? profileBase : `${profileBase}_${environment}`);
+    return {
+        name: options.name,
+        routesThroughSwitchboard,
+        command: options.command,
+        args: options.args,
+        envKeys: [...new Set(options.envKeys)].sort(),
+        provider,
+        suggestedProfileName,
+        suggestedNamespace: suggestedProfileName,
+        suggestedSecretRefs: options.envKeys
+            .filter(isSecretLikeName)
+            .map((envName) => ({
+            envName,
+            ref: `${provider === "unknown" ? "mcp" : provider}/${safeIdentifier(options.repoName)}/${environment === "unknown" ? "dev" : environment}/${secretRefLeaf(envName)}`
+        }))
+    };
+}
+function createProfileAction(server) {
+    return {
+        kind: "create-profile",
+        title: `Create Switchboard profile ${server.suggestedProfileName}`,
+        status: "planned",
+        serverName: server.name,
+        profileName: server.suggestedProfileName,
+        provider: server.provider,
+        reason: "An existing MCP server was found in project client config and can be routed through Switchboard."
+    };
+}
+function uniqueSecretRefs(servers) {
+    const byRef = new Map();
+    for (const server of servers) {
+        for (const secret of server.suggestedSecretRefs) {
+            byRef.set(secret.ref, secret);
+        }
+    }
+    return [...byRef.values()].sort((a, b) => a.ref.localeCompare(b.ref));
+}
+function detectEnvFiles(cwd) {
+    let entries;
+    try {
+        entries = readdirSync(cwd);
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((entry) => /^\.env(?:\.|$)/.test(entry))
+        .map((entry) => join(cwd, entry))
+        .filter((path) => safeIsFile(path))
+        .map((path) => {
+        const envKeys = envVarNames(readFileSync(path, "utf8"));
+        return {
+            path,
+            envKeys,
+            providerHints: [...new Set(envKeys.map(providerFromEnvName))]
+        };
+    });
+}
+function buildWarnings(options) {
+    const warnings = [];
+    for (const client of options.clients) {
+        if (client.status === "invalid") {
+            warnings.push(`${client.client} config could not be parsed: ${client.message}`);
+        }
+        if (client.servers.some((server) => server.name === "switchboard")) {
+            warnings.push(`${client.client} already has a switchboard MCP server; import will preserve it.`);
+        }
+    }
+    if (options.detectedServers.length === 0) {
+        warnings.push("No existing project MCP servers were found to import.");
+    }
+    if (options.envFiles.some((file) => file.envKeys.some((key) => isSecretLikeName(key)))) {
+        warnings.push("Secret-looking env var names were found in env files; import reports names only and does not read values.");
+    }
+    if (options.detectedServers.some((server) => server.envKeys.some((key) => isSecretLikeName(key)))) {
+        warnings.push("Existing MCP configs reference secret-looking env names; store values behind Switchboard local token aliases before routing agents.");
+    }
+    return [...new Set(warnings)];
+}
+function codexServerSections(content) {
+    const sections = [];
+    let current = null;
+    for (const line of content.split(/\r?\n/)) {
+        const serverHeader = line.match(/^\s*\[mcp_servers\.([^\].]+)\]\s*$/);
+        const envHeader = line.match(/^\s*\[mcp_servers\.([^\].]+)\.env\]\s*$/);
+        if (serverHeader?.[1]) {
+            if (current) {
+                sections.push(current);
+            }
+            current = {
+                name: unquoteTomlKey(serverHeader[1]),
+                assignments: {},
+                envKeys: [],
+                envSection: false
+            };
+            continue;
+        }
+        if (envHeader?.[1]) {
+            if (current) {
+                sections.push(current);
+            }
+            current = {
+                name: unquoteTomlKey(envHeader[1]),
+                assignments: {},
+                envKeys: [],
+                envSection: true
+            };
+            continue;
+        }
+        if (!current) {
+            continue;
+        }
+        const assignment = line.match(/^\s*([A-Za-z_][A-Za-z0-9_-]*)\s*=\s*(.*?)\s*$/);
+        if (!assignment?.[1] || assignment[2] === undefined) {
+            continue;
+        }
+        if (current.envSection) {
+            current.envKeys.push(assignment[1]);
+        }
+        else {
+            current.assignments[assignment[1]] = assignment[2];
+        }
+    }
+    if (current) {
+        sections.push(current);
+    }
+    const merged = new Map();
+    for (const section of sections) {
+        const existing = merged.get(section.name);
+        if (existing) {
+            Object.assign(existing.assignments, section.assignments);
+            existing.envKeys.push(...section.envKeys);
+        }
+        else {
+            merged.set(section.name, {
+                name: section.name,
+                assignments: { ...section.assignments },
+                envKeys: [...section.envKeys]
+            });
+        }
+    }
+    return [...merged.values()];
+}
+function parseTomlString(value) {
+    if (!value) {
+        return null;
+    }
+    const match = value.match(/^"((?:\\"|[^"])*)"$/);
+    return match?.[1]?.replace(/\\"/g, "\"") ?? null;
+}
+function parseTomlStringArray(value) {
+    if (!value) {
+        return [];
+    }
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) {
+        return [];
+    }
+    const matches = [...trimmed.matchAll(/"((?:\\"|[^"])*)"/g)];
+    return matches.map((match) => (match[1] ?? "").replace(/\\"/g, "\""));
+}
+function parseTomlInlineObjectKeys(value) {
+    if (!value) {
+        return [];
+    }
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
+        return [];
+    }
+    return [...trimmed.matchAll(/([A-Za-z_][A-Za-z0-9_-]*)\s*=/g)]
+        .map((match) => match[1])
+        .filter((key) => key !== undefined)
+        .sort();
+}
+function unquoteTomlKey(value) {
+    return value.replace(/^"|"$/g, "");
+}
+function envVarNames(content) {
+    const names = new Set();
+    for (const line of content.split(/\r?\n/)) {
+        const match = line.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/);
+        if (match?.[1]) {
+            names.add(match[1]);
+        }
+    }
+    return [...names].sort();
+}
+function inferProvider(options) {
+    const haystack = [options.name, options.command ?? "", ...options.args, ...options.envKeys]
+        .join(" ")
+        .toLowerCase();
+    for (const provider of Object.keys(providerEnvPrefixes)) {
+        if (haystack.includes(provider)) {
+            return provider;
+        }
+    }
+    if (options.envKeys.some((key) => providerFromEnvName(key) !== "unknown")) {
+        return providerFromEnvName(options.envKeys.find((key) => providerFromEnvName(key) !== "unknown") ?? "");
+    }
+    return "unknown";
+}
+function providerFromEnvName(name) {
+    for (const [provider, patterns] of Object.entries(providerEnvPrefixes)) {
+        if (patterns.some((pattern) => pattern.test(name))) {
+            return provider;
+        }
+    }
+    return "unknown";
+}
+function providerFromProfile(value) {
+    if (value === "github" ||
+        value === "vercel" ||
+        value === "stripe" ||
+        value === "supabase" ||
+        value === "posthog") {
+        return value;
+    }
+    return "unknown";
+}
+function inferEnvironment(options) {
+    const text = [options.name, ...options.args, ...options.envKeys].join(" ");
+    if (/(^|[_\-.])(prod|production|live)([_\-.]|$)/i.test(text)) {
+        return "prod";
+    }
+    if (/(^|[_\-.])preview([_\-.]|$)/i.test(text)) {
+        return "preview";
+    }
+    if (/(^|[_\-.])(test|testing)([_\-.]|$)/i.test(text)) {
+        return "test";
+    }
+    if (/(^|[_\-.])(dev|development|local)([_\-.]|$)/i.test(text)) {
+        return "dev";
+    }
+    return "unknown";
+}
+function safeIdentifier(value) {
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+    return normalized.length > 0 ? normalized : "mcp_server";
+}
+function secretRefLeaf(envName) {
+    if (/TOKEN/i.test(envName)) {
+        return "token";
+    }
+    if (/KEY/i.test(envName)) {
+        return "key";
+    }
+    if (/SECRET/i.test(envName)) {
+        return "secret";
+    }
+    return safeIdentifier(envName);
+}
+function isSecretLikeName(name) {
+    return /(SECRET|TOKEN|KEY|PASSWORD|PRIVATE)/i.test(name);
+}
+function renderCommand(command) {
+    return ["switchboard", ...command.args].join(" ");
+}
+async function readOptionalTextFileAsync(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+function readOptionalTextFile(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+async function backupExistingFile(path, now) {
+    const baseBackupPath = `${path}.switchboard-backup-${backupTimestamp(now)}`;
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+        const backupPath = attempt === 0 ? baseBackupPath : `${baseBackupPath}-${attempt}`;
+        try {
+            await copyFile(path, backupPath, constants.COPYFILE_EXCL);
+            return backupPath;
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                "code" in error &&
+                error.code === "EEXIST") {
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error(`could not create a unique backup path for ${path}`);
+}
+function backupTimestamp(now = new Date()) {
+    return now.toISOString().replaceAll(/[-:.]/g, "").replace("T", "-");
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function safeIsFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function messageFromError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=import-plan.js.map