@matterailab/orbcode 0.2.4 → 0.3.1

package/dist/commands/mcp.js

@@ -1,4 +1,6 @@
 import { addMcpServer, configPathForScope, loadMcpConfig, removeMcpServerAnyScope, } from "../mcp/config.js";
+import { applyMigration, describeEntry, discoverSources, listMigrationEntries, } from "./migrate.js";
+import { loadSettings } from "../config/settings.js";
 /**
  * `orbcode mcp` subcommand — manage MCP servers from the command line, like
  * Claude Code's `claude mcp add/remove/list`.
@@ -11,6 +13,7 @@ import { addMcpServer, configPathForScope, loadMcpConfig, removeMcpServerAnyScop
  *   orbcode mcp add --header KEY=value ... <name> <url>            http/sse headers
  *   orbcode mcp remove <name>                                      remove from any scope
  *   orbcode mcp list                                               list all servers
+ *   orbcode mcp migrate [--all] [--dry-run]                        import from Claude/Codex
  *
  * Flags:
  *   -s, --scope <user|project|local>   config scope (default: project)
@@ -39,6 +42,8 @@ Usage:
   orbcode mcp add [options] --transport sse <name> <url>   add an sse server
   orbcode mcp remove <name>                                remove a server
   orbcode mcp list                                         list all servers
+  orbcode mcp migrate [--all] [--dry-run]                  import MCP servers from
+                                                          Claude Code / Claude Desktop
 
 Options:
   -s, --scope <user|project|local>   config scope (default: project)
@@ -47,11 +52,34 @@ Options:
       --header KEY=value             HTTP header (repeatable, http/sse)
       --oauth                        enable OAuth for http/sse
       --oauth-scope <scope>          OAuth scope (implies --oauth)
+      --all                          (migrate) import every detected server
+      --dry-run                      (migrate) show what would be imported, don't write
 
 Scopes:
   project   .mcp.json in the current directory (shared, checked into git)
   user      ~/.orbcode/settings.json (applies to all projects on this machine)
-  local     .orbcode/settings.json (per-project, per-machine, not checked in)`);
+  local     .orbcode/settings.json (per-project, per-machine, not checked in)
+
+Migration sources:
+  orbcode mcp migrate scans these files and copies their mcpServers blocks
+  into ~/.orbcode/settings.json (user scope). Servers whose name already
+  exists in the destination are silently skipped.
+
+    Claude Code (user)         ~/.claude/settings.json
+    Claude Code (user, json)   ~/.claude.json -> root mcpServers
+                               (the most common location — this is where
+                               "claude mcp add -s user ..." writes)
+    Claude Code (this project) ~/.claude.json -> projects.<cwd>.mcpServers
+    Claude Desktop             ~/Library/Application Support/Claude/claude_desktop_config.json
+                               (macOS)  %APPDATA%\\Claude\\claude_desktop_config.json
+                               (Linux)  $XDG_CONFIG_HOME/Claude/claude_desktop_config.json
+
+  When the same name appears in both layers of ~/.claude.json, the
+  project-layer entry is treated as a per-project override (Claude's own
+  precedence) and is hidden from the picker — you'll only see the root
+  version, which is the one that applies across projects.
+
+  Use the /migrate slash command in the TUI for an interactive picker.`);
 }
 /** Handle `orbcode mcp ...`. Returns the process exit code. */
 export async function runMcpCommand(args) {
@@ -65,6 +93,9 @@ export async function runMcpCommand(args) {
         case "list":
         case "ls":
             return runList(rest);
+        case "migrate":
+        case "import":
+            return runMigrate(rest);
         case "help":
         case "--help":
         case "-h":
@@ -264,3 +295,120 @@ function runList(_args) {
     }
     return 0;
 }
+/** `orbcode mcp migrate [--all] [--dry-run]` — copy MCP servers from Claude
+ *  Code / Claude Desktop into `~/.orbcode/settings.json` (user scope).
+ *  Without `--all`, prints a preview and exits 0. `--dry-run` is a read-only
+ *  preview even with `--all`. Name conflicts are silently skipped. */
+function runMigrate(args) {
+    let migrateAll = false;
+    let dryRun = false;
+    for (const arg of args) {
+        if (arg === "--all" || arg === "-a")
+            migrateAll = true;
+        else if (arg === "--dry-run" || arg === "-n")
+            dryRun = true;
+        else if (arg === "--help" || arg === "-h") {
+            console.log("orbcode mcp migrate [--all] [--dry-run]\n");
+            console.log("Import MCP servers from Claude Code / Claude Desktop into");
+            console.log("~/.orbcode/settings.json (user scope).");
+            console.log("");
+            console.log("  --all, -a      import every detected server (default: preview only)");
+            console.log("  --dry-run, -n  show what would be imported, never write");
+            return 0;
+        }
+        else {
+            console.error(`Unknown flag: ${arg}. Try: orbcode mcp migrate --help`);
+            return 1;
+        }
+    }
+    const sources = discoverSources();
+    if (sources.length === 0) {
+        console.log("No MCP server sources found on this machine.");
+        console.log("");
+        console.log("Searched:");
+        console.log("  - ~/.claude/settings.json          (Claude Code, user scope)");
+        console.log("  - ~/.claude.json -> root mcpServers (Claude Code, user scope)");
+        console.log("  - ~/.claude.json -> projects.<cwd>.mcpServers (Claude Code, this project)");
+        console.log("  - Claude Desktop config            (claude_desktop_config.json)");
+        return 0;
+    }
+    const entries = listMigrationEntries();
+    if (entries.length === 0) {
+        console.log("Found MCP server source files, but none contain server entries.");
+        return 0;
+    }
+    // Always show what we found, so the user knows where the data is coming from.
+    console.log("Detected MCP server sources:");
+    for (const source of sources) {
+        const count = Object.keys(source.servers).length;
+        console.log(`  ${source.label.padEnd(28)} ${count} server${count === 1 ? "" : "s"}`);
+        console.log(`    ${source.configPath}`);
+    }
+    console.log("");
+    // If `--all` was passed, copy everything. Otherwise preview and exit.
+    const toApply = migrateAll ? entries : [];
+    // Always classify skipped (name conflicts) so the user sees the dry-run
+    // impact, not just the would-be additions.
+    const { skipped } = applyMigrationDryRun(entries);
+    if (!migrateAll) {
+        console.log("Preview — no files modified. Pass --all to apply.");
+        console.log("");
+        console.log("Servers that would be imported:");
+        for (const entry of entries) {
+            const conflict = skipped.some((s) => s.entry.key === entry.key);
+            const tag = conflict ? "skip" : "add ";
+            console.log(`  [${tag}] ${entry.name.padEnd(24)} ${describeEntry(entry)}`);
+            console.log(`          ${entry.sourceLabel}`);
+        }
+        console.log("");
+        console.log(`Would add:    ${entries.length - skipped.length}`);
+        console.log(`Would skip:   ${skipped.length} (already exists in destination)`);
+        return 0;
+    }
+    // migrateAll path. If also --dry-run, don't write.
+    if (dryRun) {
+        console.log("Dry run — no files modified.");
+        console.log("");
+        console.log("Servers that would be imported:");
+        for (const entry of toApply) {
+            const conflict = skipped.some((s) => s.entry.key === entry.key);
+            const tag = conflict ? "skip" : "add ";
+            console.log(`  [${tag}] ${entry.name.padEnd(24)} ${describeEntry(entry)}`);
+            console.log(`          ${entry.sourceLabel}`);
+        }
+        console.log("");
+        console.log(`Would add:    ${toApply.length - skipped.length}`);
+        console.log(`Would skip:   ${skipped.length} (already exists in destination)`);
+        return 0;
+    }
+    const result = applyMigration(toApply);
+    console.log(`Added ${result.added.length} MCP server${result.added.length === 1 ? "" : "s"} to ~/.orbcode/settings.json`);
+    for (const entry of result.added) {
+        console.log(`  + ${entry.name.padEnd(24)} ${describeEntry(entry)}`);
+    }
+    if (result.skipped.length > 0) {
+        console.log(`Skipped ${result.skipped.length} (already exists):`);
+        for (const { entry, reason } of result.skipped) {
+            console.log(`  - ${entry.name.padEnd(24)} ${reason}`);
+        }
+    }
+    return 0;
+}
+/** Pure classification pass that mirrors `applyMigration` but never writes.
+ *  Used by `--dry-run` and the default preview to surface the skipped count
+ *  without touching the file. */
+function applyMigrationDryRun(entries) {
+    const settings = loadSettings();
+    const existing = settings.mcpServers ?? {};
+    const added = [];
+    const skipped = [];
+    for (const entry of entries) {
+        if (entry.name in existing) {
+            skipped.push({ entry, reason: "already exists in ~/.orbcode/settings.json" });
+        }
+        else {
+            added.push(entry.key);
+        }
+    }
+    return { added, skipped };
+}

package/dist/commands/migrate.js

@@ -0,0 +1,333 @@
+/**
+ * Migrate MCP server configurations from other CLI tools into OrbCode's
+ * `~/.orbcode/settings.json` (user scope, `mcpServers` block).
+ *
+ * Detected sources:
+ *   - Claude Code user-scope:   `~/.claude/settings.json` -> mcpServers
+ *   - Claude Code (user, top of ~/.claude.json): same file, root `mcpServers`.
+ *     Claude stores the user-scope servers here, at the file root, not under
+ *     a per-project key. This is the most common location on a fresh install
+ *     — `claude mcp add -s user …` writes to it.
+ *   - Claude Code per-project:  `~/.claude.json` -> projects.<cwd>.mcpServers
+ *     (and a fallback to the first project entry that has any servers, for
+ *     mismatched cwd paths).
+ *   - Claude Desktop:           `claude_desktop_config.json` (platform path)
+ *
+ * Both the TUI (`/migrate`) and the CLI (`orbcode mcp migrate`) call into this
+ * module. The TUI lets the user pick a subset; the CLI either does a dry-run
+ * preview or copies everything that doesn't conflict.
+ *
+ * Conflict policy: if a server with the same name already exists in the
+ * destination, the incoming entry is silently dropped. The summary at the
+ * end reports the skipped count.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { getConfigDir, loadSettings } from "../config/settings.js";
+/** A safe label for the picker (one per source). */
+function sourceLabel(id) {
+    switch (id) {
+        case "claude-code-user":
+            return "Claude Code (user)";
+        case "claude-code-json-user":
+            return "Claude Code (user, ~/.claude.json)";
+        case "claude-code-project":
+            return "Claude Code (this project)";
+        case "claude-desktop":
+            return "Claude Desktop";
+    }
+}
+/** Cross-platform location of Claude Desktop's MCP config file. */
+function claudeDesktopConfigPath() {
+    const home = os.homedir();
+    if (process.platform === "darwin") {
+        return path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    }
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+        return path.join(appData, "Claude", "claude_desktop_config.json");
+    }
+    // Linux/WSL — best-effort XDG location; Claude Desktop doesn't have an
+    // official Linux build, but some forks (e.g. open-source wrappers) use it.
+    const xdg = process.env.XDG_CONFIG_HOME || path.join(home, ".config");
+    return path.join(xdg, "Claude", "claude_desktop_config.json");
+}
+function readJson(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Normalize a single MCP server config from an external source. We do not run
+ * the full `normalizeServerConfig` from `mcp/config.ts` because it has side
+ * effects (env expansion) and Claude's shape is already a subset of ours.
+ * Only stdio / http / sse entries with the required fields survive.
+ */
+function normalizeExternalServer(raw) {
+    if (!isPlainObject(raw))
+        return undefined;
+    const type = typeof raw.type === "string" ? raw.type : "stdio";
+    if (type === "stdio") {
+        if (typeof raw.command !== "string" || !raw.command.trim())
+            return undefined;
+        const config = {
+            type: "stdio",
+            command: raw.command,
+        };
+        if (Array.isArray(raw.args)) {
+            const args = raw.args.filter((a) => typeof a === "string");
+            if (args.length > 0)
+                config.args = args;
+        }
+        if (isPlainObject(raw.env)) {
+            const env = {};
+            for (const [k, v] of Object.entries(raw.env)) {
+                if (typeof v === "string")
+                    env[k] = v;
+            }
+            if (Object.keys(env).length > 0)
+                config.env = env;
+        }
+        return config;
+    }
+    if (type === "http" || type === "sse") {
+        if (typeof raw.url !== "string" || !raw.url.trim())
+            return undefined;
+        const config = {
+            type,
+            url: raw.url,
+        };
+        if (isPlainObject(raw.headers)) {
+            const headers = {};
+            for (const [k, v] of Object.entries(raw.headers)) {
+                if (typeof v === "string")
+                    headers[k] = v;
+            }
+            if (Object.keys(headers).length > 0)
+                config.headers = headers;
+        }
+        return config;
+    }
+    // `streamable-http` is Claude Code's preferred name for the modern HTTP
+    // transport; OrbCode aliases it as "http".
+    if (type === "streamable-http" || type === "streamable_http") {
+        if (typeof raw.url !== "string" || !raw.url.trim())
+            return undefined;
+        const config = { type: "http", url: raw.url };
+        if (isPlainObject(raw.headers)) {
+            const headers = {};
+            for (const [k, v] of Object.entries(raw.headers)) {
+                if (typeof v === "string")
+                    headers[k] = v;
+            }
+            if (Object.keys(headers).length > 0)
+                config.headers = headers;
+        }
+        return config;
+    }
+    return undefined;
+}
+/** Read a `mcpServers` block, skipping any entry that fails to normalize. */
+function readMcpServers(filePath) {
+    const json = readJson(filePath);
+    if (!json)
+        return {};
+    const block = json.mcpServers;
+    if (!isPlainObject(block))
+        return {};
+    const out = {};
+    for (const [name, raw] of Object.entries(block)) {
+        if (!/^[A-Za-z0-9_-]+$/.test(name))
+            continue;
+        const config = normalizeExternalServer(raw);
+        if (config)
+            out[name] = config;
+    }
+    return out;
+}
+/** Pull the user-scope MCP servers Claude Code stores at the top level of
+ *  `~/.claude.json`. This is where `claude mcp add -s user …` writes — the
+ *  root `mcpServers` block on the same file that also holds per-project
+ *  entries under `projects.<path>`. */
+function readClaudeCodeRootServers() {
+    const json = readJson(path.join(os.homedir(), ".claude.json"));
+    if (!json)
+        return {};
+    return readMcpServersFromObject(json);
+}
+/** Pull the per-project MCP servers Claude Code stores in `~/.claude.json`. */
+function readClaudeCodeProjectServers() {
+    const json = readJson(path.join(os.homedir(), ".claude.json"));
+    if (!json)
+        return {};
+    const projects = json.projects;
+    if (!isPlainObject(projects))
+        return {};
+    const cwd = process.cwd();
+    // Prefer the cwd entry, fall back to the first project entry that has
+    // any servers (helps when the cwd path doesn't match exactly, e.g. a
+    // symlinked or differently-cased home directory).
+    const entries = Object.entries(projects).filter((entry) => isPlainObject(entry[1]));
+    const direct = entries.find(([projectPath]) => projectPath === cwd);
+    const fallback = entries.find(([, project]) => isPlainObject(project.mcpServers));
+    const target = direct ?? fallback;
+    if (!target)
+        return {};
+    return readMcpServersFromObject(target[1]);
+}
+/** Same as `readMcpServers` but takes a pre-parsed object. */
+function readMcpServersFromObject(obj) {
+    const block = obj.mcpServers;
+    if (!isPlainObject(block))
+        return {};
+    const out = {};
+    for (const [name, raw] of Object.entries(block)) {
+        if (!/^[A-Za-z0-9_-]+$/.test(name))
+            continue;
+        const config = normalizeExternalServer(raw);
+        if (config)
+            out[name] = config;
+    }
+    return out;
+}
+/** Discover every available migration source on the current machine. */
+export function discoverSources() {
+    const sources = [];
+    const claudeCodeUserPath = path.join(os.homedir(), ".claude", "settings.json");
+    const claudeCodeUserServers = readMcpServers(claudeCodeUserPath);
+    if (Object.keys(claudeCodeUserServers).length > 0) {
+        sources.push({
+            id: "claude-code-user",
+            label: sourceLabel("claude-code-user"),
+            configPath: claudeCodeUserPath,
+            servers: claudeCodeUserServers,
+        });
+    }
+    // ~/.claude.json can hold entries in two layers: the root mcpServers block
+    // (user-scope, written by `claude mcp add -s user …`) and per-project
+    // entries under `projects.<path>.mcpServers`. Both can define a server with
+    // the same name; Claude treats the per-project one as the override. To
+    // avoid showing the same name twice in the picker, we collect both layers
+    // and drop any project-layer name that the root layer also has.
+    const claudeCodeJsonPath = path.join(os.homedir(), ".claude.json");
+    const rootServers = readClaudeCodeRootServers();
+    const projectServers = readClaudeCodeProjectServers();
+    const rootNames = new Set(Object.keys(rootServers));
+    if (Object.keys(rootServers).length > 0) {
+        sources.push({
+            id: "claude-code-json-user",
+            label: sourceLabel("claude-code-json-user"),
+            configPath: claudeCodeJsonPath,
+            servers: rootServers,
+        });
+    }
+    if (Object.keys(projectServers).length > 0) {
+        const deduped = {};
+        for (const [name, cfg] of Object.entries(projectServers)) {
+            if (rootNames.has(name))
+                continue;
+            deduped[name] = cfg;
+        }
+        if (Object.keys(deduped).length > 0) {
+            sources.push({
+                id: "claude-code-project",
+                label: sourceLabel("claude-code-project"),
+                configPath: claudeCodeJsonPath,
+                servers: deduped,
+            });
+        }
+    }
+    const claudeDesktopPath = claudeDesktopConfigPath();
+    const claudeDesktopServers = readMcpServers(claudeDesktopPath);
+    if (Object.keys(claudeDesktopServers).length > 0) {
+        sources.push({
+            id: "claude-desktop",
+            label: sourceLabel("claude-desktop"),
+            configPath: claudeDesktopPath,
+            servers: claudeDesktopServers,
+        });
+    }
+    return sources;
+}
+/** Flatten all sources into a single checklist. Stable order: source first,
+ *  then server name. */
+export function listMigrationEntries() {
+    const entries = [];
+    for (const source of discoverSources()) {
+        for (const [name, config] of Object.entries(source.servers)) {
+            entries.push({
+                key: `${source.id}::${name}`,
+                source: source.id,
+                sourceLabel: source.label,
+                name,
+                config,
+            });
+        }
+    }
+    return entries;
+}
+/** Short summary of a server for the picker / dry-run output. */
+export function describeEntry(entry) {
+    const cfg = entry.config;
+    if (cfg.type === "http" || cfg.type === "sse") {
+        return `${cfg.type} ${cfg.url}`;
+    }
+    const args = cfg.args ?? [];
+    return `stdio ${cfg.command}${args.length ? " " + args.join(" ") : ""}`;
+}
+/** True when `name` already exists in the user-scope mcpServers block of
+ *  OrbCode's settings. This is the only conflict that matters — the CLI and
+ *  TUI both target user scope. */
+function destinationHas(name) {
+    const settings = loadSettings();
+    return Boolean(settings.mcpServers && name in settings.mcpServers);
+}
+/**
+ * Apply a set of migration entries to `~/.orbcode/settings.json` (user scope).
+ * Returns the new entries plus the entries that were skipped (with a reason).
+ */
+export function applyMigration(entries) {
+    const filePath = path.join(getConfigDir(), "settings.json");
+    const existing = readJson(filePath) ?? {};
+    const servers = isPlainObject(existing.mcpServers)
+        ? { ...existing.mcpServers }
+        : {};
+    const added = [];
+    const skipped = [];
+    for (const entry of entries) {
+        if (entry.name in servers) {
+            skipped.push({
+                entry,
+                reason: "already exists in ~/.orbcode/settings.json",
+            });
+            continue;
+        }
+        if (destinationHas(entry.name)) {
+            // Race-safe double-check: the in-memory snapshot is the source of
+            // truth at write time, so if it changed between our read and now
+            // we still skip.
+            skipped.push({
+                entry,
+                reason: "already exists in ~/.orbcode/settings.json",
+            });
+            continue;
+        }
+        servers[entry.name] = entry.config;
+        added.push(entry);
+    }
+    if (added.length > 0) {
+        existing.mcpServers = servers;
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, JSON.stringify(existing, null, "\t") + "\n", {
+            mode: 0o600,
+        });
+    }
+    return { added, skipped };
+}

