@proofofwork-agency/toolpin 0.2.3

package/dist/continueYaml.js

@@ -0,0 +1,76 @@
+import { parseDocument, stringify } from "yaml";
+const DEFAULT_CONTINUE_CONFIG = {
+    name: "ToolPin Config",
+    version: "1.0.0",
+    schema: "v1",
+    mcpServers: [],
+};
+export function continueYamlFromClientConfig(config) {
+    return `${stringify(normalizeContinueConfig(config))}`;
+}
+export function mergeContinueYaml(existing, incoming) {
+    const root = normalizeContinueConfig(parseYamlObject(existing));
+    const incomingRoot = normalizeContinueConfig(incoming);
+    const nextServers = mergeServers(root.mcpServers, incomingRoot.mcpServers);
+    return continueYamlFromClientConfig({ ...root, mcpServers: nextServers });
+}
+export function removeContinueServerYaml(existing, serverName) {
+    const parsed = parseYamlObject(existing);
+    if (!parsed)
+        return existing;
+    const root = normalizeContinueConfig(parsed);
+    const nextServers = root.mcpServers.filter((server) => asRecord(server).name !== serverName);
+    if (nextServers.length === root.mcpServers.length)
+        return existing;
+    return continueYamlFromClientConfig({ ...root, mcpServers: nextServers });
+}
+export function readContinueServerConfig(raw, serverName) {
+    const parsed = parseYamlObject(raw);
+    if (!parsed)
+        return undefined;
+    const root = normalizeContinueConfig(parsed);
+    return root.mcpServers.find((server) => asRecord(server).name === serverName);
+}
+function mergeServers(existing, incoming) {
+    const next = [...existing];
+    for (const server of incoming) {
+        const name = asRecord(server).name;
+        if (typeof name !== "string")
+            continue;
+        const index = next.findIndex((candidate) => asRecord(candidate).name === name);
+        if (index >= 0) {
+            next[index] = server;
+        }
+        else {
+            next.push(server);
+        }
+    }
+    return next;
+}
+function normalizeContinueConfig(config) {
+    const root = asRecord(config);
+    const mcpServers = Array.isArray(root.mcpServers) ? root.mcpServers : [];
+    return {
+        ...root,
+        name: typeof root.name === "string" ? root.name : DEFAULT_CONTINUE_CONFIG.name,
+        version: typeof root.version === "string" ? root.version : DEFAULT_CONTINUE_CONFIG.version,
+        schema: typeof root.schema === "string" ? root.schema : DEFAULT_CONTINUE_CONFIG.schema,
+        mcpServers,
+    };
+}
+function parseYamlObject(raw) {
+    if (!raw.trim())
+        return undefined;
+    const document = parseDocument(raw);
+    if (document.errors.length) {
+        throw new Error(document.errors.map((error) => error.message).join("; "));
+    }
+    const parsed = document.toJS();
+    return isRecord(parsed) ? parsed : undefined;
+}
+function asRecord(value) {
+    return isRecord(value) ? value : {};
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/doctor.js

@@ -0,0 +1,163 @@
+import { readFile } from "node:fs/promises";
+import { canonicalJson } from "./canonicalJson.js";
+import { readCodexServerConfig } from "./codexToml.js";
+import { clientConfigRootKey } from "./config.js";
+import { readContinueServerConfig } from "./continueYaml.js";
+import { resolveConfigTarget } from "./install.js";
+import { readLockfile } from "./plan.js";
+export async function doctorLockfile(lockfilePath = "mcp-lock.json", scope = "all") {
+    const lockfile = await readLockfile(lockfilePath);
+    const issues = [];
+    const entries = Object.entries(lockfile.servers);
+    for (const [key, plan] of entries) {
+        const expected = expectedServerConfig(plan);
+        if (!expected) {
+            issues.push({
+                key,
+                kind: "invalid",
+                client: plan.client,
+                serverName: plan.name,
+                file: "",
+                message: "locked plan does not contain a comparable client config entry",
+            });
+            continue;
+        }
+        const missing = [];
+        const invalidScopes = [];
+        let foundConfig = false;
+        let foundUnreadable = false;
+        for (const currentScope of scopesToCheck(scope, plan)) {
+            let target;
+            try {
+                target = resolveConfigTarget(plan.client, currentScope);
+            }
+            catch (error) {
+                invalidScopes.push(`${currentScope}: ${error instanceof Error ? error.message : String(error)}`);
+                continue;
+            }
+            const actual = await readInstalledServerConfig(target.file, plan.name, plan.client);
+            if (actual.kind === "missing") {
+                missing.push({ scope: currentScope, file: target.file });
+                continue;
+            }
+            if (actual.kind === "unreadable") {
+                foundUnreadable = true;
+                issues.push({
+                    key,
+                    kind: "unreadable",
+                    client: plan.client,
+                    serverName: plan.name,
+                    file: target.file,
+                    scope: currentScope,
+                    message: actual.message,
+                });
+                continue;
+            }
+            foundConfig = true;
+            if (stableJson(actual.config) !== stableJson(expected)) {
+                issues.push({
+                    key,
+                    kind: "drift",
+                    client: plan.client,
+                    serverName: plan.name,
+                    file: target.file,
+                    scope: currentScope,
+                    message: `client config entry differs from ${lockfilePath}`,
+                });
+            }
+        }
+        if (!foundConfig && !foundUnreadable && missing.length > 0) {
+            issues.push({
+                key,
+                kind: "missing",
+                client: plan.client,
+                serverName: plan.name,
+                file: missing.map((entry) => entry.file).join(", "),
+                scope: scope === "all" ? undefined : missing[0]?.scope,
+                message: scope === "all"
+                    ? `missing ${plan.client} config entry for ${plan.name} in checked scopes: ${missing.map((entry) => entry.scope).join(", ")}`
+                    : `missing ${plan.client} config entry for ${plan.name}`,
+            });
+            continue;
+        }
+        if (!foundConfig && !foundUnreadable && missing.length === 0 && invalidScopes.length > 0) {
+            issues.push({
+                key,
+                kind: "invalid",
+                client: plan.client,
+                serverName: plan.name,
+                file: "",
+                message: `cannot check ${plan.client} at ${scope} scope: ${invalidScopes.join("; ")}`,
+            });
+        }
+    }
+    return {
+        ok: issues.length === 0,
+        checked: entries.length,
+        issues,
+    };
+}
+function scopesToCheck(scope, plan) {
+    if (scope !== "all")
+        return [scope];
+    return plan.scope ? [plan.scope] : ["project", "global"];
+}
+function expectedServerConfig(plan) {
+    return serverConfigFromWrapped(plan.locked?.config ?? plan.config, plan.name, plan.client);
+}
+export async function readInstalledServerConfig(file, serverName, client) {
+    let raw;
+    try {
+        raw = await readFile(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { kind: "missing" };
+        return { kind: "unreadable", message: error instanceof Error ? error.message : String(error) };
+    }
+    if (client === "codex") {
+        const config = readCodexServerConfig(raw, serverName);
+        return config ? { kind: "ok", config } : { kind: "missing" };
+    }
+    if (client === "continue") {
+        try {
+            const config = readContinueServerConfig(raw, serverName);
+            return config ? { kind: "ok", config } : { kind: "missing" };
+        }
+        catch (error) {
+            return {
+                kind: "unreadable",
+                message: `invalid YAML in ${file}: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        const config = serverConfigFromWrapped(parsed, serverName, client);
+        return config ? { kind: "ok", config } : { kind: "missing" };
+    }
+    catch (error) {
+        return {
+            kind: "unreadable",
+            message: `invalid JSON in ${file}: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+function serverConfigFromWrapped(config, serverName, client) {
+    if (client === "continue") {
+        const servers = asRecord(config).mcpServers;
+        return Array.isArray(servers) ? servers.find((server) => asRecord(server).name === serverName) : undefined;
+    }
+    const root = asRecord(config);
+    const section = clientConfigRootKey(client);
+    return asRecord(root[section])[serverName];
+}
+function stableJson(value) {
+    return canonicalJson(value, { pruneEmptyObjects: true });
+}
+function asRecord(value) {
+    return isRecord(value) ? value : {};
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/install.js

@@ -0,0 +1,191 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { clientConfigRootKey, exportClientConfig } from "./config.js";
+import { mergeCodexToml, removeCodexServerToml } from "./codexToml.js";
+import { mergeContinueYaml, removeContinueServerYaml } from "./continueYaml.js";
+export async function installServerConfig(server, client, scope) {
+    const exported = exportClientConfig(server, client);
+    const target = resolveConfigTarget(client, scope);
+    if (client === "codex") {
+        const existing = await readText(target.file);
+        const next = mergeCodexToml(existing, exported.config);
+        await mkdir(path.dirname(target.file), { recursive: true });
+        await writeFile(target.file, next, "utf8");
+        return {
+            client,
+            scope,
+            file: target.file,
+            serverName: server.name,
+            action: existing.trim().length === 0 ? "created" : "updated",
+            notes: [...target.notes, ...exported.notes],
+        };
+    }
+    if (client === "continue") {
+        const existing = await readText(target.file);
+        const next = mergeContinueYaml(existing, exported.config);
+        await mkdir(path.dirname(target.file), { recursive: true });
+        await writeFile(target.file, next, "utf8");
+        return {
+            client,
+            scope,
+            file: target.file,
+            serverName: server.name,
+            action: existing.trim().length === 0 ? "created" : "updated",
+            notes: [...target.notes, ...exported.notes],
+        };
+    }
+    const existing = await readJsonObject(target.file);
+    const next = mergeClientConfig(existing, exported.config, client);
+    await mkdir(path.dirname(target.file), { recursive: true });
+    await writeFile(target.file, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+    return {
+        client,
+        scope,
+        file: target.file,
+        serverName: server.name,
+        action: Object.keys(existing).length === 0 ? "created" : "updated",
+        notes: [...target.notes, ...exported.notes],
+    };
+}
+export async function removeServerConfig(serverName, client, scope) {
+    const target = resolveConfigTarget(client, scope);
+    if (client === "codex") {
+        const existing = await readText(target.file);
+        const next = removeCodexServerToml(existing, serverName);
+        if (next === existing) {
+            return { client, scope, file: target.file, serverName, action: "missing", notes: target.notes };
+        }
+        await mkdir(path.dirname(target.file), { recursive: true });
+        await writeFile(target.file, next, "utf8");
+        return { client, scope, file: target.file, serverName, action: "removed", notes: target.notes };
+    }
+    if (client === "continue") {
+        const existing = await readText(target.file);
+        const next = removeContinueServerYaml(existing, serverName);
+        if (next === existing) {
+            return { client, scope, file: target.file, serverName, action: "missing", notes: target.notes };
+        }
+        await mkdir(path.dirname(target.file), { recursive: true });
+        await writeFile(target.file, next, "utf8");
+        return { client, scope, file: target.file, serverName, action: "removed", notes: target.notes };
+    }
+    const existing = await readJsonObject(target.file);
+    const { config: next, removed } = removeClientConfig(existing, serverName, client);
+    if (!removed) {
+        return { client, scope, file: target.file, serverName, action: "missing", notes: target.notes };
+    }
+    await mkdir(path.dirname(target.file), { recursive: true });
+    await writeFile(target.file, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+    return { client, scope, file: target.file, serverName, action: "removed", notes: target.notes };
+}
+export function resolveConfigTarget(client, scope) {
+    const cwd = process.cwd();
+    const home = os.homedir();
+    if (scope === "project") {
+        switch (client) {
+            case "vscode":
+                return { file: path.join(cwd, ".vscode", "mcp.json"), notes: ["Project VS Code MCP config written."] };
+            case "codex":
+                return { file: path.join(cwd, ".codex", "config.toml"), notes: ["Project Codex config.toml written. Project must be trusted by Codex before this layer loads."] };
+            case "opencode":
+                return { file: path.join(cwd, "opencode.json"), notes: ["Project opencode config written. Restart opencode to load it."] };
+            case "cursor":
+                return { file: path.join(cwd, ".cursor", "mcp.json"), notes: ["Project Cursor MCP config written. Restart Cursor or reload MCP servers to load it."] };
+            case "gemini":
+                return { file: path.join(cwd, ".gemini", "settings.json"), notes: ["Project Gemini CLI settings.json written."] };
+            case "roo":
+                return { file: path.join(cwd, ".roo", "mcp.json"), notes: ["Project Roo Code MCP config written."] };
+            case "windsurf":
+                throw new Error("Project Windsurf/Cascade MCP config path is not documented; use --scope global.");
+            case "cline":
+                throw new Error("Project Cline MCP config path is not documented; use --scope global.");
+            case "continue":
+                throw new Error("Project Continue config path is not documented; use --scope global.");
+            case "zed":
+                throw new Error("Zed settings path is not verified yet; export the config snippet and add it through Zed settings.");
+            case "generic":
+            default:
+                return { file: path.join(cwd, ".mcp.json"), notes: ["Project MCP config written. Import it into clients that support project MCP config."] };
+        }
+    }
+    switch (client) {
+        case "opencode":
+            return { file: path.join(home, ".config", "opencode", "opencode.json"), notes: ["Global opencode config written. Restart opencode to load it."] };
+        case "cursor":
+            return { file: path.join(home, ".cursor", "mcp.json"), notes: ["Global Cursor MCP config written. Restart Cursor or reload MCP servers to load it."] };
+        case "vscode":
+            return { file: vsCodeGlobalConfigFile(home), notes: ["Global VS Code user MCP config path written."] };
+        case "codex":
+            return { file: path.join(home, ".codex", "config.toml"), notes: ["Global Codex config.toml written."] };
+        case "windsurf":
+            return { file: path.join(home, ".codeium", "windsurf", "mcp_config.json"), notes: ["Global Windsurf/Cascade MCP config written. Restart Windsurf to load it."] };
+        case "cline":
+            return { file: path.join(home, ".cline", "mcp.json"), notes: ["Global Cline CLI MCP config written. Reload Cline to load it."] };
+        case "continue":
+            return { file: path.join(home, ".continue", "config.yaml"), notes: ["Global Continue config.yaml written. Continue reloads config on save."] };
+        case "gemini":
+            return { file: path.join(home, ".gemini", "settings.json"), notes: ["Global Gemini CLI settings.json written."] };
+        case "zed":
+            throw new Error("Zed settings path is not verified yet; export the config snippet and add it through Zed settings.");
+        case "roo":
+            throw new Error("Global Roo Code mcp_settings.json path is not verified yet; use --scope project.");
+        case "claude":
+            throw new Error("Claude global MCP config is managed by the Claude CLI and is not written directly by ToolPin; use `toolpin export-config ... --client claude` with `claude mcp add-json --scope user`, or use --scope project.");
+        case "generic":
+        default:
+            return { file: path.join(home, ".config", "toolpin", `${client}-mcp.json`), notes: ["Generic global MCP config written; client-specific import may still be required."] };
+    }
+}
+function removeClientConfig(existing, serverName, client) {
+    const next = { ...existing };
+    const key = clientConfigRootKey(client);
+    const servers = { ...asObject(next[key]) };
+    if (!(serverName in servers))
+        return { config: existing, removed: false };
+    delete servers[serverName];
+    next[key] = servers;
+    return { config: next, removed: true };
+}
+function mergeClientConfig(existing, incoming, client) {
+    const incomingObject = asObject(incoming);
+    const key = clientConfigRootKey(client);
+    const next = { ...existing };
+    if (client === "opencode" && typeof next.$schema !== "string" && typeof incomingObject.$schema === "string") {
+        next.$schema = incomingObject.$schema;
+    }
+    next[key] = {
+        ...asObject(existing[key]),
+        ...asObject(incomingObject[key]),
+    };
+    return next;
+}
+export function vsCodeGlobalConfigFile(home = os.homedir(), platform = process.platform, appData = process.env.APPDATA) {
+    if (platform === "darwin") {
+        return path.join(home, "Library", "Application Support", "Code", "User", "mcp.json");
+    }
+    if (platform === "win32") {
+        return path.join(appData || path.join(home, "AppData", "Roaming"), "Code", "User", "mcp.json");
+    }
+    return path.join(home, ".config", "Code", "User", "mcp.json");
+}
+async function readJsonObject(file) {
+    try {
+        const raw = await readFile(file, "utf8");
+        return asObject(JSON.parse(raw));
+    }
+    catch {
+        return {};
+    }
+}
+async function readText(file) {
+    try {
+        return await readFile(file, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function asObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}