@nonbot/cli 0.10.14 → 0.10.16

package/dist/index.js

@@ -6,98 +6,180 @@ import { runDaemonCommand } from './commands/daemon.js';
 import { runLoginCommand } from './commands/login.js';
 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 { header, kvRow, ANSI, isTTY } from './lib/output.js';
+import { header, kvRow, ANSI, isTTY, wordmarkArt, WORDMARK_WIDTH } from './lib/output.js';
 const COMMANDS = [
     {
         name: 'login',
-        description: 'Paste a PAT from /settings/connections; saves to ~/.config/nonbot/auth.json.',
+        description: 'Sign in with a token from non.bot Settings → Connections',
+        group: 'start',
         run: (args) => runLoginCommand(args),
     },
+    {
+        name: 'logout',
+        description: 'Sign out on this machine and stop the daemon',
+        group: 'start',
+        run: (args) => runLogoutCommand(args),
+    },
     {
         name: 'daemon',
-        description: 'Long-running listener — polls /api/cli/activations/pending every 2s. `nonbot daemon stop` stops it (local; --machine <id> / --all go remote); `nonbot daemon attach` reattaches a lost tmux window.',
+        description: 'Listen for runs from non.bot; each opens a terminal here',
+        group: 'start',
         run: (args) => runDaemonCommand(args),
     },
+    {
+        name: 'update',
+        description: 'Install the latest version · update mcp: the non.bot MCP',
+        usage: 'update [mcp]',
+        group: 'start',
+        run: (args) => runUpdateCommand(args),
+    },
+    {
+        name: 'status',
+        description: 'Who is signed in and whether the daemon is connected',
+        group: 'check',
+        run: (args) => runStatusCommand(args),
+    },
+    {
+        name: 'doctor',
+        description: 'Health check: account, agents, terminal, Claude Code',
+        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)',
+        group: 'check',
+        run: (args) => runLogsCommand(args),
+    },
     {
         name: 'run',
-        description: 'One-shot: fire a single activation by id. Usage: nonbot run <activation-id>',
+        usage: 'run <id>',
+        description: 'Launch one run by id, then exit',
+        group: 'more',
         run: (args) => runRunCommand(args),
     },
     {
         name: 'choir',
-        description: 'Coordinated-run engine: launch a fleet — one agent per git worktree, merged back by hand. Usage: nonbot choir <session> [--panes N] [--base <b>] [--join <mode>]',
+        description: 'Coordinated-run engine — one agent per git worktree',
+        usage: 'choir <session>',
+        group: 'more',
         run: (args) => runChoirCommand(args),
     },
+    {
+        name: 'profiles',
+        description: 'List signed-in accounts (pick one with --profile <name>)',
+        group: 'more',
+        run: (args) => runProfilesCommand(args),
+    },
+    {
+        name: 'test',
+        description: 'Print a local diagnostic banner (no server needed)',
+        group: 'more',
+        run: () => runTestCommand(),
+    },
     {
         name: 'run-mcp',
         description: 'Per-pane fleet MCP server over stdio. Launched by .mcp.json — not run by hand.',
+        group: 'hidden',
         run: () => runRunMcpCommand(),
     },
     {
         name: 'choir-mcp',
         description: 'Deprecated alias for run-mcp.',
+        group: 'hidden',
         run: () => runRunMcpCommand(),
     },
     {
         name: 'run-prompt-hook',
         description: "Claude Code Notification-hook handler — surfaces a Run's mid-run prompt. Not run by hand.",
+        group: 'hidden',
         run: () => runRunPromptHookCommand(),
     },