package/dist/index.js

@@ -19,6 +19,7 @@ Usage:
   orbcode mcp add ...     add an MCP server (see: orbcode mcp help)
   orbcode mcp remove ...  remove an MCP server
   orbcode mcp list        list configured MCP servers
+  orbcode mcp migrate     import MCP servers from Claude Code / Claude Desktop
   orbcode -p "<prompt>"   run a single prompt non-interactively (prints only the final response)
   orbcode -p "…" --yolo   non-interactive with auto-approved edits/commands
   orbcode --model <id>    use a specific model for this run

package/dist/mcp/auth.js

@@ -153,7 +153,8 @@ function startCallbackServer(port, onCode) {
     const server = http.createServer((req, res) => {
         const url = new URL(req.url ?? "/", `http://localhost:${port}`);
         if (url.pathname !== "/callback") {
-            res.writeHead(404).end("not found");
+            res.writeHead(404, { "Content-Type": "text/html" });
+            res.end(callbackPage("not-found"));
             return;
         }
         const code = url.searchParams.get("code");
@@ -161,15 +162,16 @@ function startCallbackServer(port, onCode) {
         if (code) {
             onCode(code);
             res.writeHead(200, { "Content-Type": "text/html" });
-            res.end("<h1>Authorized</h1><p>You can close this tab and return to OrbCode.</p>");
+            res.end(callbackPage("success"));
         }
         else if (error) {
+            const desc = url.searchParams.get("error_description") ?? error;
             res.writeHead(400, { "Content-Type": "text/html" });
-            res.end(`<h1>Authorization failed</h1><p>${error}</p>`);
+            res.end(callbackPage("error", desc));
         }
         else {
             res.writeHead(400, { "Content-Type": "text/html" });
-            res.end("<h1>Missing code</h1>");
+            res.end(callbackPage("error", "Missing authorization code in the callback."));
         }
         // Close after responding so the port is freed immediately.
         server.close();
@@ -177,6 +179,88 @@ function startCallbackServer(port, onCode) {
     server.listen(port, "127.0.0.1");
     return server;
 }
+/** Render the OAuth callback page. Styled to match matterai.so: dark
+ *  background, cyan/teal accents, centered card, clean typography. */
+function callbackPage(kind, detail) {
+    const isSuccess = kind === "success";
+    const title = isSuccess ? "Authorized" : kind === "not-found" ? "Not Found" : "Authorization Failed";
+    const message = isSuccess
+        ? "You can close this tab and return to OrbCode."
+        : kind === "not-found"
+            ? "This page was not found."
+            : detail ?? "An unexpected error occurred during authentication.";
+    const icon = isSuccess ? "&#10003;" : "&#10007;";
+    const accent = isSuccess ? "#43df94" : "#e86464";
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>OrbCode &middot; ${title}</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif;
+    background: #0d1117;
+    color: #e6edf3;
+    min-height: 100vh;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    -webkit-font-smoothing: antialiased;
+  }
+  .card {
+    text-align: center;
+    padding: 3rem 2.5rem;
+    max-width: 440px;
+    width: 90%;
+  }
+  .icon {
+    width: 72px;
+    height: 72px;
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    margin: 0 auto 1.75rem;
+    font-size: 36px;
+    font-weight: 700;
+    background: ${accent}1a;
+    border: 2px solid ${accent};
+    color: ${accent};
+  }
+  h1 {
+    font-size: 1.6rem;
+    font-weight: 600;
+    letter-spacing: -0.02em;
+    margin-bottom: 0.6rem;
+  }
+  p {
+    font-size: 0.95rem;
+    line-height: 1.5;
+    color: #8b949e;
+    margin-bottom: 2rem;
+  }
+  .brand {
+    margin-top: 2.5rem;
+    font-size: 0.8rem;
+    color: #484f58;
+    letter-spacing: 0.05em;
+    text-transform: uppercase;
+  }
+  .brand span { color: #c4fdff; }
+</style>
+</head>
+<body>
+  <div class="card">
+    <div class="icon">${icon}</div>
+    <h1>${title}</h1>
+    <p>${message}</p>
+    <div class="brand">OrbCode CLI &middot; <span>powered by Axon</span></div>
+  </div>
+</body>
+</html>`;
+}
 /** Pick an ephemeral loopback port for the callback server. */
 function ephemeralPort() {
     // Bind to port 0 and read back the assigned port, then close immediately.

package/dist/mcp/manager.js

@@ -1,5 +1,5 @@
 import { callMcpTool, connectMcpServer } from "./client.js";
-import { configPathForScope, loadMcpConfig } from "./config.js";
+import { configPathForScope, loadMcpConfig, removeMcpServerAnyScope } from "./config.js";
 import { hasStoredAuth, isOAuthConfig } from "./auth.js";
 /**
  * Owns the lifecycle of all MCP server connections for a session.
@@ -154,6 +154,20 @@ export class McpManager {
             state.disabled = true;
         await this.disconnectOne(name);
     }
+    /** Permanently remove a server: disconnect, drop from the in-memory
+     *  config/state, and remove from the on-disk config (whichever scope it
+     *  lives in). Returns true if a config entry was actually removed. The
+     *  caller is responsible for re-persisting the enabled/disabled lists
+     *  (which no longer reference the removed name). */
+    async removeServer(name) {
+        await this.disconnectOne(name);
+        this.disabled.delete(name);
+        this.enabled.delete(name);
+        this.pendingApproval.delete(name);
+        this.configs.delete(name);
+        this.states.delete(name);
+        return removeMcpServerAnyScope(this.cwd, name) !== undefined;
+    }
     /** Re-authenticate a server in the needs-auth state: disconnect, clear
      *  persisted OAuth tokens, then reconnect with `forceOAuth` so even servers
      *  without an explicit `oauth` config use the OAuth flow (auto-detect).

package/dist/ui/App.js

@@ -16,6 +16,8 @@ import { FollowupPrompt } from "./components/FollowupPrompt.js";
 import { HookTrustPrompt } from "./components/HookTrustPrompt.js";
 import { McpApprovalPrompt } from "./components/McpApprovalPrompt.js";
 import { McpPicker } from "./components/McpPicker.js";
+import { McpMigrationPicker } from "./components/McpMigrationPicker.js";
+import { applyMigration, listMigrationEntries } from "../commands/migrate.js";
 import { StatusBar } from "./components/StatusBar.js";
 import { ModelPicker } from "./components/ModelPicker.js";
 import { SessionPicker } from "./components/SessionPicker.js";
@@ -48,6 +50,10 @@ const SLASH_COMMANDS = [
         name: "/mcp",
         description: "manage MCP servers — enable, disable, reconnect, view status",
     },
+    {
+        name: "/migrate",
+        description: "import MCP servers from Claude Code / Claude Desktop",
+    },
     {
         name: "/commit",
         description: "check pending changes and create detailed commits",
@@ -193,6 +199,10 @@ export function App({ initialView, initialPrompt, initialSession, systemPromptOv
     // the first agent is created so we don't spawn servers before login.
     const mcpManagerRef = useRef(null);
     const [mcpPickerOpen, setMcpPickerOpen] = useState(false);
+    // Set when /migrate is open. Holds the entries to show in the picker; null
+    // means the picker isn't open. We cache the entries on first open so the
+    // picker shows a stable list even if the user cancels and reopens.
+    const [mcpMigrationEntries, setMcpMigrationEntries] = useState(null);
     // Project-scope MCP servers awaiting the user's approval at startup.
     const [pendingMcpApproval, setPendingMcpApproval] = useState(null);
     const [staticKey, setStaticKey] = useState(0);
@@ -645,6 +655,13 @@ export function App({ initialView, initialPrompt, initialSession, systemPromptOv
                 setMcpPickerOpen(true);
                 break;
             }
+            case "/migrate": {
+                // Scan for sources now (cheap — just file reads) and cache the list
+                // so the picker has a stable view. `applyMigration` re-reads the
+                // destination on confirm, so a stale snapshot is fine.
+                setMcpMigrationEntries(listMigrationEntries());
+                break;
+            }
             case "/commit":
                 if (!getAuthToken(settings)) {
                     setView("login");
@@ -787,6 +804,82 @@ export function App({ initialView, initialPrompt, initialSession, systemPromptOv
         if (deferred)
             handleSubmit(deferred);
     }, [handleSubmit, pushRow]);
+    // Tear down the live MCP manager (if any), then create a fresh one from
+    // the current on-disk settings and start it. Used after /migrate (new
+    // servers added) and after a /mcp delete (server removed) so /mcp works
+    // immediately without needing to send a message first. The agent is also
+    // dropped so the next message rebuilds it against the new manager's tool
+    // list.
+    const rebuildMcpManager = useCallback(async () => {
+        const oldManager = mcpManagerRef.current;
+        mcpManagerRef.current = null;
+        if (oldManager) {
+            await oldManager.stop().catch(() => { });
+        }
+        agentRef.current = null;
+        const refreshed = loadSettings();
+        setSettings(refreshed);
+        if (getAuthToken(refreshed)) {
+            const manager = new McpManager(process.cwd(), refreshed.disabledMcpServers ?? [], refreshed.enabledMcpServers ?? []);
+            mcpManagerRef.current = manager;
+            void manager.start().then(() => {
+                const pendingMcp = manager.getPendingApproval();
+                if (pendingMcp.length > 0)
+                    setPendingMcpApproval(pendingMcp);
+            });
+        }
+    }, []);
+    // Apply a user-confirmed migration selection: write the chosen entries to
+    // ~/.orbcode/settings.json, then rebuild the MCP manager so the new
+    // user-scope servers connect immediately. Skips (name conflicts)
+    // are reported but not fatal.
+    const resolveMcpMigration = useCallback(async (selected) => {
+        if (selected.length === 0) {
+            pushRow({ kind: "info", text: "MCP migration cancelled (no servers selected)." });
+            return;
+        }
+        const result = applyMigration(selected);
+        const addedNames = result.added.map((e) => e.name);
+        const skippedCount = result.skipped.length;
+        if (result.added.length === 0) {
+            pushRow({
+                kind: "info",
+                text: `MCP migration: nothing added (${skippedCount} skipped — name${skippedCount === 1 ? "" : "s"} already in use).`,
+            });
+            return;
+        }
+        pushRow({
+            kind: "info",
+            text: `MCP migration: added ${result.added.length} server${result.added.length === 1 ? "" : "s"} to ~/.orbcode/settings.json (${addedNames.join(", ")})${skippedCount > 0 ? `; skipped ${skippedCount} (name already in use).` : "."}`,
+        });
+        // Tear down the live manager + agent, then immediately rebuild the
+        // manager so /mcp works without needing to send a message first.
+        // The agent is dropped so the next message creates a fresh one that
+        // picks up the new manager's tool list.
+        await rebuildMcpManager();
+    }, [pushRow, rebuildMcpManager]);
+    // Handle a permanent delete from the /mcp picker. The manager has already
+    // dropped the server from its in-memory state and from the on-disk config;
+    // we persist the cleaned enabled/disabled lists, rebuild the manager so
+    // /mcp reflects the deletion immediately, and surface a one-line
+    // confirmation.
+    const handleMcpServerDeleted = useCallback(async (name) => {
+        const manager = mcpManagerRef.current;
+        if (manager) {
+            // `removeServer` already removed the name from both lists, but
+            // `saveMcpApproval` needs the post-removal snapshot so the
+            // per-project settings don't keep a dangling reference.
+            saveMcpApproval(process.cwd(), manager.getEnabled(), manager.getDisabled());
+        }
+        pushRow({
+            kind: "info",
+            text: `MCP: removed "${name}" from the config. Use \`orbcode mcp add ${name} …\` to re-add it.`,
+        });
+        // Rebuild the manager from the now-trimmed on-disk config so /mcp
+        // works immediately and the next message gets a fresh agent with the
+        // correct tool list.
+        await rebuildMcpManager();
+    }, [pushRow, rebuildMcpManager]);
     // Apply --resume and an initial prompt (`orbcode "do something"`) on startup.
     const bootedRef = useRef(false);
     useEffect(() => {
@@ -901,6 +994,7 @@ export function App({ initialView, initialPrompt, initialSession, systemPromptOv
         !pendingMcpApproval &&
         !modelPickerOpen &&
         !mcpPickerOpen &&
+        !mcpMigrationEntries &&
         !resumableSessions;
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: rows, children: (row) => _jsx(RowView, { row: row }, row.id) }, staticKey), view === "login" ? (_jsx(LoginSection, { onLogin: handleLogin })) : (_jsxs(Box, { flexDirection: "column", children: [updateInfo?.updateAvailable && updateInfo.latest && (_jsxs(Box, { marginTop: 1, flexDirection: "column", borderStyle: "round", borderColor: COLORS.warning, paddingX: 2, alignSelf: "flex-start", children: [_jsxs(Text, { color: COLORS.warning, bold: true, children: ["\u2191 Update available: v", updateInfo.current, " \u2192 v", updateInfo.latest] }), _jsxs(Text, { children: ["Run ", _jsx(Text, { color: COLORS.accent, children: "orbcode update" }), " to install the latest version, then relaunch."] })] })), streamingReasoning && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: COLORS.thinking, italic: true, children: "\u2726 Thinking\u2026" }), _jsx(Box, { paddingLeft: 2, children: _jsx(Text, { dimColor: true, italic: true, children: tail(streamingReasoning, expandReasoningRef.current ? 30 : 3) }) })] })), streamingText && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [_jsx(Text, { color: COLORS.primary, children: "\u25CF " }), streamingText] }) })), taskLines.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, paddingLeft: 1, children: [_jsx(Text, { dimColor: true, bold: true, children: "Tasks" }), taskLines.slice(0, 10).map((line, i) => (_jsx(Text, { dimColor: /^[-*]\s*\[x\]/i.test(line), children: line
                                     .replace(/^[-*]\s*\[x\]/i, "  ■")
@@ -912,7 +1006,10 @@ export function App({ initialView, initialPrompt, initialSession, systemPromptOv
                                 const m = mcpManagerRef.current;
                                 if (m)
                                     saveMcpApproval(process.cwd(), m.getEnabled(), m.getDisabled());
-                            }, onCancel: () => setMcpPickerOpen(false) }) })), pendingApproval && (_jsx(Box, { marginTop: 1, children: _jsx(ApprovalPrompt, { request: pendingApproval.request, onDecision: (decision) => {
+                            }, onCancel: () => setMcpPickerOpen(false), onDeleted: handleMcpServerDeleted }) })), mcpMigrationEntries && (_jsx(Box, { marginTop: 1, children: _jsx(McpMigrationPicker, { entries: mcpMigrationEntries, onCancel: () => setMcpMigrationEntries(null), onConfirm: (selected) => {
+                                setMcpMigrationEntries(null);
+                                resolveMcpMigration(selected);
+                            } }) })), pendingApproval && (_jsx(Box, { marginTop: 1, children: _jsx(ApprovalPrompt, { request: pendingApproval.request, onDecision: (decision) => {
                                 pendingApproval.resolve(decision);
                                 setPendingApproval(null);
                             } }) })), pendingFollowup && (_jsx(Box, { marginTop: 1, children: _jsx(FollowupPrompt, { question: pendingFollowup.question, suggestions: pendingFollowup.suggestions, onAnswer: (answer) => {
@@ -925,6 +1022,7 @@ export function App({ initialView, initialPrompt, initialSession, systemPromptOv
                         !pendingHookTrust &&
                         !pendingMcpApproval &&
                         !mcpPickerOpen &&
+                        !mcpMigrationEntries &&
                         !streamingText &&
                         !streamingReasoning && (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: busyLabel }) })), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [queuedMessages.length > 0 && (_jsxs(Box, { flexDirection: "column", paddingLeft: 1, marginBottom: 1, children: [_jsxs(Text, { dimColor: true, bold: true, children: ["Queue (", queuedMessages.length, ")"] }), queuedMessages.slice(0, 5).map((msg, i) => (_jsxs(Text, { dimColor: true, children: [i + 1, ". ", truncateForQueue(msg).replace(/\n/g, "↵")] }, i))), queuedMessages.length > 5 && (_jsxs(Text, { dimColor: true, children: [" \u2026 ", queuedMessages.length - 5, " more"] }))] })), _jsx(InputBox, { active: inputActive, slashCommands: SLASH_COMMANDS, onSubmit: handleSubmit }), _jsx(StatusBar, { modelId: settings.model, contextTokens: contextTokens, totalCost: totalCost, state: busy ? busyLabel : "", approvalMode: approvalMode, busy: busy, title: sessionTitle, plan: usage?.plan, usagePercentage: usage?.usagePercentage, tieredUsage: usage?.tieredUsage })] })] }))] }));
 }

