@nonbot/cli 0.10.14 → 0.10.16

package/dist/lib/mcp-probe.js

@@ -0,0 +1,226 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+import { VERSION } from '../version.js';
+import { isNonbotRemoteUrl } from './mcp-config.js';
+export const MCP_PROTOCOL_VERSION = '2025-06-18';
+const INIT_PARAMS = {
+    protocolVersion: MCP_PROTOCOL_VERSION,
+    capabilities: {},
+    clientInfo: { name: 'nonbot-cli', version: VERSION },
+};
+const LOADER_ENV = /^(NODE_OPTIONS|NODE_PATH|BASH_ENV|ENV|PROMPT_COMMAND|DYLD_.*|LD_.*)$/i;
+export function safeConfigEnv(env) {
+    const out = {};
+    for (const [k, v] of Object.entries(env))
+        if (!LOADER_ENV.test(k))
+            out[k] = v;
+    return out;
+}
+function toolsFrom(result) {
+    const r = (result ?? {});
+    const tools = Array.isArray(r.tools) ? r.tools.filter((t) => t && typeof t === 'object') : [];
+    return { tools, next: typeof r.nextCursor === 'string' && r.nextCursor ? r.nextCursor : undefined };
+}
+function serverInfo(result) {
+    const info = (result ?? {}).serverInfo ?? {};
+    return {
+        name: typeof info.name === 'string' ? info.name.slice(0, 80) : undefined,
+        version: typeof info.version === 'string' ? info.version.slice(0, 40) : undefined,
+    };
+}
+function finish(started, now, parts) {
+    return { ok: false, ms: now() - started, tools: [], toolBytes: 0, ...parts };
+}
+export async function probeStdio(spec, deps = {}) {
+    const now = deps.now ?? (() => Date.now());
+    const started = now();
+    if (!spec.command)
+        return finish(started, now, { error: 'no command in the config' });
+    const spawnImpl = deps.spawnImpl ?? ((cmd, args, opts) => nodeSpawn(cmd, args, { ...opts, stdio: ['pipe', 'pipe', 'ignore'], shell: process.platform === 'win32' }));
+    const timeoutMs = deps.timeoutMs ?? 45_000;
+    let child;
+    try {
+        child = spawnImpl(spec.command, spec.args, { cwd: spec.cwd, env: { ...process.env, ...safeConfigEnv(spec.env) } });
+    }
+    catch {
+        return finish(started, now, { error: `could not start "${spec.command}"` });
+    }
+    return new Promise((resolve) => {
+        let done = false;
+        let buf = '';
+        let nextId = 1;
+        const waiting = new Map();
+        const end = (r) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            try {
+                child.stdin?.end();
+            }
+            catch { }
+            try {
+                child.kill('SIGTERM');
+            }
+            catch { }
+            resolve(r);
+        };
+        const timer = setTimeout(() => end(finish(started, now, { error: `no answer within ${Math.round(timeoutMs / 1000)}s` })), timeoutMs);
+        child.on('error', () => end(finish(started, now, { error: `could not start "${spec.command}"` })));
+        child.on('exit', (code) => end(finish(started, now, { error: `it exited (code ${code ?? '?'}) before answering` })));
+        child.stdout?.setEncoding('utf-8');
+        child.stdout?.on('data', (chunk) => {
+            buf += chunk;
+            if (buf.length > 8_000_000)
+                return end(finish(started, now, { error: 'answer too large' }));
+            let nl;
+            while ((nl = buf.indexOf('\n')) >= 0) {
+                const line = buf.slice(0, nl).trim();
+                buf = buf.slice(nl + 1);
+                if (!line)
+                    continue;
+                let msg;
+                try {
+                    msg = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (typeof msg.id === 'number' && waiting.has(msg.id)) {
+                    const cb = waiting.get(msg.id);
+                    waiting.delete(msg.id);
+                    cb(msg);
+                }
+            }
+        });
+        const send = (method, params) => new Promise((res) => {
+            const id = nextId++;
+            waiting.set(id, res);
+            child.stdin?.write(JSON.stringify({ jsonrpc: '2.0', id, method, ...(params ? { params } : {}) }) + '\n');
+        });
+        const notify = (method) => child.stdin?.write(JSON.stringify({ jsonrpc: '2.0', method }) + '\n');
+        (async () => {
+            const init = await send('initialize', INIT_PARAMS);
+            if (init.error)
+                return end(finish(started, now, { error: 'it refused the handshake' }));
+            const info = serverInfo(init.result);
+            notify('notifications/initialized');
+            const all = [];
+            let cursor;
+            for (let page = 0; page < 20; page++) {
+                const res = await send('tools/list', cursor ? { cursor } : undefined);
+                if (res.error)
+                    return end(finish(started, now, { serverName: info.name, serverVersion: info.version, error: 'tools/list failed' }));
+                const { tools, next } = toolsFrom(res.result);
+                all.push(...tools);
+                if (!next)
+                    break;
+                cursor = next;
+            }
+            end({
+                ok: true,
+                ms: now() - started,
+                serverName: info.name,
+                serverVersion: info.version,
+                tools: all.map((t) => ({ name: String(t.name ?? '') })).filter((t) => t.name),
+                toolBytes: Buffer.byteLength(JSON.stringify({ tools: all })),
+            });
+        })().catch(() => end(finish(started, now, { error: 'unexpected answer' })));
+    });
+}
+export async function probeRemote(spec, deps = {}) {
+    const now = deps.now ?? (() => Date.now());
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const started = now();
+    if (!spec.url)
+        return finish(started, now, { error: 'no url in the config' });
+    const headers = {
+        'Content-Type': 'application/json',
+        Accept: 'application/json, text/event-stream',
+        ...spec.headers,
+    };
+    if (!Object.keys(headers).some((k) => k.toLowerCase() === 'authorization') && deps.fallbackBearer && isNonbotRemoteUrl(spec.url)) {
+        headers.Authorization = `Bearer ${deps.fallbackBearer}`;
+    }
+    let nextId = 1;
+    const call = async (method, params, isNotification = false) => {
+        const body = isNotification
+            ? { jsonrpc: '2.0', method }
+            : { jsonrpc: '2.0', id: nextId++, method, ...(params ? { params } : {}) };
+        const res = await fetchImpl(spec.url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+            redirect: 'manual',
+            signal: AbortSignal.timeout(deps.timeoutMs ?? 15_000),
+        });
+        const session = res.headers.get('mcp-session-id');
+        if (session)
+            headers['Mcp-Session-Id'] = session;
+        if (isNotification)
+            return null;
+        if (res.status === 401 || res.status === 403)
+            throw new Error(`auth ${res.status}`);
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const text = await res.text();
+        if ((res.headers.get('content-type') ?? '').includes('text/event-stream')) {
+            for (const line of text.split('\n')) {
+                if (!line.startsWith('data:'))
+                    continue;
+                try {
+                    const msg = JSON.parse(line.slice(5).trim());
+                    if (msg.result !== undefined || msg.error)
+                        return msg;
+                }
+                catch { }
+            }
+            return { error: { message: 'no result' } };
+        }
+        return JSON.parse(text);
+    };
+    try {
+        const init = await call('initialize', INIT_PARAMS);
+        if (!init || init.error)
+            return finish(started, now, { error: 'it refused the handshake' });
+        const info = serverInfo(init.result);
+        await call('notifications/initialized', undefined, true).catch(() => null);
+        const all = [];
+        let cursor;
+        for (let page = 0; page < 20; page++) {
+            const res = await call('tools/list', cursor ? { cursor } : undefined);
+            if (!res || res.error)
+                return finish(started, now, { serverName: info.name, serverVersion: info.version, error: 'tools/list failed' });
+            const { tools, next } = toolsFrom(res.result);
+            all.push(...tools);
+            if (!next)
+                break;
+            cursor = next;
+        }
+        return {
+            ok: true,
+            ms: now() - started,
+            serverName: info.name,
+            serverVersion: info.version,
+            tools: all.map((t) => ({ name: String(t.name ?? '') })).filter((t) => t.name),
+            toolBytes: Buffer.byteLength(JSON.stringify({ tools: all })),
+        };
+    }
+    catch (e) {
+        const m = e.message;
+        return finish(started, now, { error: /^auth/.test(m) ? 'the server refused the token' : /^HTTP/.test(m) ? `the server answered ${m}` : 'could not reach it' });
+    }
+}
+export function probeMcp(spec, deps = {}) {
+    return spec.url && !spec.command ? probeRemote(spec, deps) : probeStdio(spec, deps);
+}
+export function toolGroups(tools) {
+    const counts = new Map();
+    for (const t of tools) {
+        const g = t.name.includes('_') ? t.name.slice(0, t.name.indexOf('_')) : t.name;
+        counts.set(g, (counts.get(g) ?? 0) + 1);
+    }
+    return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+}
+export function estimateTokens(bytes) {
+    return Math.round(bytes / 4);
+}

