@nonbot/cli 0.10.15 → 0.10.17

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/run.js

@@ -16,7 +16,7 @@ export async function runRunCommand(args = [], deps = {}) {
     }
     const id = args.find((a) => !a.startsWith('-'));
     if (!id) {
-        errLog('Usage: nonbot run <activation-id> [--headless]\n');
+        errLog('To use: nonbot run <activation-id> [--headless]\n');
         return 1;
     }
     const auth = await loader();

package/dist/index.js

@@ -8,12 +8,15 @@ import { runRunCommand } from './commands/run.js';
 import { runDoctorCommand } from './commands/doctor.js';
 import { runLogoutCommand } from './commands/logout.js';
 import { runUpdateCommand } from './commands/update.js';
+import { runMcpCommand } from './commands/mcp.js';
+import { menuIsInteractive, waitForMenuChoice, linesBelow } from './lib/quickstart-menu.js';
 import { runLogsCommand } from './commands/logs.js';
 import { runProfilesCommand } from './commands/profiles.js';
 import { runChoirCommand } from './commands/choir.js';
 import { runRunMcpCommand } from './commands/run-mcp.js';
 import { runRunPromptHookCommand } from './commands/run-prompt-hook.js';
 import { setActiveProfile } from './lib/auth.js';
+import { localStatus, statusLine, localMcpLabel, versionsLine } from './lib/local-status.js';
 import { header, kvRow, ANSI, isTTY, wordmarkArt, WORDMARK_WIDTH } from './lib/output.js';
 const COMMANDS = [
     {
@@ -53,6 +56,12 @@ const COMMANDS = [
         group: 'check',
         run: (args) => runDoctorCommand(args),
     },
+    {
+        name: 'mcp',
+        description: 'The non.bot MCP: health + version · also: test, add, clean',
+        group: 'check',
+        run: (args) => runMcpCommand(args),
+    },
     {
         name: 'logs',
         description: 'Runs launched on this machine (--limit <n>, --json, -f)',
@@ -107,14 +116,26 @@ const COMMANDS = [
 function printVersion() {
     process.stdout.write(VERSION + '\n');
 }
-function printHelp() {
+function roomForWordmark() {
+    const cols = process.stdout.columns ?? 0;
+    return cols === 0 || cols >= WORDMARK_WIDTH + 4;
+}
+function printHelp(opts = {}) {
     const tty = isTTY(process.stdout);
     const head = (t) => (tty ? `   ${ANSI.bold}${t}${ANSI.reset}` : `   ${t}`);
     const KEY = 18;
     const lines = [];
-    lines.push(header('nonbot', `non.bot CLI  ·  v${VERSION}`));
+    if (opts.wordmark !== false && roomForWordmark()) {
+        lines.push('');
+        lines.push(wordmarkArt({ indent: '  ' }));
+        lines.push('');
+        lines.push(kvRow('', versionsLine(VERSION, opts.mcpLabel ?? 'not checked'), { keyWidth: 8 }));
+    }
+    else {
+        lines.push(header('nonbot', `non.bot CLI  ·  v${VERSION}`));
+    }
     lines.push('');
-    lines.push(kvRow('Usage', 'nonbot <command> [args]', { keyWidth: KEY }));
+    lines.push(kvRow('To use', 'nonbot <command> [args]', { keyWidth: KEY }));
     const section = (title, group) => {
         lines.push('');
         lines.push(head(title));
@@ -138,29 +159,40 @@ function printHelp() {
     lines.push('');
     process.stdout.write(lines.join('\n') + '\n');
 }
-function printQuickStart() {
+async function printQuickStart() {
     const KEY = 8;
+    const io = { stdin: process.stdin, stdout: process.stdout };
+    const interactive = menuIsInteractive(io);
     const lines = [];
-    const cols = process.stdout.columns ?? 0;
-    if (cols === 0 || cols >= WORDMARK_WIDTH + 4) {
+    if (roomForWordmark()) {
         lines.push('');
         lines.push(wordmarkArt({ indent: '  ' }));
         lines.push('');
-        lines.push(kvRow('', `the non.bot CLI · v${VERSION}`, { keyWidth: KEY }));
+        lines.push(kvRow('', versionsLine(VERSION, await localMcpLabel()), { keyWidth: KEY }));
     }
     else {
         lines.push(header('non.bot CLI', `v${VERSION}`));
     }
+    const status = await localStatus();
+    lines.push(statusLine(status, KEY));
     lines.push('');
-    lines.push(kvRow('login', 'sign in', { keyWidth: KEY }));
-    lines.push(kvRow('daemon', 'listen for runs — Ctrl-C stops it', { keyWidth: KEY }));
+    lines.push(kvRow('login', status.email ? 'switch account' : 'sign in', { keyWidth: KEY }));
+    lines.push(kvRow('daemon', status.daemon ? 'running · Ctrl-C in its window stops it' : 'listen for runs — Ctrl-C stops it', { keyWidth: KEY }));
     lines.push(kvRow('doctor', 'check that everything is set up', { keyWidth: KEY }));
     lines.push(kvRow('logout', 'sign out and stop the daemon', { keyWidth: KEY }));
     lines.push(kvRow('update', 'install the latest version', { keyWidth: KEY }));
+    const HELP_MARK = 'all commands';
+    lines.push(kvRow('help', interactive ? `${HELP_MARK}  ← click, or press h` : `${HELP_MARK} · nonbot help`, { keyWidth: KEY }));
     lines.push('');
-    lines.push(kvRow('', 'type nonbot <command> · nonbot --help lists everything', { keyWidth: KEY }));
+    lines.push(kvRow('', interactive ? 'press h for help · any other key to exit' : 'type nonbot <command> · nonbot help lists everything', { keyWidth: KEY }));
     lines.push('');
-    process.stdout.write(lines.join('\n') + '\n');
+    const printed = lines.join('\n') + '\n';
+    process.stdout.write(printed);
+    if (!interactive)
+        return;
+    const choice = await waitForMenuChoice(io, linesBelow(printed, HELP_MARK));
+    if (choice === 'help')
+        printHelp({ wordmark: false });
 }
 function extractProfileFlag(args) {
     let profile;
@@ -195,7 +227,7 @@ async function main(argv) {
         }
     }
     if (args.length === 0) {
-        printQuickStart();
+        await printQuickStart();
         return 0;
     }
     const first = args[0];
@@ -203,14 +235,14 @@ async function main(argv) {
         printVersion();
         return 0;
     }
-    if (first === '-h' || first === '--help') {
-        printHelp();
+    if (first === '-h' || first === '--help' || first === 'help') {
+        printHelp({ mcpLabel: await localMcpLabel() });
         return 0;
     }
     const cmd = COMMANDS.find((c) => c.name === first);
     if (!cmd) {
         process.stderr.write(`nonbot: unknown command "${first}"\n\n`);
-        printHelp();
+        printHelp({ mcpLabel: await localMcpLabel() });
         return 1;
     }
     const result = await cmd.run(args.slice(1));

package/dist/lib/local-status.js

@@ -0,0 +1,54 @@
+import { loadAuth } from './auth.js';
+import { readPidFile } from './daemon-lifecycle.js';
+import { ANSI, isTTY } from './output.js';
+import { scanMcpConfigs } from './mcp-config.js';
+import { installedMcpVersion } from './mcp-status.js';
+export async function localMcpLabel(scan = () => scanMcpConfigs().nonbot, versionOf = (e) => installedMcpVersion(e)) {
+    let entries = [];
+    try {
+        entries = scan();
+    }
+    catch {
+        entries = [];
+    }
+    const primary = entries.find((e) => e.scope && e.scope !== 'desktop') ?? entries[0];
+    if (!primary)
+        return 'not set up';
+    if (primary.kind === 'remote')
+        return 'remote';
+    const v = await versionOf(primary).catch(() => null);
+    return v ? `v${v}` : 'set up';
+}
+export function versionsLine(cliVersion, mcpLabel) {
+    return `non.bot CLI v${cliVersion}  ·  non.bot MCP ${mcpLabel}`;
+}
+export async function localStatus(deps = {}) {
+    let email = null;
+    try {
+        email = (await (deps.loadAuth ?? loadAuth)())?.email ?? null;
+    }
+    catch {
+        email = null;
+    }
+    const pid = (deps.readPid ?? (() => readPidFile()))();
+    const alive = deps.isAlive ??
+        ((p) => {
+            try {
+                process.kill(p, 0);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+    return { email, daemon: pid !== null && alive(pid) };
+}
+export function statusLine(s, keyWidth, stream = process.stdout) {
+    const tty = isTTY(stream);
+    const pad = ' '.repeat(3 + keyWidth + 1);
+    const mark = (ok) => (tty ? (ok ? `${ANSI.green}✓${ANSI.reset}` : `${ANSI.dim}○${ANSI.reset}`) : ok ? '✓' : '○');
+    const dim = (t) => (tty ? `${ANSI.dim}${t}${ANSI.reset}` : t);
+    if (!s.email)
+        return `${pad}${mark(false)} ${dim('not signed in — start with: nonbot login')}`;
+    return `${pad}${mark(true)} ${dim(`signed in as ${s.email} · daemon ${s.daemon ? 'running' : 'not running'}`)}`;
+}