package/dist/ui/components/McpMigrationPicker.js

@@ -0,0 +1,66 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { COLORS } from "../../branding.js";
+import { describeEntry } from "../../commands/migrate.js";
+const VISIBLE_ROWS = 10;
+/**
+ * Combined checklist of all detected MCP servers across Claude Code (user),
+ * Claude Code (this project), and Claude Desktop. Each row shows the source
+ * as a dim label. Space toggles, enter confirms, esc cancels.
+ *
+ * Default state: every entry pre-checked, matching the CLI's `--all` flag.
+ * The user unchecks the ones they don't want; the confirmation runs the
+ * real `applyMigration` and reports the skipped count from conflicts.
+ */
+export function McpMigrationPicker({ entries, onConfirm, onCancel, }) {
+    const [selected, setSelected] = useState(0);
+    const [checked, setChecked] = useState(() => new Set(entries.map((e) => e.key)));
+    useInput((input, key) => {
+        if (key.escape) {
+            onCancel();
+            return;
+        }
+        if (key.upArrow) {
+            setSelected((s) => (s - 1 + entries.length) % entries.length);
+            return;
+        }
+        if (key.downArrow || key.tab) {
+            setSelected((s) => (s + 1) % entries.length);
+            return;
+        }
+        if (key.return) {
+            const picked = [];
+            for (const entry of entries) {
+                if (checked.has(entry.key))
+                    picked.push(entry);
+            }
+            onConfirm(picked);
+            return;
+        }
+        if (input === " ") {
+            const entry = entries[selected];
+            if (!entry)
+                return;
+            setChecked((prev) => {
+                const next = new Set(prev);
+                if (next.has(entry.key))
+                    next.delete(entry.key);
+                else
+                    next.add(entry.key);
+                return next;
+            });
+        }
+    });
+    if (entries.length === 0) {
+        return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: COLORS.primary, paddingX: 1, children: [_jsx(Text, { bold: true, color: COLORS.primary, children: "Migrate MCP servers" }), _jsx(Text, { dimColor: true, children: "No MCP servers found on this machine to migrate." }), _jsx(Text, { dimColor: true, children: "Install Claude Code or Claude Desktop, or add servers with `orbcode mcp add`." }), _jsx(Text, { dimColor: true, children: "esc to close" })] }));
+    }
+    const count = entries.length;
+    const windowStart = Math.max(0, Math.min(selected - VISIBLE_ROWS + 1, count - VISIBLE_ROWS));
+    const visible = entries.slice(windowStart, windowStart + VISIBLE_ROWS);
+    const checkedCount = entries.reduce((n, e) => (checked.has(e.key) ? n + 1 : n), 0);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: COLORS.primary, paddingX: 1, children: [_jsx(Text, { bold: true, color: COLORS.primary, children: "Migrate MCP servers from Claude Code / Desktop" }), _jsx(Text, { dimColor: true, children: "Servers will be copied to ~/.orbcode/settings.json. Conflicts (same name already exists) are skipped." }), windowStart > 0 && _jsxs(Text, { dimColor: true, children: [" \u2191 ", windowStart, " more"] }), visible.map((entry, i) => {
+                const isSelected = windowStart + i === selected;
+                return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: isSelected ? COLORS.accent : undefined, children: [isSelected ? "❯ " : "  ", checked.has(entry.key) ? "☑" : "☐", " ", entry.name, _jsxs(Text, { dimColor: true, children: [" \u00B7 ", describeEntry(entry)] })] }), _jsx(Box, { paddingLeft: 5, children: _jsx(Text, { dimColor: true, children: entry.sourceLabel }) })] }, entry.key));
+            }), windowStart + VISIBLE_ROWS < count && (_jsxs(Text, { dimColor: true, children: [" \u2193 ", count - windowStart - VISIBLE_ROWS, " more"] })), _jsxs(Text, { dimColor: true, children: ["space toggle \u00B7 enter confirm (", checkedCount, "/", count, ") \u00B7 esc cancel"] })] }));
+}

