s-app-scoder-agent 0.8.21 → 0.9.2

package/dist/index.js

@@ -9,6 +9,7 @@ import { JsonlLogger } from "./logger.js";
 import { collectUsage, formatCostReport } from "./cost.js";
 import { getVersion as getPackageVersion } from "./version.js";
 import { dispatchCommand } from "./tui/command-registry.js";
+import { selectableAgents } from "./agents.js";
 import * as ui from "./ui.js";
 // Single source of truth: read version from package.json (see src/version.ts).
 const VERSION = getPackageVersion();
@@ -48,6 +49,7 @@ OPTIONS
   -s, --max-steps <n>       Max autonomous loop iterations (default 40)
   -y, --yes                 Non-interactive mode (auto-approves commands)
   --permission <mode>       auto | ask | readonly (env SCODER_PERMISSION, default auto)
+  --agent <name>            primary agent to run (default build; see /agent): build | plan | review | <custom>
   --no-save                 Disable session auto-save to .scoder/sessions/
   --log-file                Write a JSONL event log to .scoder/logs/<session>.jsonl
                             (or set SCODER_LOG_FILE=1 / =/path/to/log.jsonl)
@@ -102,6 +104,9 @@ function parseArgs(argv) {
             case "--yes":
                 args.yes = true;
                 break;
+            case "--agent":
+                args.agent = next();
+                break;
             case "--permission": {
                 const mode = next();
                 if (mode !== "auto" && mode !== "ask" && mode !== "readonly") {
@@ -113,6 +118,18 @@ function parseArgs(argv) {
             case "--no-save":
                 args.noSave = true;
                 break;
+            case "--no-color":
+                args.noColor = true;
+                break;
+            case "--no-motion":
+                args.noMotion = true;
+                break;
+            case "--plain":
+                args.plain = true;
+                break;
+            case "--high-contrast":
+                args.highContrast = true;
+                break;
             case "--log-file":
                 args.logFile = true;
                 break;
@@ -154,11 +171,23 @@ function parseArgs(argv) {
             case "--version":
                 args.version = true;
                 break;
-            default:
+            default: {
                 if (a.startsWith("-")) {
-                    throw new Error(`Unknown option: ${a} (see --help)`);
+                    // MCP subcommand flags (--command, --url, --trust, --args) are not
+                    // known globally — pass them through as positional args for runMcpCommand
+                    // to interpret. Only throw if we are NOT in an mcp subcommand context.
+                    const isMcpContext = rest[0] === "mcp" || argv.slice(0, i).includes("mcp");
+                    if (!isMcpContext)
+                        throw new Error(`Unknown option: ${a} (see --help)`);
+                    rest.push(a);
+                    // Consume the next token as this option's value if present.
+                    if (i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
+                        rest.push(argv[++i]);
+                    }
+                    break;
                 }
                 rest.push(a);
+            }
         }
     }
     args.task = rest.length > 0 ? rest.join(" ") : null;
@@ -201,6 +230,23 @@ function parseArgs(argv) {
         args.subcommand = "init";
         args.task = null;
     }
+    else if (rest[0] === "mcp") {
+        // scoder mcp list|add <name>|remove <name>|test <name>
+        // e.g. scoder mcp add github --command "npx mcp-github" --url "..." --trust readonly
+        args.subcommand = "mcp";
+        const m = rest[1];
+        if (m === "list" || m === "add" || m === "remove" || m === "test" || m === "import") {
+            args.mcpCmd = m;
+        }
+        else if (m) {
+            args.mcpCmd = "list";
+        }
+        else {
+            args.mcpCmd = "list";
+        }
+        args.mcpArgs = rest.slice(2);
+        args.task = null;
+    }
     return args;
 }
 async function runOnce(cfg, task) {
@@ -324,6 +370,9 @@ async function repl(cfg) {
         const host = {
             agent: () => agent,
             config: cfg,
+            updateConfig: (patch) => {
+                Object.assign(cfg, patch); // mutate the shared cfg so new Agents see it
+            },
             replaceAgent: (next) => {
                 agent.abort();
                 agent.dispose();
@@ -350,6 +399,17 @@ async function repl(cfg) {
                 break;
             if (outcome?.notice)
                 ui.info(outcome.notice);
+            if (!outcome?.task)
+                continue;
+            try {
+                const result = first ? await agent.run(outcome.task) : await agent.runTurn(outcome.task);
+                first = false;
+                if (!result.success)
+                    ui.warn("task did not complete — try refining it");
+            }
+            catch (err) {
+                ui.error(err.message);
+            }
             continue;
         }
         try {
@@ -366,6 +426,191 @@ async function repl(cfg) {
     ui.info("bye");
     process.exit(0);
 }
+async function runMcpCommand(cfg, cmd, restArgs) {
+    const { McpManager } = await import("./mcp.js");
+    const { readFileSync, writeFileSync, existsSync } = await import("node:fs");
+    const { join, dirname } = await import("node:path");
+    const { mkdirSync } = await import("node:fs");
+    const rcPath = join(cfg.workdir, ".scoderrc.json");
+    // Load existing mcpServers from workdir rc.
+    const existing = {};
+    if (existsSync(rcPath)) {
+        try {
+            Object.assign(existing, JSON.parse(readFileSync(rcPath, "utf8")).mcpServers ?? {});
+        }
+        catch { /* ignore */ }
+    }
+    if (cmd === "list") {
+        const servers = Object.entries(cfg.mcpServers ?? existing);
+        if (servers.length === 0) {
+            console.log("no MCP servers configured — add mcpServers to .scoderrc.json");
+            return;
+        }
+        for (const [name, cfg_srv] of servers) {
+            const trust = cfg_srv.trust ?? "auto";
+            const enabled = cfg_srv.enabled === false ? " (disabled)" : "";
+            const target = cfg_srv.url ?? cfg_srv.command ?? "?";
+            console.log(`${name}: ${target}${trust !== "auto" ? ` [${trust}]` : ""}${enabled}`);
+        }
+        return;
+    }
+    if (cmd === "add") {
+        // scoder mcp add <name> --command "..." [--url "..."] [--trust auto|ask|readonly|deny]
+        const name = restArgs[0];
+        if (!name) {
+            console.error("usage: scoder mcp add <name> --command '...' [--url '...'] [--trust readonly]");
+            return;
+        }
+        const opts = {};
+        for (let i = 1; i < restArgs.length; i++) {
+            if (restArgs[i] === "--command" || restArgs[i] === "-c")
+                opts.command = restArgs[++i];
+            else if (restArgs[i] === "--url" || restArgs[i] === "-u")
+                opts.url = restArgs[++i];
+            else if (restArgs[i] === "--trust" || restArgs[i] === "-t")
+                opts.trust = restArgs[++i];
+            else if (restArgs[i] === "--args" || restArgs[i] === "-a")
+                opts.args = restArgs[++i];
+        }
+        if (!opts.command && !opts.url) {
+            console.error("error: --command or --url required");
+            return;
+        }
+        const newEntry = { ...(opts.command ? { command: opts.command } : {}), ...(opts.url ? { url: opts.url } : {}), ...(opts.args ? { args: opts.args.split(" ") } : {}), ...(opts.trust ? { trust: opts.trust } : {}) };
+        const allServers = { ...existing, [name]: newEntry };
+        const rc = existsSync(rcPath) ? JSON.parse(readFileSync(rcPath, "utf8")) : {};
+        mkdirSync(dirname(rcPath) || ".", { recursive: true });
+        writeFileSync(rcPath, JSON.stringify({ ...rc, mcpServers: allServers }, null, 2) + "\n", "utf8");
+        console.log(`MCP server "${name}" added to ${rcPath}`);
+        return;
+    }
+    if (cmd === "remove") {
+        const name = restArgs[0];
+        if (!name) {
+            console.error("usage: scoder mcp remove <name>");
+            return;
+        }
+        if (!existing[name] && !(cfg.mcpServers ?? {})[name]) {
+            console.error(`MCP server "${name}" not found in config`);
+            return;
+        }
+        const allServers = { ...existing };
+        delete allServers[name];
+        const rc = existsSync(rcPath) ? JSON.parse(readFileSync(rcPath, "utf8")) : {};
+        mkdirSync(dirname(rcPath) || ".", { recursive: true });
+        writeFileSync(rcPath, JSON.stringify({ ...rc, mcpServers: allServers }, null, 2) + "\n", "utf8");
+        console.log(`MCP server "${name}" removed from ${rcPath}`);
+        return;
+    }
+    if (cmd === "test") {
+        const name = restArgs[0];
+        if (!name) {
+            console.error("usage: scoder mcp test <name>");
+            return;
+        }
+        const srvCfg = (cfg.mcpServers ?? {})[name] ?? existing[name];
+        if (!srvCfg) {
+            console.error(`MCP server "${name}" not found`);
+            return;
+        }
+        if (srvCfg.enabled === false) {
+            console.log(`✘ "${name}" is disabled (enabled:false)`);
+            return;
+        }
+        if (srvCfg.trust === "readonly") {
+            console.log(`✘ "${name}" is trust:readonly — not spawning`);
+            return;
+        }
+        console.log(`connecting to "${name}"...`);
+        const m = new McpManager({ [name]: srvCfg });
+        try {
+            await m.connectAll();
+            const states = m.serverStates();
+            const s = states[0];
+            if (s?.state === "ready") {
+                console.log(`✓ "${name}" connected — ${s.toolCount} tools`);
+                console.log(`  serverInfo: ${s.serverInfo.name ?? "?"} v${s.serverInfo.version ?? "?"}`);
+                console.log(`  capabilities: ${Object.keys(s.capabilities).join(", ") || "(none)"}`);
+            }
+            else {
+                console.log(`✘ "${name}" failed to connect (state: ${s?.state})`);
+            }
+        }
+        finally {
+            m.killAll();
+        }
+        return;
+    }
+    if (cmd === "import") {
+        // scoder mcp import [path] [--dry-run] [--force]
+        const { loadConfigFile, discoverConfigs, mergeConfigs } = await import("./mcp-import.js");
+        const dryRun = restArgs.includes("--dry-run");
+        const force = restArgs.includes("--force");
+        const paths = restArgs.filter((a) => !a.startsWith("--"));
+        let discovered = [];
+        try {
+            discovered = discoverConfigs();
+        }
+        catch { /* ignore */ }
+        if (paths.length === 0 && discovered.length === 0) {
+            console.log("No config files found. Provide a path or ensure one of these exists:");
+            console.log("  ~/.claude/config.json  — Claude Desktop MCP servers");
+            console.log("  opencode.json         — OpenCode MCP config");
+            console.log("  .mcp.json             — standard MCP server list");
+            console.log("\nUsage: scoder mcp import [path] [--dry-run] [--force]");
+            return;
+        }
+        // Auto-discover when no path given
+        const toCheck = paths.length > 0 ? paths : discovered.map((d) => d.source);
+        if (paths.length === 0 && discovered.length > 0) {
+            console.log("Auto-discovered MCP config files:");
+            for (const d of discovered) {
+                console.log(`  ${d.format}: ${d.source} (${d.serverCount} server${d.serverCount === 1 ? "" : "s"})`);
+            }
+            console.log();
+        }
+        const { readFileSync, writeFileSync, existsSync } = await import("node:fs");
+        const { mkdirSync } = await import("node:fs");
+        let totalAdded = 0;
+        let totalSkipped = 0;
+        for (const srcPath of toCheck) {
+            const servers = loadConfigFile(srcPath);
+            if (!servers) {
+                console.log(`  skip: ${srcPath} not found`);
+                continue;
+            }
+            const { added, skipped } = mergeConfigs(existing, servers, { force, dryRun });
+            totalAdded += added.length;
+            totalSkipped += skipped.length;
+            console.log(`${srcPath}:`);
+            for (const s of added) {
+                const target = s.config.url ?? s.config.command ?? "?";
+                console.log(`  + ${s.name}: ${target} (from ${s.originalKey})`);
+            }
+            for (const s of skipped) {
+                console.log(`  ~ ${s.name}: skipped (already exists; use --force to overwrite)`);
+            }
+            if (added.length === 0 && skipped.length === 0) {
+                console.log(`    (no servers found)`);
+            }
+        }
+        if (dryRun) {
+            console.log(`\n[DRY RUN] Would import ${totalAdded} server${totalAdded === 1 ? "" : "s"} (${totalSkipped} skipped).`);
+            return;
+        }
+        if (totalAdded > 0) {
+            const rc = existsSync(rcPath) ? JSON.parse(readFileSync(rcPath, "utf8")) : {};
+            mkdirSync(dirname(rcPath) || ".", { recursive: true });
+            writeFileSync(rcPath, JSON.stringify({ ...rc, mcpServers: existing }, null, 2) + "\n", "utf8");
+            console.log(`\nImported ${totalAdded} server${totalAdded === 1 ? "" : "s"} into ${rcPath} (${totalSkipped} skipped).`);
+        }
+        else {
+            console.log(`\nNothing to import.`);
+        }
+        return;
+    }
+    console.error(`unknown mcp command: ${cmd}`);
+}
 async function main() {
     let args;
     try {
@@ -383,6 +628,14 @@ async function main() {
         console.log(HELP);
         return;
     }
+    if (args.noColor)
+        process.env.NO_COLOR = "1";
+    if (args.noMotion)
+        process.env.SCODER_NO_MOTION = "1";
+    if (args.plain)
+        process.env.SCODER_PLAIN = "1";
+    if (args.highContrast)
+        process.env.SCODER_THEME = "high-contrast";
     const cfg = loadConfig({
         model: args.model,
         baseUrl: args.baseUrl,
@@ -395,7 +648,16 @@ async function main() {
         provider: args.provider ?? undefined,
         noSave: args.noSave,
         logFile: args.logFile,
+        agent: args.agent,
     });
+    // v2: --agent must reference a selectable (mode primary|all) agent.
+    if (args.agent) {
+        const ok = selectableAgents(cfg.workdir).some((a) => a.name === args.agent);
+        if (!ok) {
+            ui.error(`unknown or non-primary agent "${args.agent}" — selectable: ${selectableAgents(cfg.workdir).map((a) => a.name).join(", ")}`);
+            process.exit(2);
+        }
+    }
     // Subcommands
     if (args.subcommand === "init") {
         await runInit();
@@ -486,6 +748,10 @@ async function main() {
             console.log(`  (no models match "${filter}")`);
         return;
     }
+    if (args.subcommand === "mcp") {
+        await runMcpCommand(cfg, args.mcpCmd ?? "list", args.mcpArgs ?? []);
+        return;
+    }
     if (args.subcommand === "tui") {
         if (!process.stdin.isTTY || !process.stdout.isTTY) {
             ui.warn("TUI requires an interactive terminal (TTY) — falling back to the classic REPL.");
@@ -531,7 +797,12 @@ async function main() {
     }
     await repl(cfg);
 }
-main().catch((err) => {
-    ui.error(`fatal: ${err.stack ?? err.message}`);
-    process.exit(2);
-});
+import { pathToFileURL } from "node:url";
+// Guard: only run when executed as entry point (not imported in tests).
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    main().catch((err) => {
+        ui.error(`fatal: ${err.stack ?? err.message}`);
+        process.exit(2);
+    });
+}
+export { parseArgs };

package/dist/mcp-import.js

@@ -0,0 +1,204 @@
+/**
+ * Phase 5 — MCP config import: parse server configs from third-party formats
+ * (Claude Desktop, OpenCode, .mcp.json) and merge them into our format.
+ *
+ * Supports:
+ * - Claude Desktop: `~/.claude/config.json` → `mcpServers` (stdio + env)
+ * - OpenCode:       `opencode.json`          → `mcp` (stdio or http)
+ * - Standard:       `.mcp.json`             → array of `{name, command, url, …}`
+ */
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** Normalise a Claude Desktop mcpServers entry to our McpServerConfig. */
+function fromClaudeDesktop(raw, _name) {
+    const cfg = {};
+    if (typeof raw.command === "string") {
+        cfg.command = raw.command;
+        if (Array.isArray(raw.args))
+            cfg.args = raw.args;
+    }
+    else if (typeof raw.url === "string") {
+        cfg.url = raw.url;
+        if (typeof raw.headers === "object" && raw.headers !== null) {
+            cfg.headers = raw.headers;
+        }
+    }
+    if (typeof raw.env === "object" && raw.env !== null) {
+        cfg.env = raw.env;
+    }
+    if (typeof raw.autoApprove === "boolean") {
+        // Claude Desktop autoApprove maps to our trust levels:
+        // autoApprove=true → "auto" (trust the server to run without prompt)
+        // autoApprove=false → "ask" (default, prompt before each tool call)
+        // We deliberately do NOT set trust here — let the global mode apply.
+    }
+    return cfg;
+}
+/** Normalise an OpenCode mcp config entry to our McpServerConfig. */
+function fromOpenCode(raw, _name) {
+    const cfg = {};
+    if (typeof raw.command === "string") {
+        cfg.command = raw.command;
+        if (Array.isArray(raw.args))
+            cfg.args = raw.args;
+    }
+    else if (typeof raw.url === "string") {
+        cfg.url = raw.url;
+        if (typeof raw.headers === "object" && raw.headers !== null) {
+            cfg.headers = raw.headers;
+        }
+    }
+    if (typeof raw.env === "object" && raw.env !== null) {
+        cfg.env = raw.env;
+    }
+    if (raw.disabled === true)
+        cfg.enabled = false;
+    return cfg;
+}
+/** Parse Claude Desktop `mcpServers` config from a JSON string. */
+function parseClaude(raw, sourcePath) {
+    const parsed = JSON.parse(raw);
+    const servers = [];
+    const entries = parsed?.mcpServers ?? parsed?.mcp?.servers ?? {};
+    for (const [key, value] of Object.entries(entries)) {
+        if (!value || typeof value !== "object")
+            continue;
+        const rec = value;
+        if (rec.enabled === false)
+            continue;
+        const config = fromClaudeDesktop(rec, key);
+        if (!config.command && !config.url)
+            continue;
+        servers.push({ source: sourcePath, name: key, originalKey: key, config });
+    }
+    return servers;
+}
+/** Parse OpenCode `mcp` config from a JSON string. */
+function parseOpenCode(raw, sourcePath) {
+    const parsed = JSON.parse(raw);
+    const servers = [];
+    const entries = parsed?.mcp ?? parsed?.servers ?? {};
+    for (const [key, value] of Object.entries(entries)) {
+        if (!value || typeof value !== "object")
+            continue;
+        const rec = value;
+        // OpenCode: "disabled" flag; our config: "enabled: false". Both mean skip.
+        if (rec.disabled === true || rec.enabled === false)
+            continue;
+        const config = fromOpenCode(rec, key);
+        if (!config.command && !config.url)
+            continue;
+        servers.push({ source: sourcePath, name: key, originalKey: key, config });
+    }
+    return servers;
+}
+/** Parse standard `.mcp.json` array of server configs. */
+function parseMcpJson(raw, sourcePath) {
+    const parsed = JSON.parse(raw);
+    const servers = [];
+    const entries = Array.isArray(parsed) ? parsed : [parsed];
+    for (const entry of entries) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const rec = entry;
+        const name = typeof rec.name === "string" ? rec.name : "unknown";
+        if (rec.enabled === false)
+            continue;
+        const cfg = {};
+        if (typeof rec.command === "string") {
+            cfg.command = rec.command;
+            if (Array.isArray(rec.args))
+                cfg.args = rec.args;
+        }
+        else if (typeof rec.url === "string") {
+            cfg.url = rec.url;
+            if (typeof rec.headers === "object" && rec.headers !== null) {
+                cfg.headers = rec.headers;
+            }
+        }
+        if (typeof rec.timeoutMs === "number")
+            cfg.timeoutMs = rec.timeoutMs;
+        if (typeof rec.env === "object" && rec.env !== null) {
+            cfg.env = rec.env;
+        }
+        if (typeof rec.trust === "string")
+            cfg.trust = rec.trust;
+        if (typeof rec.enabled === "boolean")
+            cfg.enabled = rec.enabled;
+        if (!cfg.command && !cfg.url)
+            continue;
+        servers.push({ source: sourcePath, name, originalKey: name, config: cfg });
+    }
+    return servers;
+}
+/** Detect format and parse a source file; throws on unreadable/invalid JSON. */
+export function parseConfigFile(raw, sourcePath) {
+    // Heuristic: if it has `mcpServers` top-level → Claude Desktop.
+    // If it has `mcp` top-level (object or array) → OpenCode or standard MCP.
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Invalid JSON in ${sourcePath}`);
+    }
+    if ("mcpServers" in parsed)
+        return parseClaude(raw, sourcePath);
+    if ("mcp" in parsed)
+        return parseOpenCode(raw, sourcePath);
+    // Fallback: treat as standard MCP JSON array.
+    return parseMcpJson(raw, sourcePath);
+}
+/**
+ * Load + parse one config file by path.
+ * Returns `null` when the file does not exist; throws on unreadable/invalid.
+ */
+export function loadConfigFile(path) {
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+    return parseConfigFile(raw, path);
+}
+export function discoverConfigs() {
+    const found = [];
+    const checks = [
+        [join(homedir(), ".claude", "config.json"), "claude"],
+        [join(homedir(), ".config", "claude", "config.json"), "claude"],
+        [join(process.cwd(), "opencode.json"), "opencode"],
+        [join(process.cwd(), ".mcp.json"), "mcp-json"],
+    ];
+    for (const [path, format] of checks) {
+        try {
+            const raw = readFileSync(path, "utf8");
+            const servers = parseConfigFile(raw, path);
+            if (servers.length > 0)
+                found.push({ source: path, format, serverCount: servers.length });
+        }
+        catch { /* not present */ }
+    }
+    return found;
+}
+/** Merge imported servers into an existing config map. */
+export function mergeConfigs(existing, imported, opts = {}) {
+    const added = [];
+    const skipped = [];
+    const updated = [];
+    for (const srv of imported) {
+        const existingCfg = existing[srv.name];
+        if (existingCfg && !opts.force) {
+            skipped.push(srv);
+            continue;
+        }
+        if (existingCfg && opts.force)
+            updated.push(srv.name);
+        if (!opts.dryRun)
+            existing[srv.name] = srv.config;
+        added.push(srv);
+    }
+    return { added, skipped, updated };
+}