package/dist/lib/mcp-status.js

@@ -0,0 +1,127 @@
+import { existsSync, readFileSync, readdirSync, lstatSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fetchLatestVersion, compareVersions, parseSemver } from './update-check.js';
+import { scanMcpConfigs, describeNonbotMcp } from './mcp-config.js';
+export const MCP_LATEST_URL = 'https://registry.npmjs.org/@nonbot/mcp/latest';
+export const MCP_REMOTE_URL = 'https://mcp.non.bot/';
+function readVersion(pkgJsonPath) {
+    try {
+        if (!existsSync(pkgJsonPath))
+            return null;
+        const v = JSON.parse(readFileSync(pkgJsonPath, 'utf-8')).version;
+        return parseSemver(v) ? String(v) : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function defaultGlobalRoot(execPath = process.execPath, platform = process.platform) {
+    return platform === 'win32'
+        ? join(dirname(execPath), 'node_modules')
+        : join(dirname(dirname(execPath)), 'lib', 'node_modules');
+}
+export function globalMcpIsLinked(globalRoot = defaultGlobalRoot()) {
+    try {
+        return lstatSync(join(globalRoot, '@nonbot', 'mcp')).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+export function npxCachedMcpVersion(env = process.env, home = homedir()) {
+    const root = join(env.npm_config_cache || join(home, '.npm'), '_npx');
+    let best = null;
+    let dirs = [];
+    try {
+        dirs = readdirSync(root);
+    }
+    catch {
+        return null;
+    }
+    for (const hash of dirs) {
+        const v = readVersion(join(root, hash, 'node_modules', '@nonbot', 'mcp', 'package.json'));
+        if (v && (best === null || compareVersions(v, best) > 0))
+            best = v;
+    }
+    return best;
+}
+export async function remoteMcpVersion(fetchImpl = fetch) {
+    try {
+        const res = await fetchImpl(MCP_REMOTE_URL, {
+            headers: { Accept: 'text/html' },
+            signal: AbortSignal.timeout(3_000),
+        });
+        if (!res.ok)
+            return null;
+        const m = /version\s+(\d{1,6}\.\d{1,6}\.\d{1,6})\b/.exec(await res.text());
+        return m ? m[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function installedMcpVersion(entry, deps = {}) {
+    switch (entry.kind) {
+        case 'checkout':
+            return entry.checkoutDir ? readVersion(join(entry.checkoutDir, 'package.json')) : null;
+        case 'npx':
+            return entry.pinned && parseSemver(entry.pinned) ? entry.pinned : npxCachedMcpVersion(deps.env, deps.home);
+        case 'global':
+            return readVersion(join(deps.globalRoot ?? defaultGlobalRoot(), '@nonbot', 'mcp', 'package.json'));
+        case 'remote':
+            return remoteMcpVersion(deps.fetchImpl);
+        default:
+            return null;
+    }
+}
+export async function nonbotMcpStatuses(deps = {}) {
+    const entries = scanMcpConfigs(deps).nonbot;
+    if (entries.length === 0)
+        return [];
+    const [latest, installed] = await Promise.all([
+        fetchLatestVersion({ url: MCP_LATEST_URL, fetchImpl: deps.fetchImpl }),
+        Promise.all(entries.map((e) => installedMcpVersion(e, deps))),
+    ]);
+    return entries.map((entry, i) => ({ entry, installed: installed[i] ?? null, latest }));
+}
+export function mcpRow(s, home = homedir()) {
+    const how = describeNonbotMcp(s.entry, home);
+    const v = s.installed ? `v${s.installed} · ` : '';
+    const behind = !!(s.installed && s.latest && compareVersions(s.latest, s.installed) > 0);
+    const e = s.entry;
+    if (e.kind === 'npx' && e.pinned) {
+        return {
+            sigil: '⚠',
+            detail: `${v}npx, pinned · gets no updates`,
+            hint: 'unpin it: claude mcp remove nonbot && claude mcp add nonbot -- npx -y @nonbot/mcp',
+        };
+    }
+    if (!behind) {
+        if (e.kind === 'npx' && !s.installed) {
+            return { sigil: '✓', detail: `npx @nonbot/mcp · fetches ${s.latest ? `v${s.latest}` : 'the latest'} on first start` };
+        }
+        return { sigil: '✓', detail: `${v}${how}` };
+    }
+    const out = `v${s.installed} · ${shortKind(e.kind)} · v${s.latest} is out`;
+    switch (e.kind) {
+        case 'npx':
+            return { sigil: 'ℹ', detail: out, hint: 'restart Claude Code (or /mcp → Reconnect) and npx fetches it' };
+        case 'global':
+            return { sigil: '⚠', detail: out, hint: 'update it: nonbot update mcp' };
+        case 'checkout':
+            return {
+                sigil: 'ℹ',
+                detail: out,
+                hint: `update the checkout: cd ${e.checkoutDir ? tildePath(e.checkoutDir, home) : '<checkout>'} && git pull && npm run build`,
+            };
+        default:
+            return { sigil: 'ℹ', detail: out };
+    }
+}
+function shortKind(kind) {
+    return kind === 'npx' ? 'npx @nonbot/mcp' : kind === 'checkout' ? 'source checkout' : kind === 'global' ? 'global install' : kind;
+}
+function tildePath(p, home) {
+    return p.startsWith(home) ? '~' + p.slice(home.length) : p;
+}

package/dist/lib/mcp-trust.js

@@ -0,0 +1,63 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync, chmodSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+function configDir() {
+    const override = process.env.NONBOT_CONFIG_DIR;
+    return override && override.length > 0 ? override : join(homedir(), '.config', 'nonbot');
+}
+export function trustFilePath(dir = configDir()) {
+    return join(dir, 'mcp-trust.json');
+}
+function realDir(dir) {
+    try {
+        return realpathSync(dir);
+    }
+    catch {
+        return dir;
+    }
+}
+export function launchFingerprint(spec) {
+    const env = Object.keys(spec.env).sort().map((k) => [k, spec.env[k]]);
+    const payload = JSON.stringify({ command: spec.command ?? null, args: spec.args, url: spec.url ?? null, env, cwd: realDir(spec.cwd) });
+    return createHash('sha256').update(payload).digest('hex');
+}
+function readRecords(file) {
+    try {
+        if (!existsSync(file))
+            return [];
+        const json = JSON.parse(readFileSync(file, 'utf-8'));
+        return Array.isArray(json.approved)
+            ? json.approved.filter((r) => r && typeof r === 'object' && typeof r.fingerprint === 'string')
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function isRememberedTrust(entry, spec, file = trustFilePath()) {
+    if (!entry.dir)
+        return false;
+    const dir = realDir(entry.dir);
+    const fp = launchFingerprint(spec);
+    return readRecords(file).some((r) => r.dir === dir && r.name === entry.name && r.fingerprint === fp);
+}
+export function mayStartEntry(entry, spec, isRemembered = (e, s) => isRememberedTrust(e, s)) {
+    if (entry.approved !== false)
+        return true;
+    return isRemembered(entry, spec);
+}
+export function rememberTrust(entry, spec, file = trustFilePath(), now = new Date()) {
+    if (!entry.dir)
+        return;
+    const dir = realDir(entry.dir);
+    const records = readRecords(file).filter((r) => !(r.dir === dir && r.name === entry.name));
+    records.push({ dir, name: entry.name, fingerprint: launchFingerprint(spec), approvedAt: now.toISOString() });
+    const parent = join(file, '..');
+    mkdirSync(parent, { recursive: true, mode: 0o700 });
+    const tmp = `${file}.tmp`;
+    writeFileSync(tmp, JSON.stringify({ approved: records.slice(-200) }, null, 2) + '\n', { mode: 0o600 });
+    chmodSync(tmp, 0o600);
+    renameSync(tmp, file);
+    chmodSync(file, 0o600);
+}

package/dist/lib/output.js

@@ -144,11 +144,40 @@ const WORDMARK_LINES = [
 export const WORDMARK_WIDTH = 63;
 export const WORDMARK_HEIGHT = 6;
 export const WORDMARK_DOT_COLS = [31, 32, 33];
+export const WORDMARK_GRADIENT_STOPS = [
+    [0x5e, 0xd8, 0xf0],
+    [0x6c, 0x8c, 0xff],
+    [0x9b, 0x6c, 0xf0],
+    [0xe0, 0x7a, 0xd8],
+];
+const WORDMARK_SHEEN = [0.24, 0.15, 0.07, 0, 0, 0];
+const WORDMARK_SHADOW = 0.55;
+function lerp(a, b, t) {
+    return a + (b - a) * t;
+}
+export function wordmarkCellColor(col, row, shadow = false) {
+    const span = WORDMARK_WIDTH - 1 + (WORDMARK_HEIGHT - 1) * 1.5;
+    const t = Math.min(1, Math.max(0, (col + row * 1.5) / span));
+    const stops = WORDMARK_GRADIENT_STOPS;
+    const seg = Math.min(stops.length - 2, Math.floor(t * (stops.length - 1)));
+    const local = t * (stops.length - 1) - seg;
+    const a = stops[seg];
+    const b = stops[seg + 1];
+    let rgb = [lerp(a[0], b[0], local), lerp(a[1], b[1], local), lerp(a[2], b[2], local)];
+    if (shadow) {
+        rgb = [rgb[0] * WORDMARK_SHADOW, rgb[1] * WORDMARK_SHADOW, rgb[2] * WORDMARK_SHADOW];
+    }
+    else {
+        const sheen = WORDMARK_SHEEN[row] ?? 0;
+        rgb = [lerp(rgb[0], 255, sheen), lerp(rgb[1], 255, sheen), lerp(rgb[2], 255, sheen)];
+    }
+    return [Math.round(rgb[0]), Math.round(rgb[1]), Math.round(rgb[2])];
+}
 function hexFg(hex) {
     const n = parseInt(hex.slice(1), 16);
     return `\x1b[38;2;${(n >> 16) & 255};${(n >> 8) & 255};${n & 255}m`;
 }
-function paintWordmarkLine(line, stream = process.stdout) {
+function paintWordmarkLine(line, row, stream = process.stdout) {
     if (!isTTY(stream))
         return line;
     const chars = Array.from(line);
@@ -159,11 +188,16 @@ function paintWordmarkLine(line, stream = process.stdout) {
             out += ' ';
             continue;
         }
-        const colour = WORDMARK_DOT_COLS.includes(i) ? BRAND.blue : BRAND.cream;
-        out += BRAND.bold + colour + ch + BRAND.reset;
+        const [r, g, b] = wordmarkCellColor(i, row, ch !== '█');
+        out += `${BRAND.bold}\x1b[38;2;${r};${g};${b}m${ch}${BRAND.reset}`;
     }
     return out;
 }
+export function wordmarkArt(opts = {}) {
+    const stream = opts.stream ?? process.stdout;
+    const indent = opts.indent ?? '';
+    return WORDMARK_LINES.map((line, row) => indent + paintWordmarkLine(line, row, stream)).join('\n');
+}
 export function terminalWidth(width) {
     const cols = width ?? (process.stdout && process.stdout.columns) ?? 80;
     const min = WORDMARK_WIDTH + 6;
@@ -180,7 +214,7 @@ function trackedCaps(s) {
 export function wordmark(version, opts = {}) {
     const stream = opts.stream ?? process.stdout;
     const state = opts.state;
-    const headLines = WORDMARK_LINES.map((line) => paintWordmarkLine(line, stream));
+    const headLines = WORDMARK_LINES.map((line, row) => paintWordmarkLine(line, row, stream));
     const parts = [c.cyan(trackedCaps('DAEMON'), stream)];
     if (version) {
         parts.push(c.muted('·', stream));
@@ -207,7 +241,7 @@ export function renderWordmarkWithBadge(opts = {}) {
         red: (s) => c.red(s, stream),
         muted: (s) => c.muted(s, stream),
     };
-    const lines = WORDMARK_LINES.map((wm) => paintWordmarkLine(wm, stream));
+    const lines = WORDMARK_LINES.map((wm, row) => paintWordmarkLine(wm, row, stream));
     lines.push('');
     lines.push(`  ${dotColored[color]('●')}  ${dotColored[color](label)}`);
     for (const s of sublines) {
@@ -360,7 +394,7 @@ export function compactMasthead(version, opts = {}) {
     const badgeColor = opts.badgeColor ?? 'green';
     const badgeLabel = opts.badgeLabel ?? 'CONNECTED';
     const dotGlyph = asciiOnly() ? '*' : '●';
-    const brand = `${c.bold(c.cream('non.bot', stream), stream)}${c.blue('.', stream)}`;
+    const brand = c.bold(c.cream('non.bot', stream), stream);
     const badge = colorize(`${dotGlyph} ${badgeLabel}`, badgeColor, stream);
     const sep = c.muted('·', stream);
     const tail = [c.muted(`daemon ${version}`, stream), sep, c.muted(state, stream)].join(' ');

package/dist/lib/quickstart-menu.js

@@ -0,0 +1,86 @@
+const MOUSE_ON = '\x1b[?1000h\x1b[?1006h';
+const MOUSE_OFF = '\x1b[?1000l\x1b[?1006l';
+const ASK_CURSOR = '\x1b[6n';
+const CURSOR_REPORT = /\x1b\[(\d+);(\d+)R/;
+const MOUSE_SGR = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/g;
+export function interpretInput(chunk, state, linesBelowHelp) {
+    let rest = chunk;
+    const cur = CURSOR_REPORT.exec(rest);
+    if (cur) {
+        state.helpRow = Number(cur[1]) - linesBelowHelp;
+        rest = rest.replace(CURSOR_REPORT, '');
+    }
+    let sawMouse = false;
+    for (const m of rest.matchAll(MOUSE_SGR)) {
+        sawMouse = true;
+        const button = Number(m[1]);
+        const y = Number(m[3]);
+        const press = m[4] === 'M';
+        if (press && button === 0 && state.helpRow !== null && y === state.helpRow)
+            return 'help';
+    }
+    rest = rest.replace(MOUSE_SGR, '');
+    if (rest === '')
+        return null;
+    if (sawMouse && rest.trim() === '')
+        return null;
+    if (/^[hH][\r\n]*$/.test(rest))
+        return 'help';
+    return 'exit';
+}
+export function linesBelow(printed, marker) {
+    const at = printed.indexOf(marker);
+    if (at < 0)
+        return 0;
+    const lineStart = printed.lastIndexOf('\n', at) + 1;
+    return (printed.slice(lineStart).match(/\n/g) ?? []).length;
+}
+export function menuIsInteractive(io, env = process.env) {
+    if (!io.stdin.isTTY || !io.stdout.isTTY)
+        return false;
+    if (env.CI || env.NONBOT_NO_MENU === '1')
+        return false;
+    return typeof io.stdin.setRawMode === 'function';
+}
+export function waitForMenuChoice(io, linesBelowHelp) {
+    const { stdin, stdout } = io;
+    const state = { helpRow: null };
+    return new Promise((resolve) => {
+        let done = false;
+        const finish = (choice) => {
+            if (done)
+                return;
+            done = true;
+            stdin.off('data', onData);
+            process.off('SIGINT', onSig);
+            process.off('SIGTERM', onSig);
+            try {
+                stdout.write(MOUSE_OFF);
+            }
+            catch { }
+            try {
+                stdin.setRawMode(false);
+            }
+            catch { }
+            stdin.pause();
+            resolve(choice);
+        };
+        const onData = (buf) => {
+            const choice = interpretInput(buf.toString('utf-8'), state, linesBelowHelp);
+            if (choice)
+                finish(choice);
+        };
+        const onSig = () => finish('exit');
+        try {
+            stdin.setRawMode(true);
+        }
+        catch {
+            return resolve('exit');
+        }
+        stdin.resume();
+        stdin.on('data', onData);
+        process.once('SIGINT', onSig);
+        process.once('SIGTERM', onSig);
+        stdout.write(MOUSE_ON + ASK_CURSOR);
+    });
+}

package/dist/lib/update-check.js

@@ -35,7 +35,7 @@ export function isNewerVersion(latest, current) {
     return compareVersions(latest, current) > 0;
 }
 export function updateAvailableLine(current, latest) {
-    return `Update available: @nonbot/cli ${current} → ${latest}  (npm i -g @nonbot/cli)`;
+    return `Update available: @nonbot/cli ${current} → ${latest}  (run: nonbot update)`;
 }
 export async function fetchLatestVersion(opts = {}) {
     const fetchImpl = opts.fetchImpl ?? fetch;

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.10.14';
+export const VERSION = '0.10.16';

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@nonbot/cli",
-  "version": "0.10.14",
+  "version": "0.10.16",
   "type": "module",
   "description": "The local host for non.bot ▶ Run — opens a terminal on your machine and starts the work in your linked repo.",
-  "license": "UNLICENSED",
+  "license": "SEE LICENSE IN LICENSE",
   "bin": {
     "nonbot": "dist/index.js"
   },