package/dist/ui/components/McpPicker.js

@@ -42,6 +42,11 @@ function buildActions(state) {
     else
         actions.push("Disable");
     actions.push("Reconnect");
+    // Delete is last so it's a deliberate choice past the everyday toggles.
+    // It's always available — disabling and re-enabling a server still leaves
+    // the config entry, which is the right behaviour when you might want it
+    // back. Delete is the explicit "I don't want this server here at all" path.
+    actions.push("Delete");
     return actions;
 }
 /**
@@ -52,9 +57,9 @@ function buildActions(state) {
  *   - Action menu: ↑/↓ to select an action, enter to execute, esc to go back.
  *
  * Actions adapt to the server's state: Authenticate (needs-auth), Enable
- * (disabled), Disable (connected/failed), Reconnect (always).
+ * (disabled), Disable (connected/failed), Reconnect (always), Delete (always).
  */
-export function McpPicker({ manager, onChanged, onCancel }) {
+export function McpPicker({ manager, onChanged, onCancel, onDeleted }) {
     const [snapshot, setSnapshot] = useState(() => manager.snapshot());
     const [selected, setSelected] = useState(0);
     const [busy, setBusy] = useState(false);
@@ -63,15 +68,51 @@ export function McpPicker({ manager, onChanged, onCancel }) {
     const [authUrl, setAuthUrl] = useState("");
     const [actionMode, setActionMode] = useState(false);
     const [actionSelected, setActionSelected] = useState(0);
+    // Pending destructive confirmation. The resolve ref unblocks the awaiting
+    // `deleteSelected` call when the user picks y/n at the prompt.
+    const [pendingConfirm, setPendingConfirm] = useState(null);
     const codeResolveRef = useRef(null);
     const codeRejectRef = useRef(null);
     const servers = snapshot.servers;
     const count = servers.length;
     const current = servers[selected];
     const actions = current ? buildActions(current) : [];
-    useInput((_input, key) => {
+    /** Show a yes/no confirmation and resolve when the user picks one. Used
+     *  for destructive actions like deleting a server. */
+    function confirmDangerousAction(title, body) {
+        return new Promise((resolve) => {
+            setPendingConfirm({ title, body, resolve });
+        });
+    }
+    useInput((input, key) => {
         if (authingServer || busy)
             return;
+        // A destructive confirmation is in flight. Eat every key except the
+        // explicit y/n + enter / esc — matches the rest of the picker's
+        // "no shorthand" rule.
+        if (pendingConfirm) {
+            if (key.escape) {
+                pendingConfirm.resolve(false);
+                setPendingConfirm(null);
+                return;
+            }
+            if (key.return) {
+                pendingConfirm.resolve(true);
+                setPendingConfirm(null);
+                return;
+            }
+            if (input === "y" || input === "Y") {
+                pendingConfirm.resolve(true);
+                setPendingConfirm(null);
+                return;
+            }
+            if (input === "n" || input === "N") {
+                pendingConfirm.resolve(false);
+                setPendingConfirm(null);
+                return;
+            }
+            return;
+        }
         if (actionMode) {
             if (key.escape) {
                 setActionMode(false);
@@ -126,6 +167,8 @@ export function McpPicker({ manager, onChanged, onCancel }) {
             await disableSelected();
         else if (action === "Reconnect")
             await reconnectSelected();
+        else if (action === "Delete")
+            await deleteSelected();
     }
     async function enableSelected() {
         if (!current)
@@ -155,6 +198,39 @@ export function McpPicker({ manager, onChanged, onCancel }) {
             setBusyMessage("");
         }
     }
+    async function deleteSelected() {
+        if (!current)
+            return;
+        const name = current.name;
+        // Pull the config path so the confirmation can show what file gets
+        // modified — without this, the user has to remember the scope rules.
+        const configPath = manager.getConfigPath(name) ?? "~/.orbcode/settings.json";
+        const confirmed = await confirmDangerousAction(`Delete MCP server "${name}"?`, `This removes the entry from ${configPath}. You'll have to re-add it manually.`);
+        if (!confirmed)
+            return;
+        setBusy(true);
+        setBusyMessage("Deleting…");
+        try {
+            const removed = await manager.removeServer(name);
+            if (!removed) {
+                // Race: someone else removed it between opening the picker and
+                // confirming. Refresh and bail — the user can see it's gone.
+                await refresh();
+                return;
+            }
+            // Move the cursor to a safe position before the snapshot shrinks.
+            // `setSelected` runs before the next render commits, so clamping
+            // here is correct.
+            const next = manager.snapshot().servers;
+            setSelected((s) => Math.min(s, Math.max(0, next.length - 1)));
+            onDeleted(name);
+            await refresh();
+        }
+        finally {
+            setBusy(false);
+            setBusyMessage("");
+        }
+    }
     async function reconnectSelected() {
         if (!current)
             return;
@@ -221,6 +297,9 @@ export function McpPicker({ manager, onChanged, onCancel }) {
     if (authingServer) {
         return (_jsx(McpAuthScreen, { serverName: authingServer, authUrl: authUrl, onPasteCode: handlePasteCode, onCancel: handleAuthCancel }));
     }
+    if (pendingConfirm) {
+        return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: COLORS.error, paddingX: 1, children: [_jsx(Text, { bold: true, color: COLORS.error, children: pendingConfirm.title }), _jsx(Text, { children: pendingConfirm.body }), _jsx(Text, { dimColor: true, children: "y confirm \u00B7 n / esc cancel" })] }));
+    }
     const windowStart = Math.max(0, Math.min(selected - VISIBLE_ROWS + 1, count - VISIBLE_ROWS));
     const visible = servers.slice(windowStart, windowStart + VISIBLE_ROWS);
     return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: COLORS.primary, paddingX: 1, children: [_jsxs(Text, { bold: true, color: COLORS.primary, children: ["Manage MCP servers (", count, ")"] }), windowStart > 0 && _jsxs(Text, { dimColor: true, children: ["  \u2191 ", windowStart, " more"] }), visible.map((state, i) => {
@@ -257,6 +336,16 @@ function DetailPanel({ manager, state, actions, actionMode, actionSelected, }) {
     }
     return (_jsxs(Box, { paddingLeft: 1, marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { bold: true, children: [state.name, " MCP Server"] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Status:          " }), _jsxs(Text, { color: statusColor(state), children: [statusIcon(state), " ", state.status] })] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Auth:            " }), _jsx(Text, { color: isOAuth && !authenticated ? COLORS.error : isOAuth ? COLORS.success : COLORS.dim, children: authText })] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "URL:             " }), urlText] }), configPath && (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Config location: " }), _jsx(Text, { dimColor: true, children: configPath })] })), state.detail && (_jsx(Text, { color: state.status === "failed" ? COLORS.error : state.status === "needs-auth" ? COLORS.warning : COLORS.dim, children: state.detail })), _jsx(Box, { marginTop: 1, flexDirection: "column", children: actions.map((action, i) => {
                     const isSelected = actionMode && i === actionSelected;
-                    return (_jsxs(Text, { color: isSelected ? COLORS.accent : undefined, children: [isSelected ? "❯ " : "  ", i + 1, ". ", action] }, action));
+                    // Color destructive actions red so they read differently
+                    // from the everyday toggles. Keeps the affordance visually
+                    // separate from the harmless enable/disable/reconnect
+                    // choices right above it.
+                    const isDestructive = action === "Delete";
+                    const color = isSelected
+                        ? COLORS.accent
+                        : isDestructive
+                            ? COLORS.error
+                            : undefined;
+                    return (_jsxs(Text, { color: color, children: [isSelected ? "❯ " : "  ", i + 1, ". ", action] }, action));
                 }) })] }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterailab/orbcode",
-  "version": "0.2.4",
+  "version": "0.3.1",
   "description": "OrbCode CLI — agentic coding in your terminal, powered by Axon models by MatterAI",
   "type": "module",
   "bin": {