@whylineee/zerocode 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,35 +1,54 @@
 #!/usr/bin/env node
-import { writeFileSync, existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-import { detectAgents, allAgentTargets, addMcpToAgent, removeMcpFromAgent, listInstalledMcp, } from "./agents.js";
+import { writeFileSync, readFileSync, existsSync, mkdirSync, readdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+import { detectAgents, allAgentTargets, addMcpToAgent, removeMcpFromAgent, listInstalledMcp, supportsJsonConfig, } from "./agents.js";
 import { mcpRegistry, skillRegistry, findMcp, findSkill } from "./registry.js";
 import { banner, heading, success, warn, error, info, item, table, divider } from "./ui.js";
-import { choose, confirm, askEnvVars } from "./prompt.js";
+import { choose, chooseMultiple, confirm, ask, askEnvVars } from "./prompt.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PKG_VERSION = (() => {
+    try {
+        const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+        return pkg.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+})();
 // ── Arg parsing ──────────────────────────────────────────────────
 const args = process.argv.slice(2);
 const command = args[0]?.toLowerCase();
 const subCommand = args[1]?.toLowerCase();
 const target = args[2]?.toLowerCase();
-function usage() {
-    banner();
+function printUsage() {
     console.log("  Usage:");
     console.log();
+    console.log("    zerocode init                    Interactive setup wizard");
     console.log("    zerocode detect                  Detect installed agents");
+    console.log("    zerocode configure               Pick an agent and manage it interactively");
     console.log("    zerocode list mcp                List available MCP servers");
     console.log("    zerocode list skills             List available skills");
     console.log("    zerocode add mcp <name>          Install MCP server to an agent");
     console.log("    zerocode add skill <name>        Install a skill to the project");
     console.log("    zerocode remove mcp <name>       Remove MCP server from an agent");
     console.log("    zerocode status                  Show what's installed on each agent");
-    console.log("    zerocode add mcp <name> --agent <id>   Install to a specific agent");
+    console.log("    zerocode doctor                  Check your setup for issues");
+    console.log("    zerocode sync                    Copy MCP servers from one agent to another");
+    console.log("    zerocode export                  Export config to shareable .zerocode.json");
+    console.log("    zerocode import [path]            Import config from .zerocode.json");
+    console.log("    zerocode backup                  Backup all agent configs");
+    console.log("    zerocode restore                 Restore agent configs from backup");
     console.log();
     console.log("  Examples:");
     console.log();
-    console.log("    npx zerocode detect");
-    console.log("    npx zerocode add mcp filesystem-mcp");
-    console.log("    npx zerocode add mcp github-mcp --agent claude-desktop");
-    console.log("    npx zerocode add skill pr-reviewer");
-    console.log("    npx zerocode status");
+    console.log("    npx @whylineee/zerocode detect");
+    console.log("    npx @whylineee/zerocode add mcp filesystem-mcp");
+    console.log("    npx @whylineee/zerocode add mcp github-mcp --agent claude-desktop");
+    console.log("    npx @whylineee/zerocode add skill pr-reviewer");
+    console.log("    npx @whylineee/zerocode status");
     console.log();
 }
 // ── Helpers ──────────────────────────────────────────────────────
@@ -168,8 +187,13 @@ async function cmdAddMcp() {
         warn("Cancelled.");
         return;
     }
-    addMcpToAgent(agent, serverName, entry);
+    const written = addMcpToAgent(agent, serverName, entry);
     console.log();
+    if (!written) {
+        warn(`${agent.name} does not use JSON config — MCP must be configured manually.`);
+        info(`Add the server entry to: ${agent.configPath}`);
+        return;
+    }
     success(`${mcp.name} installed to ${agent.name}`);
     info(`Config written to: ${agent.configPath}`);
     if (mcp.envVars && mcp.envVars.length > 0) {
@@ -232,6 +256,13 @@ async function cmdRemoveMcp() {
     if (agentFlag) {
         const all = allAgentTargets();
         agent = all.find((a) => a.id === agentFlag);
+        if (!agent) {
+            error(`Agent "${agentFlag}" not found. Available agents:`);
+            for (const a of detectAgents()) {
+                item(a.id, a.name);
+            }
+            return;
+        }
     }
     else {
         const detected = detectAgents();
@@ -273,10 +304,744 @@ async function cmdStatus() {
         divider();
     }
 }
+// ── Init ─────────────────────────────────────────────────────────
+async function cmdInit() {
+    heading("Interactive Setup Wizard");
+    info("Let's set up your AI agent environment.\n");
+    // Step 1 — Detect agents
+    const detected = detectAgents();
+    if (detected.length === 0) {
+        warn("No agents detected on this machine.");
+        info("Install an agent first (Claude Desktop, Cursor, Windsurf, etc.) and re-run.");
+        return;
+    }
+    success(`Found ${detected.length} agent(s) on your machine:`);
+    console.log();
+    for (const a of detected) {
+        item(a.name, a.scope);
+    }
+    // Step 2 — Pick agents to configure
+    const selectedAgents = await chooseMultiple("Which agents do you want to configure?", detected);
+    if (selectedAgents.length === 0) {
+        warn("No agents selected. Aborting.");
+        return;
+    }
+    // Step 3 — Pick MCP servers to install
+    console.log();
+    info("Popular MCP starter packs:");
+    console.log();
+    info("  a) Essential   — filesystem, git, memory");
+    info("  b) Web         — fetch, brave-search, firecrawl");
+    info("  c) DevOps      — github, docker, sentry");
+    info("  d) Custom      — pick your own");
+    console.log();
+    const pack = await ask("  Choose a pack (a/b/c/d): ");
+    let mcpSlugs;
+    switch (pack.toLowerCase()) {
+        case "a":
+            mcpSlugs = ["filesystem-mcp", "git-mcp", "memory-mcp"];
+            break;
+        case "b":
+            mcpSlugs = ["fetch-mcp", "brave-search-mcp", "firecrawl-mcp"];
+            break;
+        case "c":
+            mcpSlugs = ["github-mcp", "docker-mcp", "sentry-mcp"];
+            break;
+        default: {
+            const picked = await chooseMultiple("Select MCP servers to install:", mcpRegistry.map((m) => ({ name: m.name, slug: m.slug })));
+            mcpSlugs = picked.map((p) => p.slug);
+        }
+    }
+    if (mcpSlugs.length === 0) {
+        warn("No MCP servers selected. Skipping MCP setup.");
+    }
+    // Step 4 — Collect env vars for all selected MCP servers
+    const allEnvValues = {};
+    for (const slug of mcpSlugs) {
+        const mcp = findMcp(slug);
+        if (!mcp)
+            continue;
+        if (mcp.envVars && mcp.envVars.length > 0) {
+            console.log();
+            info(`${mcp.name} requires: ${mcp.envVars.join(", ")}`);
+            const vals = await askEnvVars(mcp.envVars);
+            Object.assign(allEnvValues, vals);
+        }
+    }
+    // Step 5 — Install to all selected agents
+    console.log();
+    heading("Installing...");
+    for (const agent of selectedAgents) {
+        for (const slug of mcpSlugs) {
+            const mcp = findMcp(slug);
+            if (!mcp)
+                continue;
+            const entry = resolveEnvPlaceholders({ ...mcp.entry }, allEnvValues);
+            const serverName = slug.replace(/-mcp$/, "");
+            addMcpToAgent(agent, serverName, entry);
+            success(`${mcp.name} → ${agent.name}`);
+        }
+    }
+    // Step 6 — Optionally install skills
+    console.log();
+    const wantSkills = await confirm("Install some skills too?");
+    if (wantSkills) {
+        const picked = await chooseMultiple("Select skills:", skillRegistry.map((s) => ({ name: s.name, slug: s.slug })));
+        for (const s of picked) {
+            const skill = findSkill(s.slug);
+            if (!skill)
+                continue;
+            const skillDir = join(process.cwd(), ".zerocode", "skills", skill.slug);
+            const skillPath = join(skillDir, "SKILL.md");
+            if (!existsSync(skillDir))
+                mkdirSync(skillDir, { recursive: true });
+            writeFileSync(skillPath, skill.skillMd + "\n", "utf-8");
+            success(`${skill.name} → ${skillPath}`);
+        }
+    }
+    console.log();
+    success("Setup complete!");
+    info("Restart your agents to pick up the new MCP servers.");
+    info("Run 'zerocode status' to verify everything.");
+}
+// ── Doctor ───────────────────────────────────────────────────────
+function commandExists(cmd) {
+    try {
+        execSync(`which ${cmd}`, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isValidJson(filePath) {
+    try {
+        if (!existsSync(filePath))
+            return false;
+        JSON.parse(readFileSync(filePath, "utf-8"));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function cmdDoctor() {
+    heading("Diagnostics");
+    let issues = 0;
+    // Check runtimes
+    info("Checking runtimes...");
+    console.log();
+    const runtimes = [
+        ["node", "Required for npx-based MCP servers"],
+        ["npx", "Runs MCP servers from npm"],
+        ["uvx", "Runs Python-based MCP servers (git, fetch, sqlite)"],
+        ["python3", "Required by some MCP servers"],
+    ];
+    for (const [cmd, purpose] of runtimes) {
+        if (commandExists(cmd)) {
+            try {
+                const ver = execSync(`${cmd} --version 2>/dev/null`, { encoding: "utf-8" }).trim();
+                success(`${cmd} ${ver}  — ${purpose}`);
+            }
+            catch {
+                success(`${cmd} found  — ${purpose}`);
+            }
+        }
+        else {
+            warn(`${cmd} not found — ${purpose}`);
+            issues++;
+        }
+    }
+    // Check agents
+    console.log();
+    info("Checking agents...");
+    console.log();
+    const detected = detectAgents();
+    if (detected.length === 0) {
+        warn("No agents detected.");
+        issues++;
+    }
+    else {
+        for (const agent of detected) {
+            const configExists = existsSync(agent.configPath);
+            const usesJson = agent.configFormat !== "claude-code";
+            const configValid = usesJson ? isValidJson(agent.configPath) : configExists;
+            if (!configExists) {
+                item(agent.name, "config not found (will be created on first add)");
+            }
+            else if (!configValid) {
+                error(`${agent.name} — config exists but is INVALID JSON: ${agent.configPath}`);
+                issues++;
+            }
+            else {
+                const installed = listInstalledMcp(agent);
+                const count = Object.keys(installed).length;
+                success(`${agent.name} — ${count} MCP server(s) configured`);
+                // Check if configured servers have placeholder env vars
+                for (const [key, srv] of Object.entries(installed)) {
+                    const hasPlaceholder = srv.args.some((a) => /^\{.+\}$/.test(a));
+                    const envPlaceholders = srv.env
+                        ? Object.values(srv.env).filter((v) => /^\{.+\}$/.test(v))
+                        : [];
+                    if (hasPlaceholder || envPlaceholders.length > 0) {
+                        warn(`  └─ ${key}: has unresolved placeholder values`);
+                        issues++;
+                    }
+                }
+            }
+        }
+    }
+    // Summary
+    console.log();
+    divider();
+    if (issues === 0) {
+        success("All checks passed! Your setup looks healthy.");
+    }
+    else {
+        warn(`${issues} issue(s) found. Review the warnings above.`);
+    }
+}
+// ── Backup / Restore ─────────────────────────────────────────────
+const BACKUP_DIR = join(process.cwd(), ".zerocode");
+const BACKUP_FILE = join(BACKUP_DIR, "backup.json");
+async function cmdBackup() {
+    heading("Backing up agent configs");
+    const detected = detectAgents();
+    if (detected.length === 0) {
+        warn("No agents detected. Nothing to back up.");
+        return;
+    }
+    const backup = {
+        timestamp: new Date().toISOString(),
+        agents: [],
+    };
+    for (const agent of detected) {
+        if (existsSync(agent.configPath)) {
+            const content = readFileSync(agent.configPath, "utf-8");
+            backup.agents.push({
+                id: agent.id,
+                name: agent.name,
+                configPath: agent.configPath,
+                configFormat: agent.configFormat,
+                content,
+            });
+            success(`${agent.name} — backed up`);
+        }
+        else {
+            info(`${agent.name} — no config file yet, skipping`);
+        }
+    }
+    if (backup.agents.length === 0) {
+        warn("No configs found to back up.");
+        return;
+    }
+    if (!existsSync(BACKUP_DIR)) {
+        mkdirSync(BACKUP_DIR, { recursive: true });
+    }
+    writeFileSync(BACKUP_FILE, JSON.stringify(backup, null, 2), "utf-8");
+    console.log();
+    success(`Backup saved to ${BACKUP_FILE}`);
+    info(`${backup.agents.length} agent config(s) stored.`);
+}
+async function cmdRestore() {
+    heading("Restoring agent configs");
+    if (!existsSync(BACKUP_FILE)) {
+        error(`No backup found at ${BACKUP_FILE}`);
+        info("Run 'zerocode backup' first.");
+        return;
+    }
+    const raw = readFileSync(BACKUP_FILE, "utf-8");
+    let backup;
+    try {
+        backup = JSON.parse(raw);
+    }
+    catch {
+        error("Backup file is corrupted.");
+        return;
+    }
+    info(`Backup from: ${backup.timestamp}`);
+    info(`Contains: ${backup.agents.length} agent config(s)`);
+    console.log();
+    for (const entry of backup.agents) {
+        item(entry.name, entry.configPath);
+    }
+    console.log();
+    const ok = await confirm("Restore all configs? This will overwrite current configs.");
+    if (!ok) {
+        warn("Cancelled.");
+        return;
+    }
+    for (const entry of backup.agents) {
+        const dir = dirname(entry.configPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(entry.configPath, entry.content, "utf-8");
+        success(`${entry.name} — restored`);
+    }
+    console.log();
+    success("All configs restored!");
+    info("Restart your agents to apply.");
+}
+// ── Export / Import ──────────────────────────────────────────────
+const EXPORT_FILE = join(process.cwd(), ".zerocode.json");
+async function cmdExport() {
+    heading("Exporting configuration");
+    const detected = detectAgents();
+    if (detected.length === 0) {
+        warn("No agents detected. Nothing to export.");
+        return;
+    }
+    // Collect all unique MCP server slugs across agents
+    const mcpMap = new Map();
+    const agentNames = [];
+    for (const agent of detected) {
+        const installed = listInstalledMcp(agent);
+        const keys = Object.keys(installed);
+        if (keys.length > 0) {
+            agentNames.push(agent.name);
+        }
+        for (const key of keys) {
+            if (mcpMap.has(key))
+                continue;
+            // Try to match back to registry for metadata
+            const regEntry = mcpRegistry.find((m) => m.slug.replace(/-mcp$/, "") === key);
+            mcpMap.set(key, {
+                slug: regEntry?.slug ?? key,
+                name: regEntry?.name ?? key,
+                envVars: regEntry?.envVars,
+            });
+        }
+    }
+    // Collect installed skills
+    const skillsSlugs = [];
+    const skillsDir = join(process.cwd(), ".zerocode", "skills");
+    if (existsSync(skillsDir)) {
+        try {
+            const dirs = readdirSync(skillsDir, { withFileTypes: true });
+            for (const d of dirs) {
+                if (d.isDirectory() && existsSync(join(skillsDir, d.name, "SKILL.md"))) {
+                    skillsSlugs.push(d.name);
+                }
+            }
+        }
+        catch { /* ignore */ }
+    }
+    if (mcpMap.size === 0 && skillsSlugs.length === 0) {
+        warn("No MCP servers or skills found. Nothing to export.");
+        return;
+    }
+    const manifest = {
+        version: 1,
+        timestamp: new Date().toISOString(),
+        mcpServers: Array.from(mcpMap.values()),
+        skills: skillsSlugs,
+        source: { agents: agentNames },
+    };
+    // Show summary
+    if (manifest.mcpServers.length > 0) {
+        success(`${manifest.mcpServers.length} MCP server(s):`);
+        for (const m of manifest.mcpServers) {
+            item(m.name, m.slug);
+        }
+    }
+    if (manifest.skills.length > 0) {
+        console.log();
+        success(`${manifest.skills.length} skill(s):`);
+        for (const s of manifest.skills) {
+            item(s, "");
+        }
+    }
+    console.log();
+    const ok = await confirm(`Export to ${EXPORT_FILE}?`);
+    if (!ok) {
+        warn("Cancelled.");
+        return;
+    }
+    writeFileSync(EXPORT_FILE, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+    console.log();
+    success(`Exported to ${EXPORT_FILE}`);
+    info("Share this file with your team or copy it to another machine.");
+    info("Import with: zerocode import");
+}
+async function cmdImport() {
+    heading("Importing configuration");
+    const importPath = args[1] || EXPORT_FILE;
+    if (!existsSync(importPath)) {
+        error(`No manifest found at ${importPath}`);
+        info("Usage: zerocode import [path-to-.zerocode.json]");
+        info("Or run 'zerocode export' on the source machine first.");
+        return;
+    }
+    let manifest;
+    try {
+        manifest = JSON.parse(readFileSync(importPath, "utf-8"));
+    }
+    catch {
+        error("Manifest file is invalid JSON.");
+        return;
+    }
+    if (!manifest.version || !manifest.mcpServers) {
+        error("Invalid manifest format.");
+        return;
+    }
+    info(`Manifest from: ${manifest.timestamp}`);
+    info(`Source agents: ${manifest.source.agents.join(", ") || "unknown"}`);
+    console.log();
+    if (manifest.mcpServers.length > 0) {
+        success(`${manifest.mcpServers.length} MCP server(s) to install:`);
+        for (const m of manifest.mcpServers) {
+            item(m.name, m.slug);
+        }
+    }
+    if (manifest.skills.length > 0) {
+        console.log();
+        success(`${manifest.skills.length} skill(s) to install:`);
+        for (const s of manifest.skills) {
+            item(s, "");
+        }
+    }
+    // Pick target agents
+    console.log();
+    const detected = detectAgents();
+    if (detected.length === 0) {
+        warn("No agents detected on this machine.");
+        info("Install an agent first, then re-run.");
+        return;
+    }
+    const selectedAgents = await chooseMultiple("Install to which agents?", detected);
+    if (selectedAgents.length === 0) {
+        warn("No agents selected. Aborting.");
+        return;
+    }
+    // Collect all required env vars
+    const allRequiredEnvVars = [];
+    for (const m of manifest.mcpServers) {
+        if (m.envVars) {
+            for (const v of m.envVars) {
+                if (!allRequiredEnvVars.includes(v)) {
+                    allRequiredEnvVars.push(v);
+                }
+            }
+        }
+    }
+    let envValues = {};
+    if (allRequiredEnvVars.length > 0) {
+        console.log();
+        info(`Some servers require env vars: ${allRequiredEnvVars.join(", ")}`);
+        envValues = await askEnvVars(allRequiredEnvVars);
+    }
+    // Install MCP servers
+    console.log();
+    heading("Installing MCP servers...");
+    for (const agent of selectedAgents) {
+        for (const m of manifest.mcpServers) {
+            const regEntry = findMcp(m.slug);
+            if (regEntry) {
+                const entry = resolveEnvPlaceholders({ ...regEntry.entry }, envValues);
+                const serverName = m.slug.replace(/-mcp$/, "");
+                addMcpToAgent(agent, serverName, entry);
+                success(`${m.name} → ${agent.name}`);
+            }
+            else {
+                warn(`${m.slug} not found in registry — skipped`);
+            }
+        }
+    }
+    // Install skills
+    if (manifest.skills.length > 0) {
+        console.log();
+        heading("Installing skills...");
+        for (const slug of manifest.skills) {
+            const skill = findSkill(slug);
+            if (skill) {
+                const skillDir = join(process.cwd(), ".zerocode", "skills", skill.slug);
+                const skillPath = join(skillDir, "SKILL.md");
+                if (!existsSync(skillDir))
+                    mkdirSync(skillDir, { recursive: true });
+                writeFileSync(skillPath, skill.skillMd + "\n", "utf-8");
+                success(`${skill.name} → ${skillPath}`);
+            }
+            else {
+                warn(`Skill "${slug}" not found in registry — skipped`);
+            }
+        }
+    }
+    console.log();
+    success("Import complete!");
+    info("Restart your agents to pick up the new MCP servers.");
+}
+// ── Configure (agent-centric interactive) ────────────────────────
+async function cmdConfigure() {
+    heading("Agent Configurator");
+    // Step 1 — Detect agents
+    const detected = detectAgents();
+    if (detected.length === 0) {
+        warn("No agents detected on this machine.");
+        info("Install an agent first (Claude Desktop, Cursor, Windsurf, etc.) and re-run.");
+        return;
+    }
+    success(`Found ${detected.length} agent(s):`);
+    console.log();
+    for (const a of detected) {
+        item(a.name, `${a.scope} · ${a.configPath}`);
+    }
+    // Step 2 — Pick an agent
+    const agent = await choose("Select an agent to configure:", detected);
+    if (!agent) {
+        warn("No agent selected. Aborting.");
+        return;
+    }
+    console.log();
+    success(`Selected: ${agent.name}`);
+    // Step 3 — Interactive menu loop
+    const actions = [
+        { name: "Add MCP server" },
+        { name: "Add skill" },
+        { name: "View installed MCP servers" },
+        { name: "Remove MCP server" },
+        { name: "Exit" },
+    ];
+    while (true) {
+        console.log();
+        divider();
+        const action = await choose(`What do you want to do with ${agent.name}?`, actions);
+        if (!action || action.name === "Exit") {
+            info("Done configuring.");
+            break;
+        }
+        if (action.name === "Add MCP server") {
+            await configureAddMcp(agent);
+        }
+        else if (action.name === "Add skill") {
+            await configureAddSkill();
+        }
+        else if (action.name === "View installed MCP servers") {
+            configureViewInstalled(agent);
+        }
+        else if (action.name === "Remove MCP server") {
+            await configureRemoveMcp(agent);
+        }
+    }
+}
+async function configureAddMcp(agent) {
+    // Let user pick from the full registry
+    const items = mcpRegistry.map((m) => ({ name: `${m.name}  \x1b[2m${m.slug}\x1b[0m`, slug: m.slug }));
+    const picked = await choose("Select MCP server to install:", items);
+    if (!picked) {
+        warn("Nothing selected.");
+        return;
+    }
+    const mcp = findMcp(picked.slug);
+    if (!mcp)
+        return;
+    info(mcp.description);
+    // Collect env vars
+    let envValues = {};
+    if (mcp.envVars && mcp.envVars.length > 0) {
+        console.log();
+        info(`Requires: ${mcp.envVars.join(", ")}`);
+        envValues = await askEnvVars(mcp.envVars);
+    }
+    const entry = resolveEnvPlaceholders({ ...mcp.entry }, envValues);
+    const serverName = mcp.slug.replace(/-mcp$/, "");
+    console.log();
+    info(`Server:  ${mcp.name}`);
+    info(`Agent:   ${agent.name}`);
+    info(`Key:     ${serverName}`);
+    console.log();
+    const ok = await confirm("Install this MCP server?");
+    if (!ok) {
+        warn("Cancelled.");
+        return;
+    }
+    const written = addMcpToAgent(agent, serverName, entry);
+    if (!written) {
+        warn(`${agent.name} does not use JSON config — MCP must be configured manually.`);
+        info(`Add the server entry to: ${agent.configPath}`);
+        return;
+    }
+    success(`${mcp.name} installed to ${agent.name}`);
+    info("Restart your agent to pick up the new MCP server.");
+}
+async function configureAddSkill() {
+    const items = skillRegistry.map((s) => ({ name: `${s.name}  \x1b[2m${s.slug}\x1b[0m`, slug: s.slug }));
+    const picked = await choose("Select skill to install:", items);
+    if (!picked) {
+        warn("Nothing selected.");
+        return;
+    }
+    const skill = findSkill(picked.slug);
+    if (!skill)
+        return;
+    info(skill.description);
+    const skillDir = join(process.cwd(), ".zerocode", "skills", skill.slug);
+    const skillPath = join(skillDir, "SKILL.md");
+    if (existsSync(skillPath)) {
+        const overwrite = await confirm(`Skill already exists at ${skillPath}. Overwrite?`);
+        if (!overwrite) {
+            warn("Cancelled.");
+            return;
+        }
+    }
+    if (!existsSync(skillDir)) {
+        mkdirSync(skillDir, { recursive: true });
+    }
+    writeFileSync(skillPath, skill.skillMd + "\n", "utf-8");
+    success(`${skill.name} installed to ${skillPath}`);
+}
+function configureViewInstalled(agent) {
+    const installed = listInstalledMcp(agent);
+    const keys = Object.keys(installed);
+    console.log();
+    if (keys.length === 0) {
+        info("No MCP servers configured on this agent.");
+    }
+    else {
+        success(`${keys.length} MCP server(s) on ${agent.name}:`);
+        console.log();
+        for (const key of keys) {
+            const srv = installed[key];
+            item(key, `${srv.command} ${srv.args.join(" ")}`);
+        }
+    }
+}
+async function configureRemoveMcp(agent) {
+    const installed = listInstalledMcp(agent);
+    const keys = Object.keys(installed);
+    if (keys.length === 0) {
+        info("No MCP servers to remove.");
+        return;
+    }
+    const items = keys.map((k) => ({ name: k }));
+    const picked = await choose("Select MCP server to remove:", items);
+    if (!picked) {
+        warn("Nothing selected.");
+        return;
+    }
+    const ok = await confirm(`Remove "${picked.name}" from ${agent.name}?`);
+    if (!ok) {
+        warn("Cancelled.");
+        return;
+    }
+    const removed = removeMcpFromAgent(agent, picked.name);
+    if (removed) {
+        success(`Removed "${picked.name}" from ${agent.name}`);
+    }
+    else {
+        warn(`"${picked.name}" was not found.`);
+    }
+}
+// ── Sync ─────────────────────────────────────────────────────────
+async function cmdSync() {
+    heading("Sync MCP servers between agents");
+    const detected = detectAgents();
+    if (detected.length < 2) {
+        warn("Need at least 2 detected agents to sync.");
+        if (detected.length === 1) {
+            info(`Only found: ${detected[0].name}`);
+        }
+        info("Install more agents and re-run.");
+        return;
+    }
+    // Filter to agents that support JSON config (can read from)
+    const readable = detected.filter((a) => supportsJsonConfig(a));
+    if (readable.length === 0) {
+        warn("No agents with readable JSON config found.");
+        return;
+    }
+    // Step 1 — Pick source agent
+    const source = await choose("Copy FROM which agent?", readable);
+    if (!source) {
+        warn("No source agent selected. Aborting.");
+        return;
+    }
+    const installed = listInstalledMcp(source);
+    const keys = Object.keys(installed);
+    if (keys.length === 0) {
+        warn(`${source.name} has no MCP servers configured. Nothing to sync.`);
+        return;
+    }
+    console.log();
+    success(`${source.name} has ${keys.length} MCP server(s):`);
+    console.log();
+    for (const key of keys) {
+        const srv = installed[key];
+        item(key, `${srv.command} ${srv.args.join(" ")}`);
+    }
+    // Step 2 — Pick which servers to copy
+    console.log();
+    const copyAll = await confirm("Copy all servers?");
+    let serversToCopy;
+    if (copyAll) {
+        serversToCopy = keys;
+    }
+    else {
+        const picked = await chooseMultiple("Select servers to copy:", keys.map((k) => ({ name: k })));
+        serversToCopy = picked.map((p) => p.name);
+        if (serversToCopy.length === 0) {
+            warn("No servers selected. Aborting.");
+            return;
+        }
+    }
+    // Step 3 — Pick target agents
+    const targets = detected.filter((a) => a.id !== source.id && supportsJsonConfig(a));
+    if (targets.length === 0) {
+        warn("No other agents with JSON config available as targets.");
+        return;
+    }
+    console.log();
+    const selectedTargets = await chooseMultiple("Copy TO which agents?", targets);
+    if (selectedTargets.length === 0) {
+        warn("No target agents selected. Aborting.");
+        return;
+    }
+    // Step 4 — Summary and confirm
+    console.log();
+    info(`Copying ${serversToCopy.length} server(s) from ${source.name} to:`);
+    for (const t of selectedTargets) {
+        info(`  → ${t.name}`);
+    }
+    console.log();
+    const ok = await confirm("Proceed?");
+    if (!ok) {
+        warn("Cancelled.");
+        return;
+    }
+    // Step 5 — Copy
+    console.log();
+    let copied = 0;
+    let skipped = 0;
+    for (const target of selectedTargets) {
+        for (const serverName of serversToCopy) {
+            const entry = installed[serverName];
+            const written = addMcpToAgent(target, serverName, entry);
+            if (written) {
+                success(`${serverName} → ${target.name}`);
+                copied++;
+            }
+            else {
+                warn(`${serverName} → ${target.name} — skipped (non-JSON config)`);
+                skipped++;
+            }
+        }
+    }
+    console.log();
+    success(`Sync complete! ${copied} server(s) copied.`);
+    if (skipped > 0) {
+        warn(`${skipped} skipped (agents without JSON config support).`);
+    }
+    info("Restart your agents to pick up the changes.");
+}
 // ── Main ─────────────────────────────────────────────────────────
 async function main() {
+    // Show splash on every run except version
+    const isVersion = command === "version" || command === "--version" || command === "-v";
+    if (!isVersion) {
+        banner(PKG_VERSION);
+    }
     if (!command) {
-        usage();
+        printUsage();
         return;
     }
     switch (command) {
@@ -319,19 +1084,45 @@ async function main() {
         case "status":
             await cmdStatus();
             break;
+        case "init":
+            await cmdInit();
+            break;
+        case "doctor":
+            await cmdDoctor();
+            break;
+        case "backup":
+            await cmdBackup();
+            break;
+        case "restore":
+            await cmdRestore();
+            break;
+        case "configure":
+        case "config":
+            await cmdConfigure();
+            break;
+        case "sync":
+        case "copy":
+            await cmdSync();
+            break;
+        case "export":
+            await cmdExport();
+            break;
+        case "import":
+            await cmdImport();
+            break;
         case "help":
         case "--help":
         case "-h":
-            usage();
+            printUsage();
             break;
         case "version":
         case "--version":
         case "-v":
-            console.log("zerocode 0.1.0");
+            console.log(`zerocode ${PKG_VERSION}`);
             break;
         default:
             error(`Unknown command: ${command}`);
-            usage();
+            printUsage();
     }
 }
 main().catch((err) => {