@nonbot/cli 0.10.14 → 0.10.16

package/dist/commands/mcp.js

@@ -0,0 +1,409 @@
+import { spawnSync as nodeSpawnSync } from 'node:child_process';
+import { readFileSync, writeFileSync, copyFileSync, renameSync } from 'node:fs';
+import { createInterface } from 'node:readline/promises';
+import { homedir } from 'node:os';
+import { VERSION } from '../version.js';
+import { loadAuth } from '../lib/auth.js';
+import { header, statusRow, isTTY, ANSI } from '../lib/output.js';
+import { scanMcpConfigs, launchSpecOf, LEGACY_MCP_NAMES, } from '../lib/mcp-config.js';
+import { nonbotMcpStatuses, mcpRow } from '../lib/mcp-status.js';
+import { probeMcp, toolGroups, estimateTokens } from '../lib/mcp-probe.js';
+import { tokenFor, maskToken, isReadOnly, checkToken, scopeGaps, preApprovals, fetchAppStates, appsOff, newerReleases, } from '../lib/mcp-account.js';
+import { isRememberedTrust, rememberTrust, mayStartEntry } from '../lib/mcp-trust.js';
+const W = 14;
+const CLAUDE_CODE_SCOPES = new Set(['user', 'local', 'project']);
+const SCOPE_WORD = { user: 'you (user)', local: 'this folder (local)', project: 'project', desktop: 'Claude Desktop' };
+export async function runMcpCommand(args = [], deps = {}) {
+    const sub = args.find((a) => !a.startsWith('-'));
+    if (sub === 'test')
+        return runMcpTest(deps, args);
+    if (sub === 'add')
+        return runMcpAdd(args, deps);
+    if (sub === 'clean')
+        return runMcpClean(args, deps);
+    if (sub) {
+        ;
+        (deps.errLog ?? ((s) => process.stderr.write(s)))(`nonbot mcp: unknown subcommand "${sub}". Try: nonbot mcp · nonbot mcp test · nonbot mcp add · nonbot mcp clean\n`);
+        return 1;
+    }
+    return runMcpReadout(args, deps);
+}
+function io(deps) {
+    const log = deps.log ?? ((s) => process.stdout.write(s));
+    const errLog = deps.errLog ?? ((s) => process.stderr.write(s));
+    const row = (sig, label, detail = '') => log(statusRow(sig, label, detail, { labelWidth: W }) + '\n');
+    const hint = (text) => log(' '.repeat(3 + 1 + 2 + W + 1) + (isTTY(process.stdout) ? `${ANSI.dim}${text}${ANSI.reset}` : text) + '\n');
+    const section = (t) => log('\n' + (isTTY(process.stdout) ? `   ${ANSI.bold}${t}${ANSI.reset}` : `   ${t}`) + '\n');
+    const cmdRow = (c, what) => log(isTTY(process.stdout) ? `      ${ANSI.cyan}${c.padEnd(20)}${ANSI.reset}${ANSI.dim}${what}${ANSI.reset}\n` : `      ${c.padEnd(20)}${what}\n`);
+    return { log, errLog, row, hint, section, cmdRow };
+}
+function mayStart(entry, spec, deps) {
+    return mayStartEntry(entry, spec, deps.isRemembered ?? isRememberedTrust);
+}
+function commandLine(spec) {
+    return [spec.command ?? spec.url ?? '', ...spec.args].join(' ').replace(/pat_[A-Za-z0-9_-]+/g, 'pat_…');
+}
+function seconds(ms) {
+    return ms < 1000 ? `${ms}ms` : `${(ms / 1000).toFixed(1)}s`;
+}
+function kTokens(n) {
+    return n >= 1000 ? `~${Math.round(n / 1000)}k` : `~${n}`;
+}
+function plural(n, word) {
+    return `${n} ${word}${n === 1 ? '' : 's'}`;
+}
+function tilde(p, home) {
+    return p.startsWith(home) ? '~' + p.slice(home.length) : p;
+}
+export async function runMcpReadout(args, deps = {}) {
+    const { log, row, hint, section, cmdRow } = io(deps);
+    const quick = args.includes('--quick');
+    const home = deps.home ?? homedir();
+    const platform = deps.platform ?? process.platform;
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const now = deps.now ?? (() => Date.now());
+    const auth = await (deps.loadAuth ?? loadAuth)();
+    const statuses = await (deps.statuses ?? (() => nonbotMcpStatuses({ fetchImpl })))();
+    const scan = (deps.scan ?? (() => scanMcpConfigs()))();
+    const specOf = deps.launchSpec ?? launchSpecOf;
+    const primary = statuses.find((s) => CLAUDE_CODE_SCOPES.has(s.entry.scope ?? '')) ?? statuses[0];
+    const latest = statuses.find((s) => s.latest)?.latest ?? null;
+    const subtitle = primary?.installed
+        ? `v${primary.installed}${latest ? (primary.installed === latest ? ' (latest)' : ` · v${latest} is out`) : ''}`
+        : latest
+            ? `v${latest} on npm`
+            : `CLI v${VERSION}`;
+    log(header('non.bot MCP', subtitle) + '\n');
+    section('SETUP');
+    if (!primary) {
+        row('⚠', 'Not set up', 'no Claude app on this machine runs the non.bot MCP');
+        hint('add it: nonbot mcp add');
+        const retired = scan.locations.filter((l) => LEGACY_MCP_NAMES.includes(l.name));
+        log('\n');
+        cmdRow('nonbot mcp add', 'register it in Claude Code');
+        if (retired.length)
+            cmdRow('nonbot mcp clean', `remove ${plural(retired.length, 'retired server')}`);
+        return 0;
+    }
+    const r = mcpRow(primary, home);
+    row(r.sigil, 'Installed', r.detail);
+    if (r.hint)
+        hint(r.hint);
+    for (const s of statuses) {
+        const label = s.entry.scope === 'desktop' ? 'Claude Desktop' : 'Claude Code';
+        const where = s.entry.scope === 'desktop' ? 'configured' : `${SCOPE_WORD[s.entry.scope ?? 'user']} · ${s.entry.source}`;
+        row('✓', label, `${where}${s.entry.name !== 'nonbot' ? ` · as "${s.entry.name}"` : ''}`);
+    }
+    if (platform === 'darwin' && !statuses.some((s) => s.entry.scope === 'desktop'))
+        row('ℹ', 'Claude Desktop', 'not set up');
+    const codeNames = new Set(statuses.filter((s) => CLAUDE_CODE_SCOPES.has(s.entry.scope ?? '')).map((s) => s.entry.name));
+    if (codeNames.size > 1) {
+        row('⚠', 'Duplicates', `registered as ${[...codeNames].map((n) => `"${n}"`).join(' and ')} — Claude loads both`);
+        hint('keep one: claude mcp remove <name>');
+    }
+    if (primary.installed && latest) {
+        const releases = await newerReleases(primary.installed, latest, fetchImpl);
+        if (releases && releases.length) {
+            row('ℹ', "What's new", `${plural(releases.length, 'release')} since v${primary.installed}`);
+            hint(releases.slice(-4).map((x) => `${x.version} (${x.date})`).join(' · '));
+        }
+    }
+    section('HEALTH');
+    const spec = specOf(primary.entry);
+    let probe = null;
+    if (quick) {
+        row('ℹ', 'Starts', 'not checked (--quick)');
+    }
+    else if (spec && !mayStart(primary.entry, spec, deps) && !args.includes('--include-project')) {
+        row('ℹ', 'Starts', `not started — ${primary.entry.source} is a project file`);
+        hint('check the command and approve it once: nonbot mcp test --include-project');
+    }
+    else if (!spec) {
+        row('⚠', 'Starts', 'could not read how it is launched');
+    }
+    else {
+        probe = await (deps.probe ?? ((sp) => probeMcp(sp, { fetchImpl, fallbackBearer: auth?.pat })))(spec, primary.entry);
+        if (probe.ok) {
+            const who = probe.serverVersion ? ` · reports ${probe.serverName ?? 'server'} ${probe.serverVersion}` : '';
+            row('✓', 'Starts', `answered in ${seconds(probe.ms)}${who}`);
+            const groups = toolGroups(probe.tools);
+            const shown = groups.slice(0, 5).map(([g, n]) => `${g} ${n}`).join(' · ');
+            row('✓', 'Tools', `${probe.tools.length}${shown ? ` · ${shown}` : ''}${groups.length > 5 ? ' · …' : ''}`);
+            row('ℹ', 'Context cost', `${kTokens(estimateTokens(probe.toolBytes))} tokens of tool definitions per conversation`);
+        }
+        else {
+            row('✗', 'Starts', probe.error ?? 'it did not answer');
+            hint('see it fail directly: nonbot mcp test');
+        }
+    }
+    const t0 = now();
+    const base = auth?.baseUrl ?? 'https://non.bot';
+    try {
+        const res = await fetchImpl(`${base}/api/health`, { signal: AbortSignal.timeout(8_000) });
+        row(res.ok ? '✓' : '⚠', 'non.bot API', res.ok ? `answered in ${seconds(now() - t0)}` : `answered HTTP ${res.status}`);
+    }
+    catch {
+        row('✗', 'non.bot API', `could not reach ${base}`);
+    }
+    section('ACCOUNT');
+    const choice = tokenFor(primary.entry, spec, auth);
+    let check = null;
+    if (choice.source === 'none' || !choice.token) {
+        if (primary.entry.kind === 'remote')
+            row('ℹ', 'Token', 'Claude signs in to mcp.non.bot itself — no token on this machine');
+        else {
+            row('⚠', 'Token', 'none — the MCP has no token to use');
+            hint('sign in: nonbot login');
+        }
+    }
+    else {
+        check = await checkToken(base, choice.token, fetchImpl);
+        const from = choice.source === 'login' ? 'from nonbot login' : 'from the MCP config';
+        const state = check.valid === true ? 'valid' : check.valid === false ? 'REJECTED' : 'could not check';
+        row(check.valid === false ? '✗' : check.valid === true ? '✓' : '⚠', 'Token', `${maskToken(choice.token)} · ${from} · ${state}`);
+        if (check.valid === false)
+            hint(choice.source === 'login' ? 'sign in again: nonbot login' : `make a new one: ${base}/settings/connections`);
+    }
+    if (check?.valid && probe?.ok) {
+        const gaps = scopeGaps(check.scopes, probe.tools);
+        if (gaps.full)
+            row('✓', 'Permissions', `full access${check.name ? ` · token "${check.name}"` : ''}`);
+        else {
+            if (!gaps.blocked.length && !gaps.readOnly.length)
+                row('✓', 'Permissions', `every tool is covered${check.name ? ` · token "${check.name}"` : ''}`);
+            for (const b of gaps.blocked) {
+                row('⚠', 'Permissions', `${plural(b.tools, `${b.family} tool`)} can't run — needs ${b.needs}`);
+            }
+            for (const ro of gaps.readOnly)
+                row('ℹ', 'Permissions', `${ro.family} tools are read-only for this token (${ro.tools})`);
+            if (gaps.blocked.length)
+                hint(`a token with more access: ${base}/settings/connections`);
+        }
+    }
+    else if (check?.valid && !probe?.ok) {
+        row('ℹ', 'Permissions', `${check.scopes === null ? 'full access' : check.scopes.join(', ')}${quick ? '' : ' · tools not listed'}`);
+    }
+    if (isReadOnly(spec))
+        row('ℹ', 'Read-only mode', 'on — the MCP leaves out every write tool');
+    if (choice.token && probe?.ok) {
+        const apps = await fetchAppStates(base, choice.token, fetchImpl);
+        for (const off of apps ? appsOff(probe.tools, apps) : []) {
+            if (off.state === 'not offered')
+                continue;
+            const App = off.app === 'run' ? 'Run' : 'JobShop';
+            row('⚠', 'Off for you', `${plural(off.tools, `${App} tool`)} — ${App} is ${off.state === 'off' ? 'switched off' : 'not added'}`);
+            hint(`${off.state === 'off' ? 'turn it on' : 'add it'}: ${base}/whygraph/store?tab=apps&app=${off.app}`);
+        }
+    }
+    const dirs = [primary.entry.dir, process.cwd()].filter((d) => !!d);
+    const pre = preApprovals(primary.entry.name, dirs, home);
+    if (pre.denied === 'all')
+        row('⚠', 'Pre-approved', `every ${primary.entry.name} tool is DENIED in ${pre.files.join(', ')}`);
+    else if (pre.all)
+        row('✓', 'Pre-approved', `all ${primary.entry.name} tools run without asking (${pre.files.join(', ')})`);
+    else if (pre.some)
+        row('ℹ', 'Pre-approved', `${plural(pre.some, 'tool')} run without asking; Claude asks for the rest`);
+    else
+        row('ℹ', 'Pre-approved', 'none — Claude asks before each nonbot tool');
+    if (typeof pre.denied === 'number' && pre.denied > 0)
+        row('ℹ', 'Denied', plural(pre.denied, 'tool'));
+    section('COMMANDS');
+    cmdRow('nonbot mcp test', 'start it and check it answers');
+    cmdRow('nonbot update mcp', 'update it');
+    const retired = scan.locations.filter((l) => LEGACY_MCP_NAMES.includes(l.name));
+    if (retired.length)
+        cmdRow('nonbot mcp clean', `remove ${plural(retired.length, 'retired server')}`);
+    if (quick)
+        cmdRow('nonbot mcp', 'the full check (starts it)');
+    return 0;
+}
+export async function runMcpTest(deps = {}, args = []) {
+    const { log, row, hint } = io(deps);
+    const includeProject = args.includes('--include-project');
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const auth = await (deps.loadAuth ?? loadAuth)();
+    const scan = (deps.scan ?? (() => scanMcpConfigs()))();
+    const specOf = deps.launchSpec ?? launchSpecOf;
+    log(header('non.bot MCP test', `${plural(scan.nonbot.length, 'configured copy')}`.replace('copys', 'copies')) + '\n\n');
+    if (scan.nonbot.length === 0) {
+        row('✗', 'Not set up', 'nothing to start — add it: nonbot mcp add');
+        return 1;
+    }
+    let failed = 0;
+    for (const entry of scan.nonbot) {
+        const spec = specOf(entry);
+        const label = entry.scope === 'desktop' ? 'Claude Desktop' : entry.name;
+        if (!spec) {
+            row('✗', label, 'could not read how it is launched');
+            failed++;
+            continue;
+        }
+        if (!mayStart(entry, spec, deps)) {
+            if (!includeProject) {
+                row('ℹ', label, `not started — ${entry.source} is a project file`);
+                hint('check the command and approve it once: nonbot mcp test --include-project');
+                continue;
+            }
+            hint(`command: ${commandLine(spec)}`);
+            hint(`from:    ${entry.source}`);
+            if (deps.stdinIsTTY ?? !!process.stdin.isTTY) {
+                const yes = await (deps.confirm ?? defaultConfirm)('   Start it, and remember this exact command? [y/N] ');
+                if (!yes) {
+                    row('ℹ', label, 'not started');
+                    continue;
+                }
+                ;
+                (deps.remember ?? rememberTrust)(entry, spec);
+            }
+        }
+        if (entry.kind === 'npx')
+            hint('npx may download it first — this can take a while');
+        const p = await (deps.probe ?? ((sp) => probeMcp(sp, { fetchImpl, fallbackBearer: auth?.pat })))(spec, entry);
+        if (p.ok)
+            row('✓', label, `${p.tools.length} tools in ${seconds(p.ms)}${p.serverVersion ? ` · v${p.serverVersion}` : ''} · ${entry.source}`);
+        else {
+            row('✗', label, `${p.error ?? 'did not answer'} · ${entry.source}`);
+            failed++;
+        }
+    }
+    return failed ? 1 : 0;
+}
+export const MCP_ADD_ARGS = (scope) => ['mcp', 'add', '-s', scope, 'nonbot', '--', 'npx', '-y', '@nonbot/mcp'];
+export async function runMcpAdd(args, deps = {}) {
+    const { log, errLog, row, hint } = io(deps);
+    const spawn = deps.spawnSync ?? ((cmd, a, o) => nodeSpawnSync(cmd, a, { ...o, encoding: 'utf-8' }));
+    const i = args.indexOf('--scope');
+    const scope = i >= 0 ? args[i + 1] ?? '' : 'user';
+    if (!['user', 'local', 'project'].includes(scope)) {
+        errLog('nonbot mcp add: --scope is user, local or project\n');
+        return 1;
+    }
+    log(header('non.bot MCP add', `scope: ${scope}`) + '\n\n');
+    const scan = (deps.scan ?? (() => scanMcpConfigs()))();
+    const cwd = deps.cwd ?? process.cwd();
+    const code = scan.nonbot.filter((e) => CLAUDE_CODE_SCOPES.has(e.scope ?? ''));
+    const everywhere = code.find((e) => e.scope === 'user');
+    const here = code.find((e) => e.dir && (cwd === e.dir || cwd.startsWith(e.dir + '/')));
+    if (!args.includes('--force')) {
+        if (everywhere) {
+            row('✓', 'Already set up', `for every project · ${everywhere.source}`);
+            return 0;
+        }
+        if (here && scope !== 'user') {
+            row('✓', 'Already set up', `for this project · ${here.source}`);
+            return 0;
+        }
+        if (here) {
+            row('ℹ', 'This project', `already has it (${here.source}) — adding it for every project too`);
+        }
+    }
+    const auth = await (deps.loadAuth ?? loadAuth)();
+    if (!auth) {
+        row('⚠', 'Not signed in', 'the MCP uses your nonbot login — sign in first');
+        hint('nonbot login, then: nonbot mcp add');
+        return 1;
+    }
+    const argv = MCP_ADD_ARGS(scope);
+    const res = spawn('claude', argv, { stdio: 'inherit' });
+    if (res.error) {
+        row('✗', 'Claude Code', 'the claude command is not on PATH');
+        hint(`run it yourself: claude ${argv.join(' ')}`);
+        return 1;
+    }
+    if (res.status !== 0) {
+        row('✗', 'Add failed', `claude exited ${res.status} — see its output above`);
+        return 1;
+    }
+    row('✓', 'Added', `"nonbot" · ${SCOPE_WORD[scope]} · npx @nonbot/mcp (updates itself)`);
+    hint('restart Claude Code, or run /mcp, to load it');
+    return 0;
+}
+function dedupe(locs) {
+    const seen = new Set();
+    return locs.filter((l) => {
+        const k = `${l.name}|${l.scope}|${l.dir ?? ''}|${l.file}`;
+        if (seen.has(k))
+            return false;
+        seen.add(k);
+        return true;
+    });
+}
+export function removeFromDesktopConfig(file, name, stamp = Date.now()) {
+    const text = readFileSync(file, 'utf-8');
+    const json = JSON.parse(text);
+    if (!json.mcpServers || !(name in json.mcpServers))
+        return false;
+    copyFileSync(file, `${file}.nonbot-backup-${stamp}`);
+    delete json.mcpServers[name];
+    const tmp = `${file}.nonbot-tmp`;
+    writeFileSync(tmp, JSON.stringify(json, null, 2) + '\n');
+    renameSync(tmp, file);
+    return true;
+}
+async function defaultConfirm(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await rl.question(question);
+        return /^y(es)?$/i.test(answer.trim());
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function runMcpClean(args, deps = {}) {
+    const { log, row, hint } = io(deps);
+    const home = deps.home ?? homedir();
+    const spawn = deps.spawnSync ?? ((cmd, a, o) => nodeSpawnSync(cmd, a, { ...o, encoding: 'utf-8' }));
+    const scan = (deps.scan ?? (() => scanMcpConfigs()))();
+    const retired = dedupe(scan.locations.filter((l) => LEGACY_MCP_NAMES.includes(l.name)));
+    log(header('non.bot MCP clean', 'retired servers') + '\n\n');
+    if (retired.length === 0) {
+        row('✓', 'Nothing to do', 'no retired MCP servers are configured');
+        return 0;
+    }
+    for (const l of retired)
+        row('ℹ', l.name, `${SCOPE_WORD[l.scope]} · ${tilde(l.file, home)}`);
+    log('\n');
+    const yes = args.includes('--yes') || args.includes('-y');
+    if (!yes) {
+        const tty = deps.stdinIsTTY ?? !!process.stdin.isTTY;
+        if (!tty) {
+            hint('not removed — re-run with --yes to remove them');
+            return 1;
+        }
+        const ok = await (deps.confirm ?? defaultConfirm)(`   Remove ${plural(retired.length, 'server')}? [y/N] `);
+        if (!ok) {
+            hint('nothing removed');
+            return 0;
+        }
+    }
+    let failed = 0;
+    for (const l of retired) {
+        if (l.scope === 'desktop') {
+            try {
+                const done = removeFromDesktopConfig(l.file, l.name);
+                row(done ? '✓' : 'ℹ', l.name, done ? 'removed from Claude Desktop (backup kept next to the file)' : 'already gone');
+            }
+            catch {
+                row('✗', l.name, 'could not edit the Claude Desktop config');
+                failed++;
+            }
+            continue;
+        }
+        const res = spawn('claude', ['mcp', 'remove', '-s', l.scope, l.name], { cwd: l.dir ?? home, stdio: 'pipe' });
+        if (res.error) {
+            row('✗', l.name, 'the claude command is not on PATH');
+            hint(`${l.dir ? `cd ${tilde(l.dir, home)} && ` : ''}claude mcp remove -s ${l.scope} ${l.name}`);
+            failed++;
+        }
+        else if (res.status !== 0) {
+            row('✗', l.name, `claude mcp remove failed (exit ${res.status})`);
+            failed++;
+        }
+        else
+            row('✓', l.name, `removed · ${SCOPE_WORD[l.scope]}`);
+    }
+    if (!failed)
+        hint('restart Claude Code to drop them from open sessions');
+    return failed ? 1 : 0;
+}

package/dist/commands/update.js

@@ -0,0 +1,157 @@
+import { spawnSync as nodeSpawnSync } from 'node:child_process';
+import { realpathSync } from 'node:fs';
+import { dirname, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { VERSION } from '../version.js';
+import { fetchLatestVersion, compareVersions } from '../lib/update-check.js';
+import { readPidFile } from '../lib/daemon-lifecycle.js';
+import { header, statusRow } from '../lib/output.js';
+import { nonbotMcpStatuses, mcpRow, globalMcpIsLinked } from '../lib/mcp-status.js';
+export const UPDATE_INSTALL_ARGS = ['install', '-g', '@nonbot/cli@latest'];
+function defaultEntryPath() {
+    const here = fileURLToPath(import.meta.url);
+    try {
+        return realpathSync(here);
+    }
+    catch {
+        return here;
+    }
+}
+export function isLinkedCheckout(entry) {
+    const marker = `${sep}node_modules${sep}@nonbot${sep}cli${sep}`;
+    return !entry.split('/').join(sep).includes(marker);
+}
+function checkoutRoot(entry) {
+    let d = dirname(entry);
+    while (d !== dirname(d)) {
+        if (d.endsWith(`${sep}dist`))
+            return dirname(d);
+        d = dirname(d);
+    }
+    return dirname(entry);
+}
+function defaultRunNpm(args) {
+    const r = nodeSpawnSync('npm', [...args], {
+        stdio: 'inherit',
+        shell: process.platform === 'win32',
+    });
+    if (r.error)
+        return 127;
+    return r.status ?? 1;
+}
+function defaultDaemonRunning() {
+    const pid = readPidFile();
+    if (pid === null)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function runUpdateCommand(args = [], deps = {}) {
+    const log = deps.log ?? ((s) => process.stdout.write(s));
+    const errLog = deps.errLog ?? ((s) => process.stderr.write(s));
+    const positional = args.filter((a) => !a.startsWith('-'));
+    if (positional[0] === 'mcp')
+        return runUpdateMcpCommand(args.slice(1), deps);
+    if (positional.length > 0) {
+        errLog(`nonbot update: unknown target "${positional[0]}". Try: nonbot update  (this CLI)  ·  nonbot update mcp  (the non.bot MCP)\n`);
+        return 1;
+    }
+    const current = deps.current ?? VERSION;
+    const fetchLatest = deps.fetchLatest ?? (() => fetchLatestVersion());
+    const entry = (deps.entryPath ?? defaultEntryPath)();
+    const runNpm = deps.runNpm ?? defaultRunNpm;
+    const daemonRunning = deps.daemonRunning ?? defaultDaemonRunning;
+    const force = args.includes('--force');
+    log(header('non.bot update', `v${current}`) + '\n\n');
+    const latest = await fetchLatest();
+    if (!latest) {
+        errLog(statusRow('⚠', 'Registry', 'could not read the latest version from npm — check your connection', { stream: process.stderr }) + '\n');
+        errLog(`   or install it directly:  npm ${UPDATE_INSTALL_ARGS.join(' ')}\n`);
+        return 1;
+    }
+    if (compareVersions(latest, current) <= 0) {
+        log(statusRow('✓', 'Up to date', `v${current} is the latest`) + '\n');
+        return 0;
+    }
+    log(statusRow('ℹ', 'Update', `v${current} → v${latest}`) + '\n');
+    if (isLinkedCheckout(entry) && !force) {
+        const root = checkoutRoot(entry);
+        log(statusRow('⚠', 'Linked copy', `this nonbot runs from a source checkout: ${root}`) + '\n');
+        log(`   update the checkout:      cd ${root} && git pull && npm run build\n`);
+        log(`   or replace the link with the published v${latest}:  nonbot update --force\n`);
+        return 0;
+    }
+    log(`\n   npm ${UPDATE_INSTALL_ARGS.join(' ')}\n\n`);
+    const code = runNpm(UPDATE_INSTALL_ARGS);
+    log('\n');
+    if (code !== 0) {
+        errLog(statusRow('✗', 'Update failed', `npm exited ${code} — see its output above`, { stream: process.stderr }) + '\n');
+        return 1;
+    }
+    log(statusRow('✓', 'Updated', `v${latest} installed`) + '\n');
+    if (daemonRunning()) {
+        log(statusRow('ℹ', 'Daemon', 'still running the old version — restart it to use the new one:') + '\n');
+        log('   Ctrl-C in its window (or: nonbot daemon stop), then: nonbot daemon\n');
+    }
+    return 0;
+}
+export const MCP_INSTALL_ARGS = ['install', '-g', '@nonbot/mcp@latest'];
+export async function runUpdateMcpCommand(args = [], deps = {}) {
+    const log = deps.log ?? ((s) => process.stdout.write(s));
+    const errLog = deps.errLog ?? ((s) => process.stderr.write(s));
+    const statusesOf = deps.mcpStatuses ?? (() => nonbotMcpStatuses());
+    const runNpm = deps.runNpm ?? defaultRunNpm;
+    const linked = deps.globalMcpLinked ?? (() => globalMcpIsLinked());
+    const force = args.includes('--force');
+    const W = 14;
+    const row = (sig, label, detail = '') => log(statusRow(sig, label, detail, { labelWidth: W }) + '\n');
+    const hint = (text) => log(' '.repeat(3 + 1 + 2 + W + 1) + text + '\n');
+    const statuses = await statusesOf();
+    const latest = statuses.find((s) => s.latest)?.latest ?? null;
+    log(header('non.bot update mcp', latest ? `v${latest} on npm` : 'npm not reachable') + '\n\n');
+    if (statuses.length === 0) {
+        row('⚠', 'nonbot MCP', 'not set up in Claude Code');
+        hint('add it: claude mcp add nonbot -- npx -y @nonbot/mcp');
+        return 0;
+    }
+    let changed = false;
+    let failed = false;
+    let globalDone = false;
+    for (const s of statuses) {
+        const r = mcpRow(s);
+        row(r.sigil, 'nonbot MCP', r.detail);
+        hint(`in ${s.entry.source}`);
+        const behind = !!(s.installed && s.latest && compareVersions(s.latest, s.installed) > 0);
+        if (s.entry.kind === 'global' && (behind || !s.installed) && !globalDone) {
+            globalDone = true;
+            if (linked() && !force) {
+                hint('the global @nonbot/mcp is linked to a source checkout — left alone (nonbot update mcp --force replaces it)');
+                continue;
+            }
+            log(`\n   npm ${MCP_INSTALL_ARGS.join(' ')}\n\n`);
+            const code = runNpm(MCP_INSTALL_ARGS);
+            log('\n');
+            if (code === 0) {
+                row('✓', 'Updated', latest ? `@nonbot/mcp v${latest} installed` : '@nonbot/mcp installed');
+                changed = true;
+            }
+            else {
+                errLog(statusRow('✗', 'Update failed', `npm exited ${code} — see its output above`, { labelWidth: W, stream: process.stderr }) + '\n');
+                failed = true;
+            }
+        }
+        else if (r.hint) {
+            hint(r.hint);
+        }
+    }
+    if (changed) {
+        log('\n');
+        row('ℹ', 'Load it', 'restart Claude Code, or run /mcp → Reconnect');
+    }
+    return failed ? 1 : 0;
+}