openalmanac 0.3.1 → 0.3.3

package/dist/setup.js

@@ -2,6 +2,7 @@ import { readFileSync, writeFileSync, mkdirSync, existsSync, cpSync } from "fs";
 import { homedir } from "os";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
+import { spawnSync } from "child_process";
 import { performLogin } from "./login-core.js";
 import { getAuthStatus } from "./auth.js";
 const TOOL_GROUPS = [
@@ -131,9 +132,15 @@ const vis = (s) => s.replace(/\x1b\[[0-9;]*m/g, "").length;
 const w = (s) => process.stdout.write(s + "\n");
 /* ── File helpers ───────────────────────────────────────────────── */
 const CLAUDE_DIR = join(homedir(), ".claude");
-const CLAUDE_JSON = join(homedir(), ".claude.json"); // Claude Desktop
-const CLAUDE_CODE_MCP = join(CLAUDE_DIR, "mcp.json"); // Claude Code
+const CLAUDE_JSON = join(homedir(), ".claude.json"); // Claude Code user-scoped MCP config
+const CLAUDE_CODE_MCP = join(CLAUDE_DIR, "mcp.json"); // Claude Code local MCP config
 const SETTINGS_JSON = join(CLAUDE_DIR, "settings.json");
+const CODEX_CONFIG = join(homedir(), ".codex", "config.toml");
+const CURSOR_MCP_JSON = join(homedir(), ".cursor", "mcp.json");
+const OPENCODE_DIR = join(homedir(), ".config", "opencode");
+const OPENCODE_JSON = join(OPENCODE_DIR, "opencode.json");
+const OPENCODE_JSONC = join(OPENCODE_DIR, "opencode.jsonc");
+const WINDSURF_MCP_JSON = join(homedir(), ".codeium", "mcp_config.json");
 function ensureDir(dir) {
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
@@ -151,34 +158,518 @@ function writeJson(path, data) {
 }
 /* ── Step 1 — MCP server ───────────────────────────────────────── */
 const ALMANAC_MCP_ENTRY = { command: "npx", args: ["-y", "openalmanac@latest"] };
+const SUPPORTED_CLIENT_IDS = [
+    "claude-code",
+    "claude-desktop",
+    "codex",
+    "cursor",
+    "opencode",
+    "windsurf",
+];
+const SUPPORTED_CLIENTS = {
+    "claude-code": {
+        id: "claude-code",
+        name: "Claude Code",
+        selectionLabel: "Claude Code",
+        detect: () => hasCommand("claude") || existsSync(CLAUDE_JSON) || existsSync(CLAUDE_DIR),
+        configure: (mode) => {
+            const snippets = [
+                {
+                    path: CLAUDE_JSON,
+                    content: jsonSnippet({
+                        mcpServers: {
+                            almanac: { ...ALMANAC_MCP_ENTRY },
+                        },
+                    }),
+                },
+                {
+                    path: CLAUDE_CODE_MCP,
+                    content: jsonSnippet({
+                        mcpServers: {
+                            almanac: { ...ALMANAC_MCP_ENTRY },
+                        },
+                    }),
+                },
+            ];
+            const changedPrimary = configureJsonMcpFile(CLAUDE_JSON, mode);
+            const changedSecondary = configureJsonMcpFile(CLAUDE_CODE_MCP, mode);
+            return { changed: changedPrimary || changedSecondary, snippets };
+        },
+        supportsPermissions: true,
+    },
+    "claude-desktop": {
+        id: "claude-desktop",
+        name: "Claude Desktop",
+        selectionLabel: "Claude Desktop",
+        detect: () => {
+            const path = getClaudeDesktopConfigPath();
+            return Boolean(path && (existsSync(path) || isClaudeDesktopInstalled()));
+        },
+        configure: (mode) => {
+            const path = getClaudeDesktopConfigPath();
+            if (!path)
+                return { changed: false, snippets: [] };
+            return {
+                changed: configureJsonMcpFile(path, mode),
+                snippets: [
+                    {
+                        path,
+                        content: jsonSnippet({
+                            mcpServers: {
+                                almanac: { ...ALMANAC_MCP_ENTRY },
+                            },
+                        }),
+                    },
+                ],
+            };
+        },
+    },
+    codex: {
+        id: "codex",
+        name: "Codex",
+        selectionLabel: "Codex",
+        detect: () => hasCommand("codex") || existsSync(CODEX_CONFIG) || existsSync(join(homedir(), ".codex")),
+        configure: (mode) => ({
+            changed: configureCodexToml(CODEX_CONFIG, mode),
+            snippets: [
+                {
+                    path: CODEX_CONFIG,
+                    content: codexSnippet(),
+                },
+            ],
+        }),
+    },
+    cursor: {
+        id: "cursor",
+        name: "Cursor",
+        selectionLabel: "Cursor",
+        detect: () => hasCommand("cursor-agent") ||
+            existsSync(CURSOR_MCP_JSON) ||
+            existsSync(join(homedir(), ".cursor")),
+        configure: (mode) => ({
+            changed: configureJsonMcpFile(CURSOR_MCP_JSON, mode),
+            snippets: [
+                {
+                    path: CURSOR_MCP_JSON,
+                    content: jsonSnippet({
+                        mcpServers: {
+                            almanac: { ...ALMANAC_MCP_ENTRY },
+                        },
+                    }),
+                },
+            ],
+        }),
+    },
+    opencode: {
+        id: "opencode",
+        name: "OpenCode",
+        selectionLabel: "OpenCode",
+        detect: () => hasCommand("opencode") ||
+            existsSync(OPENCODE_JSON) ||
+            existsSync(OPENCODE_JSONC) ||
+            existsSync(OPENCODE_DIR),
+        configure: (mode) => {
+            const path = getOpenCodeConfigPath();
+            return {
+                changed: configureOpenCodeFile(path, mode),
+                snippets: [
+                    {
+                        path,
+                        content: jsonSnippet({
+                            "$schema": "https://opencode.ai/config.json",
+                            mcp: {
+                                almanac: {
+                                    type: "local",
+                                    command: [ALMANAC_MCP_ENTRY.command, ...ALMANAC_MCP_ENTRY.args],
+                                    enabled: true,
+                                },
+                            },
+                        }),
+                    },
+                ],
+            };
+        },
+    },
+    windsurf: {
+        id: "windsurf",
+        name: "Windsurf",
+        selectionLabel: "Windsurf",
+        detect: () => hasCommand("windsurf") ||
+            existsSync(WINDSURF_MCP_JSON) ||
+            existsSync(join(homedir(), ".codeium")),
+        configure: (mode) => ({
+            changed: configureJsonMcpFile(WINDSURF_MCP_JSON, mode),
+            snippets: [
+                {
+                    path: WINDSURF_MCP_JSON,
+                    content: jsonSnippet({
+                        mcpServers: {
+                            almanac: { ...ALMANAC_MCP_ENTRY },
+                        },
+                    }),
+                },
+            ],
+        }),
+    },
+};
+function parseSetupArgs(argv) {
+    const options = {
+        all: false,
+        clients: [],
+        dryRun: false,
+        print: false,
+        yes: false,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--all") {
+            options.all = true;
+            continue;
+        }
+        if (arg === "--print") {
+            options.print = true;
+            continue;
+        }
+        if (arg === "--dry-run") {
+            options.dryRun = true;
+            continue;
+        }
+        if (arg === "--yes" || arg === "-y") {
+            options.yes = true;
+            continue;
+        }
+        if (arg === "--client") {
+            const value = argv[i + 1];
+            if (!value) {
+                throw new Error("Missing value for --client");
+            }
+            i++;
+            options.clients.push(...parseClientList(value));
+            continue;
+        }
+        if (arg.startsWith("--client=")) {
+            options.clients.push(...parseClientList(arg.slice("--client=".length)));
+            continue;
+        }
+        throw new Error(`Unknown setup flag: ${arg}`);
+    }
+    if (options.all && options.clients.length > 0) {
+        throw new Error("Use either --all or --client, not both");
+    }
+    options.clients = Array.from(new Set(options.clients));
+    return options;
+}
+function parseClientList(value) {
+    return value
+        .split(",")
+        .map((part) => part.trim().toLowerCase())
+        .filter(Boolean)
+        .map((part) => normalizeClientId(part));
+}
+function normalizeClientId(value) {
+    const aliases = {
+        claude: "claude-code",
+        "claude-code": "claude-code",
+        "claude-desktop": "claude-desktop",
+        desktop: "claude-desktop",
+        codex: "codex",
+        cursor: "cursor",
+        opencode: "opencode",
+        windsurf: "windsurf",
+    };
+    const normalized = aliases[value];
+    if (!normalized) {
+        throw new Error(`Unsupported client "${value}". Supported clients: ${SUPPORTED_CLIENT_IDS.join(", ")}`);
+    }
+    return normalized;
+}
+function hasCommand(command) {
+    const checker = process.platform === "win32" ? "where" : "which";
+    const result = spawnSync(checker, [command], { stdio: "ignore" });
+    return result.status === 0;
+}
+function getClaudeDesktopConfigPath() {
+    if (process.platform === "darwin") {
+        return join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    }
+    if (process.platform === "linux") {
+        return join(homedir(), ".config", "Claude", "claude_desktop_config.json");
+    }
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA;
+        if (!appData)
+            return null;
+        return join(appData, "Claude", "claude_desktop_config.json");
+    }
+    return null;
+}
+function isClaudeDesktopInstalled() {
+    if (process.platform === "darwin") {
+        return (existsSync("/Applications/Claude.app") ||
+            existsSync(join(homedir(), "Applications", "Claude.app")));
+    }
+    if (process.platform === "linux") {
+        return (existsSync("/usr/share/applications/claude.desktop") ||
+            existsSync(join(homedir(), ".local", "share", "applications", "claude.desktop")) ||
+            existsSync("/opt/Claude/claude"));
+    }
+    if (process.platform === "win32") {
+        const localAppData = process.env.LOCALAPPDATA;
+        const programFiles = process.env.ProgramFiles;
+        return Boolean((localAppData &&
+            existsSync(join(localAppData, "Programs", "Claude", "Claude.exe"))) ||
+            (programFiles && existsSync(join(programFiles, "Claude", "Claude.exe"))));
+    }
+    return false;
+}
+function jsonSnippet(data) {
+    return JSON.stringify(data, null, 2);
+}
+function getOpenCodeConfigPath() {
+    if (existsSync(OPENCODE_JSON))
+        return OPENCODE_JSON;
+    if (existsSync(OPENCODE_JSONC))
+        return OPENCODE_JSONC;
+    return OPENCODE_JSON;
+}
+function codexSnippet() {
+    return [
+        "[mcp_servers.almanac]",
+        `command = ${tomlString(ALMANAC_MCP_ENTRY.command)}`,
+        `args = ${tomlArray(ALMANAC_MCP_ENTRY.args)}`,
+    ].join("\n");
+}
 function isAlmanacCurrent(server) {
     return (server?.command === "npx" &&
         JSON.stringify(server.args) === JSON.stringify(ALMANAC_MCP_ENTRY.args));
 }
-function configureMcp() {
-    let changed = false;
-    // Claude Desktop — ~/.claude.json
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const desktop = readJson(CLAUDE_JSON);
-    if (!desktop.mcpServers)
-        desktop.mcpServers = {};
-    if (!isAlmanacCurrent(desktop.mcpServers.almanac)) {
-        desktop.mcpServers.almanac = { ...ALMANAC_MCP_ENTRY };
-        writeJson(CLAUDE_JSON, desktop);
-        changed = true;
-    }
-    // Claude Code — ~/.claude/mcp.json
-    ensureDir(CLAUDE_DIR);
+function isOpenCodeAlmanacCurrent(entry) {
+    return (entry?.type === "local" &&
+        entry?.enabled === true &&
+        JSON.stringify(entry.command) ===
+            JSON.stringify([ALMANAC_MCP_ENTRY.command, ...ALMANAC_MCP_ENTRY.args]));
+}
+function configureJsonMcpFile(path, mode) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const code = readJson(CLAUDE_CODE_MCP);
-    if (!code.mcpServers)
-        code.mcpServers = {};
-    if (!isAlmanacCurrent(code.mcpServers.almanac)) {
-        code.mcpServers.almanac = { ...ALMANAC_MCP_ENTRY };
-        writeJson(CLAUDE_CODE_MCP, code);
-        changed = true;
+    const json = readJson(path);
+    if (!json.mcpServers)
+        json.mcpServers = {};
+    if (isAlmanacCurrent(json.mcpServers.almanac)) {
+        return false;
+    }
+    if (mode === "apply") {
+        ensureDir(dirname(path));
+        json.mcpServers.almanac = { ...ALMANAC_MCP_ENTRY };
+        writeJson(path, json);
+    }
+    return true;
+}
+function configureCodexToml(path, mode) {
+    const current = readToml(path);
+    const next = upsertCodexServer(current);
+    if (current.trim() === next.trim()) {
+        return false;
+    }
+    if (mode === "apply") {
+        ensureDir(dirname(path));
+        writeFileSync(path, next.endsWith("\n") ? next : next + "\n");
+    }
+    return true;
+}
+function configureOpenCodeFile(path, mode) {
+    const current = readJsonWithComments(path);
+    if (!current.$schema) {
+        current.$schema = "https://opencode.ai/config.json";
+    }
+    const mcp = isRecord(current.mcp) ? current.mcp : {};
+    if (!isRecord(current.mcp)) {
+        current.mcp = mcp;
+    }
+    if (isOpenCodeAlmanacCurrent(mcp.almanac)) {
+        return false;
+    }
+    mcp.almanac = {
+        type: "local",
+        command: [ALMANAC_MCP_ENTRY.command, ...ALMANAC_MCP_ENTRY.args],
+        enabled: true,
+    };
+    if (mode === "apply") {
+        ensureDir(dirname(path));
+        writeJson(path, current);
+    }
+    return true;
+}
+function readToml(path) {
+    try {
+        return readFileSync(path, "utf-8");
+    }
+    catch {
+        return "";
     }
-    return changed;
+}
+function readJsonWithComments(path) {
+    try {
+        const raw = readFileSync(path, "utf-8");
+        const parsed = JSON.parse(stripJsonComments(raw));
+        return isRecord(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function stripJsonComments(input) {
+    let result = "";
+    let inString = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    let escaped = false;
+    for (let i = 0; i < input.length; i++) {
+        const char = input[i];
+        const next = input[i + 1];
+        if (inLineComment) {
+            if (char === "\n") {
+                inLineComment = false;
+                result += char;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (char === "*" && next === "/") {
+                inBlockComment = false;
+                i++;
+            }
+            continue;
+        }
+        if (inString) {
+            result += char;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === "\\") {
+                escaped = true;
+            }
+            else if (char === "\"") {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === "/" && next === "/") {
+            inLineComment = true;
+            i++;
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            inBlockComment = true;
+            i++;
+            continue;
+        }
+        if (char === "\"") {
+            inString = true;
+        }
+        result += char;
+    }
+    return result;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function upsertCodexServer(content) {
+    const sectionName = "mcp_servers.almanac";
+    const header = `[${sectionName}]`;
+    const nextBody = [
+        `command = ${tomlString(ALMANAC_MCP_ENTRY.command)}`,
+        `args = ${tomlArray(ALMANAC_MCP_ENTRY.args)}`,
+    ];
+    const lines = content === "" ? [] : content.split(/\r?\n/);
+    const start = lines.findIndex((line) => line.trim() === header);
+    if (start === -1) {
+        const prefix = content.trimEnd();
+        const block = [header, ...nextBody].join("\n");
+        return prefix === "" ? block + "\n" : `${prefix}\n\n${block}\n`;
+    }
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i++) {
+        if (/^\s*\[.+\]\s*$/.test(lines[i])) {
+            end = i;
+            break;
+        }
+    }
+    const existingBody = lines.slice(start + 1, end);
+    const preserved = existingBody.filter((line) => {
+        const trimmed = line.trim();
+        return !trimmed.startsWith("command =") && !trimmed.startsWith("args =");
+    });
+    const replacement = [header, ...nextBody, ...preserved];
+    const updated = [...lines.slice(0, start), ...replacement, ...lines.slice(end)];
+    return updated.join("\n").replace(/\n{3,}/g, "\n\n").replace(/\s+$/, "") + "\n";
+}
+function tomlString(value) {
+    return JSON.stringify(value);
+}
+function tomlArray(values) {
+    return `[${values.map((value) => tomlString(value)).join(", ")}]`;
+}
+function detectClients() {
+    return SUPPORTED_CLIENT_IDS.map((id) => SUPPORTED_CLIENTS[id]).filter((client) => client.detect());
+}
+function resolveClients(options) {
+    if (options.clients.length > 0) {
+        return options.clients.map((id) => SUPPORTED_CLIENTS[id]);
+    }
+    const detected = detectClients();
+    if (options.all)
+        return detected;
+    return detected;
+}
+function applyClientSetup(clients, mode) {
+    const configured = [];
+    const alreadyConfigured = [];
+    for (const client of clients) {
+        const result = client.configure(mode);
+        if (result.changed) {
+            configured.push(client.name);
+        }
+        else {
+            alreadyConfigured.push(client.name);
+        }
+    }
+    return { configured, alreadyConfigured };
+}
+function printSetupPlan(clients, options) {
+    const heading = options.dryRun ? "Dry run" : "OpenAlmanac MCP setup";
+    process.stdout.write(`${heading}\n\n`);
+    if (clients.length === 0) {
+        process.stdout.write("No supported clients detected. Use --client <name> to force a target or --print to inspect supported snippets.\n");
+        if (options.print) {
+            process.stdout.write("\nSupported clients:\n");
+            for (const id of SUPPORTED_CLIENT_IDS) {
+                process.stdout.write(`- ${SUPPORTED_CLIENTS[id].name}\n`);
+            }
+        }
+        return;
+    }
+    const mode = options.print ? "print" : "dry-run";
+    for (const client of clients) {
+        const result = client.configure(mode);
+        const status = result.changed
+            ? options.print
+                ? "snippet"
+                : "would configure"
+            : "already configured";
+        process.stdout.write(`- ${client.name}: ${status}\n`);
+        if (options.print) {
+            for (const snippet of result.snippets) {
+                process.stdout.write(`  Path: ${snippet.path}\n`);
+                process.stdout.write(`${indentBlock(snippet.content, "    ")}\n`);
+            }
+        }
+    }
+}
+function indentBlock(content, prefix) {
+    return content
+        .split("\n")
+        .map((line) => `${prefix}${line}`)
+        .join("\n");
 }
 /* ── Step 2 — Permissions ──────────────────────────────────────── */
 function configurePermissions(tools) {
@@ -201,29 +692,30 @@ function configurePermissions(tools) {
         writeJson(SETTINGS_JSON, settings);
     return tools.length;
 }
-/* ── Agent selection screen ─────────────────────────────────────── */
-function renderAgentSelect(_cursor, mode = "default") {
+/* ── Client selection screen ────────────────────────────────────── */
+function renderClientSelect(clients, selected, cursor, mode = "default") {
     process.stdout.write("\x1b[2J\x1b[H");
     renderHeader(mode);
     printBadge();
     w("");
-    stepActive(`Select your agent`);
+    stepActive(`Select where to install Almanac`);
     w(BAR);
-    for (const agent of AGENTS) {
-        if (agent.supported) {
-            w(`  ${DIM}\u2502${RST}   ${BLUE}\u276f${RST} ${BLUE}\u25cf${RST} ${BOLD}${agent.name}${RST}`);
-        }
-        else {
-            w(`  ${DIM}\u2502${RST}     ${DIM}\u25cb ${agent.name}${"  "}coming soon${RST}`);
-        }
+    for (let i = 0; i < clients.length; i++) {
+        const client = clients[i];
+        const arrow = i === cursor ? `${BLUE}\u276f${RST}` : " ";
+        const check = selected[i] ? `${BLUE}\u2713${RST}` : " ";
+        const label = i === cursor ? `${BOLD}${client.selectionLabel ?? client.name}${RST}` : client.selectionLabel ?? client.name;
+        w(`  ${DIM}\u2502${RST}   ${arrow} [${check}] ${label}`);
     }
     w(BAR);
-    w(`  ${DIM}\u2502${RST}   ${BLUE}${BOLD}[enter]${RST} confirm  ${DIM}[q] quit${RST}`);
+    w(`  ${DIM}\u2502${RST}   ${BLUE}${BOLD}[space]${RST} toggle  ${BLUE}${BOLD}[\u2191\u2193]${RST} move  ${BLUE}${BOLD}[a]${RST} all  ${BLUE}${BOLD}[enter]${RST} confirm  ${DIM}[q] quit${RST}`);
     w("");
 }
-function runAgentSelect(mode = "default") {
+function runClientSelect(clients, mode = "default") {
     return new Promise((resolve) => {
-        renderAgentSelect(0, mode);
+        const selected = clients.map(() => true);
+        let cursor = 0;
+        renderClientSelect(clients, selected, cursor, mode);
         process.stdin.setRawMode(true);
         process.stdin.resume();
         process.stdin.setEncoding("utf-8");
@@ -239,16 +731,38 @@ function runAgentSelect(mode = "default") {
                 console.log("\n  Setup cancelled.\n");
                 process.exit(0);
             }
-            if (key === "\r" || key === "\n") {
+            if (key === "\x1b[A" || key === "k") {
+                cursor = (cursor - 1 + clients.length) % clients.length;
+            }
+            else if (key === "\x1b[B" || key === "j") {
+                cursor = (cursor + 1) % clients.length;
+            }
+            else if (key === " ") {
+                selected[cursor] = !selected[cursor];
+            }
+            else if (key === "a") {
+                const all = selected.every(Boolean);
+                selected.fill(!all);
+            }
+            else if (key === "\r" || key === "\n") {
                 cleanup();
-                const supported = AGENTS.find((a) => a.supported);
-                resolve(supported.name);
+                const chosen = clients.filter((_, index) => selected[index]);
+                if (chosen.length === 0) {
+                    console.log("\n  Select at least one client.\n");
+                    process.exit(1);
+                }
+                resolve(chosen);
                 return;
             }
+            renderClientSelect(clients, selected, cursor, mode);
         };
         process.stdin.on("data", onData);
     });
 }
+async function runAgentSelect(mode = "default") {
+    const [client] = await runClientSelect([SUPPORTED_CLIENTS["claude-code"]], mode);
+    return client.name;
+}
 /* ── Login step ─────────────────────────────────────────────────── */
 function loginLabel(result) {
     if (result.status === "already")
@@ -278,12 +792,15 @@ function waitForKey(prompt) {
     });
 }
 async function runLoginStep(agent, mcpChanged, toolCount, mode = "default") {
+    const label = agent.includes(",") ? "Clients" : "Agent";
     const priorSteps = () => {
-        stepDone(`Agent \u2192 ${WHITE_BOLD}${agent}${RST}`);
+        stepDone(`${label} \u2192 ${WHITE_BOLD}${agent}${RST}`);
         w(BAR);
         stepDone(`MCP server ${mcpChanged ? "configured" : `${DIM}already configured${RST}`}`);
-        w(BAR);
-        stepDone(`${BLUE}${toolCount}${RST} tool${toolCount !== 1 ? "s" : ""} allowed`);
+        if (toolCount !== null) {
+            w(BAR);
+            stepDone(`${BLUE}${toolCount}${RST} tool${toolCount !== 1 ? "s" : ""} allowed`);
+        }
         w(BAR);
     };
     function renderLoginChoice(name, cursor) {
@@ -428,16 +945,16 @@ async function runLoginStep(agent, mcpChanged, toolCount, mode = "default") {
 }
 /* ── Tool permissions TUI ───────────────────────────────────────── */
 const MAX_NAME = Math.max(...TOOL_GROUPS.map((g) => g.name.length));
-function renderToolSelect(selected, cursor, agent, mcpChanged, mode = "default") {
+function renderToolSelect(selected, cursor, clientsLabel, mcpChanged, mode = "default") {
     process.stdout.write("\x1b[2J\x1b[H");
     renderHeader(mode);
     printBadge();
     w("");
-    stepDone(`Agent \u2192 ${WHITE_BOLD}${agent}${RST}`);
+    stepDone(`Clients \u2192 ${WHITE_BOLD}${clientsLabel}${RST}`);
     w(BAR);
     stepDone(`MCP server ${mcpChanged ? "configured" : `${DIM}already configured${RST}`}`);
     w(BAR);
-    stepActive(`Select tool permissions  ${DIM}deselect any you'd rather approve manually${RST}`);
+    stepActive(`Select Claude Code tool permissions  ${DIM}deselect any you'd rather approve manually${RST}`);
     w(BAR);
     for (let i = 0; i < TOOL_GROUPS.length; i++) {
         const arrow = i === cursor ? `${BLUE}\u276f${RST}` : " ";
@@ -451,11 +968,11 @@ function renderToolSelect(selected, cursor, agent, mcpChanged, mode = "default")
     w(`  ${DIM}\u2502${RST}   ${BLUE}${BOLD}[space]${RST} toggle  ${BLUE}${BOLD}[\u2191\u2193]${RST} move  ${BLUE}${BOLD}[a]${RST} all  ${BLUE}${BOLD}[enter]${RST} confirm  ${DIM}[q] quit${RST}`);
     w("");
 }
-function runToolSelect(agent, mcpChanged, mode = "default") {
+function runToolSelect(clientsLabel, mcpChanged, mode = "default") {
     return new Promise((resolve) => {
         const selected = TOOL_GROUPS.map(() => true);
         let cursor = 0;
-        renderToolSelect(selected, cursor, agent, mcpChanged, mode);
+        renderToolSelect(selected, cursor, clientsLabel, mcpChanged, mode);
         process.stdin.setRawMode(true);
         process.stdin.resume();
         process.stdin.setEncoding("utf-8");
@@ -491,23 +1008,27 @@ function runToolSelect(agent, mcpChanged, mode = "default") {
                 resolve(tools);
                 return;
             }
-            renderToolSelect(selected, cursor, agent, mcpChanged, mode);
+            renderToolSelect(selected, cursor, clientsLabel, mcpChanged, mode);
         };
         process.stdin.on("data", onData);
     });
 }
 /* ── Result screen ──────────────────────────────────────────────── */
-function printResult(agent, loginResult, mcpChanged, toolCount) {
+function printResult(clientsLabel, loginResult, configured, alreadyConfigured, toolCount) {
     process.stdout.write("\x1b[2J\x1b[H");
     printBanner();
     printBadge();
     w("");
-    stepDone(`Agent \u2192 ${WHITE_BOLD}${agent}${RST}`);
+    stepDone(`Clients \u2192 ${WHITE_BOLD}${clientsLabel}${RST}`);
     w(BAR);
-    stepDone(`MCP server ${mcpChanged ? "configured" : `${DIM}already configured${RST}`}`);
+    stepDone(`Configured \u2192 ${configured.length > 0 ? configured.join(", ") : `${DIM}none${RST}`}`);
     w(BAR);
-    stepDone(`${BLUE}${toolCount}${RST} tool${toolCount !== 1 ? "s" : ""} allowed in ${DIM}~/.claude/settings.json${RST}`);
+    stepDone(`Already configured \u2192 ${alreadyConfigured.length > 0 ? alreadyConfigured.join(", ") : `${DIM}none${RST}`}`);
     w(BAR);
+    if (toolCount > 0) {
+        stepDone(`${BLUE}${toolCount}${RST} tool${toolCount !== 1 ? "s" : ""} allowed in ${DIM}~/.claude/settings.json${RST}`);
+        w(BAR);
+    }
     stepDone(loginLabel(loginResult));
     w(BAR);
     stepDone(`${BLUE}Setup complete${RST}`);
@@ -519,37 +1040,95 @@ function printResult(agent, loginResult, mcpChanged, toolCount) {
         return `  ${BLUE_DIM}\u2502${RST}${content}${" ".repeat(padding)}${BLUE_DIM}\u2502${RST}`;
     };
     const empty = row("");
+    const nextSteps = getNextSteps(clientsLabel);
     w(`  ${BLUE_DIM}\u256d${"─".repeat(innerW)}\u256e${RST}`);
     w(empty);
     w(row(`  ${WHITE_BOLD}Next steps${RST}`));
     w(empty);
-    w(row(`  ${BLUE}1.${RST}  Type ${WHITE_BOLD}claude${RST} to start Claude Code`));
-    w(row(`  ${BLUE}2.${RST}  Say ${BLUE}"I want to contribute/explore the founders-inc wiki"${RST}`));
+    for (let i = 0; i < nextSteps.length; i++) {
+        w(row(`  ${BLUE}${i + 1}.${RST}  ${nextSteps[i]}`));
+    }
     w(empty);
     w(`  ${BLUE_DIM}\u2570${"─".repeat(innerW)}\u256f${RST}`);
     w("");
 }
+function getNextSteps(clientsLabel) {
+    if (clientsLabel === "Claude Code") {
+        return [
+            `Type ${WHITE_BOLD}claude${RST} to start Claude Code`,
+            `Say ${BLUE}"Let's explore <topic> using Almanac"${RST}`,
+        ];
+    }
+    if (clientsLabel === "Codex") {
+        return [
+            `Type ${WHITE_BOLD}codex${RST} to start Codex`,
+            `Ask ${BLUE}"Let's explore <topic> using Almanac"${RST}`,
+        ];
+    }
+    if (clientsLabel === "Cursor") {
+        return [
+            `Open ${WHITE_BOLD}Cursor${RST} in your project`,
+            `Ask ${BLUE}"Let's explore <topic> using Almanac"${RST}`,
+        ];
+    }
+    if (clientsLabel === "OpenCode") {
+        return [
+            `Type ${WHITE_BOLD}opencode${RST} to start OpenCode`,
+            `Ask ${BLUE}"Let's explore <topic> using Almanac"${RST}`,
+        ];
+    }
+    if (clientsLabel === "Windsurf") {
+        return [
+            `Open ${WHITE_BOLD}Windsurf${RST} in your project`,
+            `Ask ${BLUE}"Let's explore <topic> using Almanac"${RST}`,
+        ];
+    }
+    if (clientsLabel === "Claude Desktop") {
+        return [
+            `Open ${WHITE_BOLD}Claude Desktop${RST}`,
+            `Ask ${BLUE}"Let's explore <topic> using Almanac"${RST}`,
+        ];
+    }
+    return [
+        `Open one of your configured agents in this project`,
+        `Ask ${BLUE}"Let's explore <topic> using Almanac"${RST}`,
+    ];
+}
 /* ── Entry point ────────────────────────────────────────────────── */
 export async function runSetup() {
-    const skipTui = process.argv.includes("--yes") || process.argv.includes("-y");
-    const interactive = process.stdin.isTTY && !skipTui;
-    let agent = "Claude Code";
-    if (interactive) {
-        agent = await runAgentSelect();
+    const options = parseSetupArgs(process.argv.slice(3));
+    let clients = resolveClients(options);
+    if (options.print || options.dryRun) {
+        printSetupPlan(clients, options);
+        process.exit(0);
     }
-    const mcpChanged = configureMcp();
-    let tools;
-    if (interactive) {
-        tools = await runToolSelect(agent, mcpChanged);
+    if (clients.length === 0) {
+        printSetupPlan(clients, options);
+        process.exit(0);
     }
-    else {
-        tools = TOOL_GROUPS.flatMap((g) => g.tools);
+    const skipTui = options.yes;
+    const interactive = process.stdin.isTTY && !skipTui;
+    if (interactive && options.clients.length === 0) {
+        clients = await runClientSelect(clients);
     }
-    const count = configurePermissions(tools);
-    // Login step (last — so when they return from browser, everything is done)
+    const clientsLabel = clients.map((client) => client.name).join(", ");
+    const setupSummary = applyClientSetup(clients, "apply");
+    const permissionClient = clients.find((client) => client.supportsPermissions);
+    let tools = [];
+    if (permissionClient) {
+        const mcpChanged = setupSummary.configured.includes(permissionClient.name);
+        if (interactive) {
+            tools = await runToolSelect(clientsLabel, mcpChanged);
+        }
+        else {
+            tools = TOOL_GROUPS.flatMap((g) => g.tools);
+        }
+    }
+    const count = tools.length > 0 ? configurePermissions(tools) : 0;
+    const permissionCount = permissionClient ? count : null;
     let loginResult;
     if (interactive) {
-        loginResult = await runLoginStep(agent, mcpChanged, count);
+        loginResult = await runLoginStep(clientsLabel, setupSummary.configured.length > 0, permissionCount);
     }
     else {
         try {
@@ -563,7 +1142,7 @@ export async function runSetup() {
             loginResult = { status: "skipped" };
         }
     }
-    printResult(agent, loginResult, mcpChanged, count);
+    printResult(clientsLabel, loginResult, setupSummary.configured, setupSummary.alreadyConfigured, count);
     process.exit(0);
 }
 /* ── Skill installation ────────────────────────────────────────── */
@@ -629,7 +1208,8 @@ export async function runRedditSetup() {
     if (interactive) {
         agent = await runAgentSelect("reddit");
     }
-    const mcpChanged = configureMcp();
+    const claudeSetup = SUPPORTED_CLIENTS["claude-code"].configure("apply");
+    const mcpChanged = claudeSetup.changed;
     let tools;
     if (interactive) {
         tools = await runToolSelect(agent, mcpChanged, "reddit");