-    {
-        name: 'status',
-        description: 'Report login state + last daemon heartbeat.',
-        run: (args) => runStatusCommand(args),
-    },
-    {
-        name: 'doctor',
-        description: 'Health check — auth, server, daemon, provider CLIs, terminal.',
-        run: (args) => runDoctorCommand(args),
-    },
-    {
-        name: 'logs',
-        description: 'Local activation history. Flags: --limit <n>, --json, --follow/-f.',
-        run: (args) => runLogsCommand(args),
-    },
-    {
-        name: 'profiles',
-        description: 'List multi-account auth profiles; marks the active one.',
-        run: (args) => runProfilesCommand(args),
-    },
-    {
-        name: 'test',
-        description: 'Print the diagnostic banner locally — no server roundtrip.',
-        run: () => runTestCommand(),
-    },
 ];
 function printVersion() {
     process.stdout.write(VERSION + '\n');
 }
 function printHelp() {
     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 host  ·  v${VERSION}`));
+    lines.push(header('nonbot', `non.bot CLI  ·  v${VERSION}`));
     lines.push('');
-    lines.push(tty ? `   ${ANSI.cyan}Usage${ANSI.reset}      ${ANSI.dim}nonbot <command> [args]${ANSI.reset}` : '   Usage      nonbot <command> [args]');
+    lines.push(kvRow('Usage', 'nonbot <command> [args]', { keyWidth: KEY }));
+    const section = (title, group) => {
+        lines.push('');
+        lines.push(head(title));
+        for (const cmd of COMMANDS.filter((c) => c.group === group)) {
+            lines.push(kvRow(cmd.usage ?? cmd.name, cmd.description, { keyWidth: KEY }));
+        }
+    };
+    section('Get started', 'start');
     lines.push('');
-    lines.push(tty ? `   ${ANSI.cyan}Commands${ANSI.reset}` : '   Commands');
-    const w = COMMANDS.reduce((m, c) => Math.max(m, c.name.length), 0);
-    for (const cmd of COMMANDS) {
-        lines.push(kvRow(cmd.name, cmd.description, { keyWidth: w }));
-    }
+    lines.push(head('Stop the daemon'));
+    lines.push(kvRow('Ctrl-C', 'in the daemon\'s window', { keyWidth: KEY }));
+    lines.push(kvRow('daemon stop', 'from another terminal (--machine <id> / --all)', { keyWidth: KEY }));
+    lines.push(kvRow('daemon attach', 'bring back a closed daemon window', { keyWidth: KEY }));
+    section('Check', 'check');
+    section('More', 'more');
     lines.push('');
-    lines.push(tty ? `   ${ANSI.cyan}Flags${ANSI.reset}` : '   Flags');
-    lines.push(kvRow('--profile <name>', 'Use a named auth profile (multi-account). Default: "default".', { keyWidth: 18 }));
-    lines.push(kvRow('-v, --version', 'Print CLI version and exit.', { keyWidth: 18 }));
-    lines.push(kvRow('-h, --help', 'Print this help and exit.', { keyWidth: 18 }));
+    lines.push(head('Flags'));
+    lines.push(kvRow('--profile <name>', 'use a named account (works with any command)', { keyWidth: KEY }));
+    lines.push(kvRow('-v, --version', 'print the version', { keyWidth: KEY }));
+    lines.push(kvRow('-h, --help', 'print this help', { keyWidth: KEY }));
     lines.push('');
     process.stdout.write(lines.join('\n') + '\n');
 }
+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) {
+        lines.push('');
+        lines.push(wordmarkArt({ indent: '  ' }));
+        lines.push('');
+        lines.push(kvRow('', `the non.bot CLI · v${VERSION}`, { keyWidth: KEY }));
+    }
+    else {
+        lines.push(header('non.bot CLI', `v${VERSION}`));
+    }
+    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('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('', interactive ? 'press h for help · any other key to exit' : 'type nonbot <command> · nonbot help lists everything', { keyWidth: KEY }));
+    lines.push('');
+    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();
+}
 function extractProfileFlag(args) {
     let profile;
     for (let i = 0; i < args.length; i++) {
@@ -131,7 +213,7 @@ async function main(argv) {
         }
     }
     if (args.length === 0) {
-        printHelp();
+        await printQuickStart();
         return 0;
     }
     const first = args[0];
@@ -139,7 +221,7 @@ async function main(argv) {
         printVersion();
         return 0;
     }
-    if (first === '-h' || first === '--help') {
+    if (first === '-h' || first === '--help' || first === 'help') {
         printHelp();
         return 0;
     }

package/dist/lib/mcp-account.js

@@ -0,0 +1,232 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { compareVersions, parseSemver } from './update-check.js';
+export function tokenFor(entry, spec, cliAuth) {
+    if (spec) {
+        const auth = Object.entries(spec.headers).find(([k]) => k.toLowerCase() === 'authorization')?.[1];
+        const bearer = auth && /^Bearer\s+(\S+)$/i.exec(auth)?.[1];
+        if (bearer)
+            return { source: 'config', token: bearer };
+        const env = spec.env.NON_BOT_API_TOKEN;
+        if (env)
+            return { source: 'config', token: env };
+    }
+    if (entry.kind === 'remote')
+        return { source: 'none' };
+    return cliAuth?.pat ? { source: 'login', token: cliAuth.pat } : { source: 'none' };
+}
+export function maskToken(token) {
+    const tail = token.slice(-4);
+    return token.startsWith('pat_') ? `pat_…${tail}` : `…${tail}`;
+}
+export function isReadOnly(spec) {
+    if (!spec)
+        return false;
+    if (spec.env.NON_BOT_MCP_READONLY === '1')
+        return true;
+    if (spec.url) {
+        try {
+            return new URL(spec.url).searchParams.get('readonly') === '1';
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
+export async function checkToken(baseUrl, token, fetchImpl = fetch) {
+    try {
+        const res = await fetchImpl(`${baseUrl}/api/auth/me`, {
+            headers: { Authorization: `Bearer ${token}`, 'X-Requested-With': 'ConradPM-Native' },
+            signal: AbortSignal.timeout(8_000),
+        });
+        if (res.status === 401)
+            return { valid: false, scopes: null };
+        if (!res.ok)
+            return { valid: null, scopes: null };
+        const body = (await res.json());
+        if (!body.authenticated)
+            return { valid: false, scopes: null };
+        const t = body.token;
+        return {
+            valid: true,
+            name: typeof t?.name === 'string' ? t.name : null,
+            scopes: Array.isArray(t?.scopes) ? t.scopes.filter((s) => typeof s === 'string') : null,
+        };
+    }
+    catch {
+        return { valid: null, scopes: null };
+    }
+}
+export function familyOf(tool) {
+    if (tool.startsWith('jobshop_'))
+        return { family: 'jobshop', resources: ['jobshop'] };
+    if (tool.startsWith('radbug_'))
+        return { family: 'radbugs', resources: ['radbugs', 'admin', 'team'] };
+    if (tool.startsWith('run_'))
+        return { family: 'run', resources: ['portfolio', 'runs'] };
+    return { family: 'portfolio', resources: ['portfolio'] };
+}
+export function scopeGaps(scopes, tools) {
+    if (scopes === null || scopes.includes('*'))
+        return { full: true, blocked: [], readOnly: [] };
+    const has = (res) => scopes.some((s) => s.startsWith(`${res}:`));
+    const canWrite = (res) => scopes.some((s) => s === `${res}:write` || (res === 'runs' && /^runs:(fire|control|respond)$/.test(s)));
+    const counts = new Map();
+    for (const t of tools) {
+        const f = familyOf(t.name);
+        const c = counts.get(f.family) ?? { resources: f.resources, n: 0 };
+        c.n++;
+        counts.set(f.family, c);
+    }
+    const blocked = [];
+    const readOnly = [];
+    for (const [family, { resources, n }] of counts) {
+        if (!resources.some(has))
+            blocked.push({ family, tools: n, needs: resources.map((r) => `${r}:*`).join(' or ') });
+        else if (!resources.some(canWrite))
+            readOnly.push({ family, tools: n });
+    }
+    return { full: false, blocked, readOnly };
+}
+export function preApprovals(serverName, dirs, home = homedir(), read = readIfExists) {
+    const files = [join(home, '.claude', 'settings.json'), join(home, '.claude', 'settings.local.json')];
+    for (const d of dirs)
+        files.push(join(d, '.claude', 'settings.json'), join(d, '.claude', 'settings.local.json'));
+    const whole = new Set([`mcp__${serverName}`, `mcp__${serverName}__*`]);
+    const prefix = `mcp__${serverName}__`;
+    const out = { all: false, some: 0, denied: 0, files: [] };
+    const allowed = new Set();
+    const denied = new Set();
+    for (const f of [...new Set(files)]) {
+        let json = null;
+        try {
+            const text = read(f);
+            json = text ? JSON.parse(text) : null;
+        }
+        catch {
+            json = null;
+        }
+        const allow = Array.isArray(json?.permissions?.allow) ? json.permissions.allow : [];
+        const deny = Array.isArray(json?.permissions?.deny) ? json.permissions.deny : [];
+        let said = false;
+        for (const r of allow) {
+            if (typeof r !== 'string')
+                continue;
+            if (whole.has(r)) {
+                out.all = true;
+                said = true;
+            }
+            else if (r.startsWith(prefix)) {
+                allowed.add(r);
+                said = true;
+            }
+        }
+        for (const r of deny) {
+            if (typeof r !== 'string')
+                continue;
+            if (whole.has(r)) {
+                out.denied = 'all';
+                said = true;
+            }
+            else if (r.startsWith(prefix) && out.denied !== 'all') {
+                denied.add(r);
+                said = true;
+            }
+        }
+        if (said)
+            out.files.push(f.startsWith(home) ? '~' + f.slice(home.length) : f);
+    }
+    out.some = allowed.size;
+    if (out.denied !== 'all')
+        out.denied = denied.size;
+    return out;
+}
+function readIfExists(p) {
+    try {
+        return existsSync(p) ? readFileSync(p, 'utf-8') : null;
+    }
+    catch {
+        return null;
+    }
+}
+const RUN_PORTFOLIO_TOOLS = new Set([
+    'portfolio_create_activation',
+    'portfolio_get_activation',
+    'portfolio_update_activation_status',
+    'portfolio_subscribe_to_activations',
+    'portfolio_attach_brief',
+    'portfolio_link_chat_session',
+    'portfolio_mark_run_ready',
+    'portfolio_repo_path',
+]);
+export function appOfTool(tool) {
+    if (tool.startsWith('run_') || RUN_PORTFOLIO_TOOLS.has(tool))
+        return 'run';
+    if (tool.startsWith('jobshop_'))
+        return 'jobshop';
+    return null;
+}
+export async function fetchAppStates(baseUrl, token, fetchImpl = fetch) {
+    try {
+        const res = await fetchImpl(`${baseUrl}/api/feature-flags/me`, {
+            headers: { Authorization: `Bearer ${token}`, 'X-Requested-With': 'ConradPM-Native' },
+            signal: AbortSignal.timeout(8_000),
+        });
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        if (!Array.isArray(body.apps))
+            return null;
+        return body.apps
+            .filter((a) => !!a && typeof a.id === 'string')
+            .map((a) => ({ id: a.id, installed: !!a.installed, enabled: !!a.enabled, available: a.available }));
+    }
+    catch {
+        return null;
+    }
+}
+export function appsOff(tools, apps) {
+    const out = [];
+    for (const app of ['run', 'jobshop']) {
+        const n = tools.filter((t) => appOfTool(t.name) === app).length;
+        if (n === 0)
+            continue;
+        const s = apps.find((a) => a.id === app);
+        if (!s)
+            continue;
+        if (s.available === false)
+            out.push({ app, tools: n, state: 'not offered' });
+        else if (!s.installed)
+            out.push({ app, tools: n, state: 'not added' });
+        else if (!s.enabled)
+            out.push({ app, tools: n, state: 'off' });
+    }
+    return out;
+}
+export async function newerReleases(installed, latest, fetchImpl = fetch) {
+    if (!parseSemver(installed) || !parseSemver(latest) || compareVersions(latest, installed) <= 0)
+        return [];
+    try {
+        const res = await fetchImpl('https://registry.npmjs.org/@nonbot/mcp', {
+            headers: { Accept: 'application/json' },
+            signal: AbortSignal.timeout(8_000),
+        });
+        if (!res.ok)
+            return null;
+        const doc = (await res.json());
+        const out = [];
+        for (const [v, t] of Object.entries(doc.time ?? {})) {
+            if (!parseSemver(v) || /-/.test(v))
+                continue;
+            if (compareVersions(v, installed) > 0 && compareVersions(v, latest) <= 0 && typeof t === 'string') {
+                out.push({ version: v, date: t.slice(0, 10) });
+            }
+        }
+        return out.sort((a, b) => compareVersions(a.version, b.version));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/mcp-config.js

@@ -0,0 +1,202 @@
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join, resolve, isAbsolute } from 'node:path';
+export const LEGACY_MCP_NAMES = ['portfolio-mcp', 'context-graph', 'jobshop-mcp'];
+const LAUNCH = new WeakMap();
+export function launchSpecOf(entry) {
+    return LAUNCH.get(entry);
+}
+export function isNonbotRemoteUrl(value) {
+    if (!value)
+        return false;
+    try {
+        const u = new URL(value);
+        return u.protocol === 'https:' && u.hostname.toLowerCase().replace(/\.$/, '') === 'mcp.non.bot';
+    }
+    catch {
+        return false;
+    }
+}
+export function projectServerApproved(name, dir, claudeJson, home, read) {
+    const enabled = new Set();
+    const disabled = new Set();
+    let all = false;
+    const takeFrom = (o, mayApprove) => {
+        if (!o || typeof o !== 'object')
+            return;
+        const r = o;
+        if (Array.isArray(r.disabledMcpjsonServers))
+            for (const n of r.disabledMcpjsonServers)
+                if (typeof n === 'string')
+                    disabled.add(n);
+        if (!mayApprove)
+            return;
+        if (Array.isArray(r.enabledMcpjsonServers))
+            for (const n of r.enabledMcpjsonServers)
+                if (typeof n === 'string')
+                    enabled.add(n);
+        if (r.enableAllProjectMcpServers === true)
+            all = true;
+    };
+    let real = dir;
+    try {
+        real = realpathSync(dir);
+    }
+    catch {
+    }
+    takeFrom(claudeJson?.projects?.[dir], true);
+    if (real !== dir)
+        takeFrom(claudeJson?.projects?.[real], true);
+    takeFrom(parse(read(join(home, '.claude', 'settings.json'))), true);
+    takeFrom(parse(read(join(dir, '.claude', 'settings.json'))), false);
+    takeFrom(parse(read(join(dir, '.claude', 'settings.local.json'))), false);
+    if (disabled.has(name))
+        return false;
+    return enabled.has(name) || all;
+}
+function stringMap(v) {
+    const out = {};
+    if (v && typeof v === 'object') {
+        for (const [k, val] of Object.entries(v))
+            if (typeof val === 'string')
+                out[k] = val;
+    }
+    return out;
+}
+function defaultReadFile(path) {
+    try {
+        return existsSync(path) ? readFileSync(path, 'utf-8') : null;
+    }
+    catch {
+        return null;
+    }
+}
+function tilde(path, home) {
+    return path.startsWith(home) ? '~' + path.slice(home.length) : path;
+}
+export function classifyServer(name, server, baseDir) {
+    const args = Array.isArray(server.args) ? server.args.filter((a) => typeof a === 'string') : [];
+    const command = typeof server.command === 'string' ? server.command : '';
+    const url = typeof server.url === 'string' ? server.url : '';
+    if (isNonbotRemoteUrl(url) || args.some(isNonbotRemoteUrl)) {
+        return { kind: 'remote' };
+    }
+    const spec = args.find((a) => /^@nonbot\/mcp(@[^\s]+)?$/.test(a));
+    if (spec) {
+        const at = spec.indexOf('@', 1);
+        const version = at > 0 ? spec.slice(at + 1) : undefined;
+        return { kind: 'npx', pinned: version && version !== 'latest' ? version : undefined };
+    }
+    if (basename(command) === 'nonbot-mcp' || basename(command) === 'nonbot-mcp.cmd') {
+        return { kind: 'global' };
+    }
+    const script = [command, ...args].find((a) => /nonbot-mcp[\\/]+dist[\\/]+stdio\.js$/.test(a));
+    if (script) {
+        const abs = isAbsolute(script) ? script : resolve(baseDir, script);
+        return { kind: 'checkout', checkoutDir: dirname(dirname(abs)) };
+    }
+    if (name === 'nonbot')
+        return { kind: 'unknown' };
+    return null;
+}
+function serversIn(json) {
+    const servers = json?.mcpServers;
+    if (!servers || typeof servers !== 'object')
+        return [];
+    return Object.entries(servers).filter(([, v]) => v !== null && typeof v === 'object');
+}
+function parse(text) {
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+export function scanMcpConfigs(deps = {}) {
+    const home = deps.home ?? homedir();
+    const cwd = deps.cwd ?? process.cwd();
+    const platform = deps.platform ?? process.platform;
+    const read = deps.readFile ?? defaultReadFile;
+    const names = new Set();
+    const where = new Map();
+    const nonbot = [];
+    const locations = [];
+    const seenFiles = new Set();
+    const take = (source, json, baseDir, scope, file, dir) => {
+        for (const [name, server] of serversIn(json)) {
+            names.add(name);
+            if (!where.has(name))
+                where.set(name, source);
+            locations.push({ name, source, scope, file, ...(dir ? { dir } : {}) });
+            const c = classifyServer(name, server, baseDir);
+            if (c) {
+                const approved = scope !== 'project' || (!!dir && projectServerApproved(name, dir, claudeJson, home, read));
+                const entry = { source, name, ...c, scope, ...(dir ? { dir } : {}), approved };
+                nonbot.push(entry);
+                LAUNCH.set(entry, {
+                    command: typeof server.command === 'string' ? server.command : undefined,
+                    args: Array.isArray(server.args) ? server.args.filter((a) => typeof a === 'string') : [],
+                    env: stringMap(server.env),
+                    url: typeof server.url === 'string' ? server.url : undefined,
+                    headers: stringMap(server.headers),
+                    cwd: baseDir,
+                });
+            }
+        }
+    };
+    const claudeJsonPath = join(home, '.claude.json');
+    const claudeJson = parse(read(claudeJsonPath));
+    const projectDirs = [];
+    if (claudeJson) {
+        take('~/.claude.json', claudeJson, home, 'user', claudeJsonPath);
+        if (claudeJson.projects && typeof claudeJson.projects === 'object') {
+            for (const [dir, proj] of Object.entries(claudeJson.projects)) {
+                take(`~/.claude.json (${tilde(dir, home)})`, proj, dir, 'local', claudeJsonPath, dir);
+                projectDirs.push(dir);
+            }
+        }
+    }
+    const mcpJsonDirs = [];
+    for (let d = resolve(cwd);; d = dirname(d)) {
+        mcpJsonDirs.push(d);
+        if (d === dirname(d) || d === home)
+            break;
+    }
+    mcpJsonDirs.push(...projectDirs);
+    for (const dir of mcpJsonDirs) {
+        const file = join(dir, '.mcp.json');
+        if (seenFiles.has(file))
+            continue;
+        seenFiles.add(file);
+        const json = parse(read(file));
+        if (json)
+            take(tilde(file, home), json, dir, 'project', file, dir);
+    }
+    if (platform === 'darwin') {
+        const desktop = desktopConfigPath(home);
+        const json = parse(read(desktop));
+        if (json)
+            take('Claude Desktop', json, home, 'desktop', desktop);
+    }
+    return { names, where, nonbot, locations };
+}
+export function desktopConfigPath(home = homedir()) {
+    return join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+}
+export function describeNonbotMcp(e, home = homedir()) {
+    switch (e.kind) {
+        case 'remote':
+            return 'remote (mcp.non.bot) · always current';
+        case 'npx':
+            return e.pinned ? `npx, pinned to ${e.pinned} · gets no updates` : 'npx @nonbot/mcp · updates itself';
+        case 'global':
+            return 'global install · update: npm i -g @nonbot/mcp';
+        case 'checkout':
+            return `source checkout ${e.checkoutDir ? tilde(e.checkoutDir, home) : ''}`.trim();
+        default:
+            return 'configured';
+    }
+}