@nonbot/cli 0.5.13

package/dist/commands/doctor.js

@@ -0,0 +1,262 @@
+import { spawnSync } from 'node:child_process';
+import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { loadAuth } from '../lib/auth.js';
+import { resolveTerminal } from '../lib/terminal.js';
+import { VERSION } from '../version.js';
+import { header, statusRow, errorBlock } from '../lib/output.js';
+const HEARTBEAT_FRESH_MS = 15_000;
+const PROVIDER_CLIS = ['claude', 'codex', 'gemini'];
+const EXPECTED_MCPS = ['portfolio-mcp', 'jobshop-mcp', 'context-graph'];
+const EXPECTED_SKILLS = [];
+function readConfiguredMcpNames() {
+    const out = new Set();
+    try {
+        const path = join(homedir(), '.claude.json');
+        if (!existsSync(path))
+            return out;
+        const json = JSON.parse(readFileSync(path, 'utf-8'));
+        const projects = json?.projects && typeof json.projects === 'object' ? json.projects : null;
+        if (projects) {
+            for (const proj of Object.values(projects)) {
+                const servers = proj?.mcpServers;
+                if (servers && typeof servers === 'object') {
+                    for (const name of Object.keys(servers))
+                        out.add(name);
+                }
+            }
+        }
+        const top = json?.mcpServers;
+        if (top && typeof top === 'object') {
+            for (const name of Object.keys(top))
+                out.add(name);
+        }
+    }
+    catch {
+    }
+    return out;
+}
+function isSkillInstalled(skillName) {
+    const base = join(homedir(), '.claude');
+    const candidates = [];
+    const skillsDir = join(base, 'skills');
+    if (existsSync(skillsDir))
+        candidates.push(skillsDir);
+    const pluginsDir = join(base, 'plugins');
+    if (existsSync(pluginsDir)) {
+        try {
+            for (const entry of readdirSync(pluginsDir)) {
+                const inner = join(pluginsDir, entry, 'skills');
+                if (existsSync(inner))
+                    candidates.push(inner);
+                try {
+                    const sub = join(pluginsDir, entry);
+                    if (statSync(sub).isDirectory()) {
+                        for (const child of readdirSync(sub)) {
+                            const inner2 = join(sub, child, 'skills');
+                            if (existsSync(inner2))
+                                candidates.push(inner2);
+                        }
+                    }
+                }
+                catch {
+                }
+            }
+        }
+        catch {
+        }
+    }
+    for (const dir of candidates) {
+        try {
+            for (const entry of readdirSync(dir)) {
+                if (entry === skillName)
+                    return true;
+                const skillMd = join(dir, entry, 'SKILL.md');
+                if (existsSync(skillMd)) {
+                    try {
+                        const head = readFileSync(skillMd, 'utf-8').slice(0, 1024);
+                        const m = head.match(/^name:\s*([^\s\n]+)/m);
+                        if (m && m[1] === skillName)
+                            return true;
+                    }
+                    catch {
+                    }
+                }
+            }
+        }
+        catch {
+        }
+    }
+    return false;
+}
+function probe(cmd, args, interpret = (out) => ({
+    installed: true,
+    version: out || undefined,
+})) {
+    try {
+        const res = spawnSync(cmd, args, { encoding: 'utf-8' });
+        if (res.error)
+            return { installed: false };
+        if (res.status === 0)
+            return interpret((res.stdout ?? '').trim());
+        const stderr = (res.stderr ?? '').trim();
+        return { installed: false, version: stderr ? stderr.slice(0, 200) : undefined };
+    }
+    catch (e) {
+        return { installed: false, version: e.message };
+    }
+}
+function defaultCheckBinary(bin) {
+    if (bin.startsWith('mcp:')) {
+        const name = bin.slice('mcp:'.length);
+        return { installed: readConfiguredMcpNames().has(name) };
+    }
+    if (bin.startsWith('skill:')) {
+        const name = bin.slice('skill:'.length);
+        return { installed: isSkillInstalled(name) };
+    }
+    if (bin === 'iterm-running') {
+        return probe('osascript', ['-e', 'tell application "System Events" to ((name of every process) contains "iTerm2")'], (out) => ({ installed: out === 'true' }));
+    }
+    if (bin === 'iterm-applescript') {
+        return probe('osascript', ['-e', 'tell application "iTerm" to get version']);
+    }
+    try {
+        const res = spawnSync(bin, ['--version'], { encoding: 'utf-8' });
+        if (res.error)
+            return { installed: false };
+        if (res.status === 0)
+            return { installed: true, version: (res.stdout ?? '').trim() || undefined };
+        return { installed: true };
+    }
+    catch {
+        return { installed: false };
+    }
+}
+export async function runDoctorCommand(args = [], deps = {}) {
+    void args;
+    const log = deps.log ?? ((s) => process.stdout.write(s));
+    const errLog = deps.errLog ?? ((s) => process.stderr.write(s));
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const loader = deps.loadAuth ?? loadAuth;
+    const now = deps.now ?? (() => Date.now());
+    const checkBinary = deps.checkBinary ?? defaultCheckBinary;
+    let exitCode = 0;
+    log(header('non.bot doctor', `v${VERSION}  ·  ${process.platform}/${process.arch}`) + '\n');
+    log('\n');
+    const auth = await loader();
+    if (!auth) {
+        log(errorBlock('Not logged in', 'Run `nonbot login` to authenticate.'));
+        return 1;
+    }
+    log(statusRow('✓', 'Auth', `logged in as ${auth.email}`) + '\n');
+    let serverOk = false;
+    try {
+        const res = await fetchImpl(`${auth.baseUrl}/api/auth/me`, {
+            headers: {
+                Authorization: `Bearer ${auth.pat}`,
+                'X-Requested-With': 'ConradPM-Native',
+                'X-CLI-Version': VERSION,
+            },
+        });
+        if (res.ok) {
+            serverOk = true;
+            log(statusRow('✓', 'Server reachable', `${auth.baseUrl} · PAT valid`) + '\n');
+        }
+        else if (res.status === 401) {
+            errLog(statusRow('✗', 'Server', `PAT rejected (HTTP 401) — re-run: nonbot login`, { stream: process.stderr }) + '\n');
+            exitCode = 1;
+        }
+        else {
+            log(statusRow('⚠', 'Server', `returned HTTP ${res.status} for /api/auth/me`) + '\n');
+        }
+    }
+    catch (e) {
+        log(statusRow('⚠', 'Server', `Could not reach ${auth.baseUrl}: ${e.message}`) + '\n');
+    }
+    try {
+        const res = await fetchImpl(`${auth.baseUrl}/api/cli/daemon-status`, {
+            headers: {
+                Authorization: `Bearer ${auth.pat}`,
+                'X-Requested-With': 'ConradPM-Native',
+                'X-CLI-Version': VERSION,
+            },
+        });
+        if (res.ok) {
+            const body = (await res.json());
+            const last = body.lastHeartbeatAt;
+            if (typeof last === 'number' && now() - last <= HEARTBEAT_FRESH_MS) {
+                const ageSec = Math.round((now() - last) / 1000);
+                log(statusRow('✓', 'Daemon running', `last heartbeat ${ageSec}s ago`) + '\n');
+            }
+            else {
+                log(statusRow('✗', 'Daemon not running', 'no recent heartbeat — start with: nonbot daemon') + '\n');
+            }
+        }
+        else if (res.status === 401) {
+            log(statusRow('⚠', 'Daemon status unknown', '(auth rejected)') + '\n');
+        }
+        else {
+            log(statusRow('⚠', 'Daemon status unknown', `(HTTP ${res.status})`) + '\n');
+        }
+    }
+    catch (e) {
+        log(statusRow('⚠', 'Daemon status unknown', e.message) + '\n');
+    }
+    for (const bin of PROVIDER_CLIS) {
+        const r = checkBinary(bin);
+        if (r.installed) {
+            log(statusRow('✓', bin, r.version ? `(${r.version})` : '') + '\n');
+        }
+        else {
+            log(statusRow('⚠', bin, 'not on PATH') + '\n');
+        }
+    }
+    const profile = resolveTerminal(undefined);
+    const { cmd } = profile.launch('/tmp/nonbot-doctor-probe.sh');
+    const launcher = checkBinary(cmd);
+    if (launcher.installed) {
+        log(statusRow('✓', 'Terminal', `${profile.displayName} (launches via "${cmd}")`) + '\n');
+    }
+    else {
+        log(statusRow('⚠', 'Terminal', `${profile.displayName} — launcher "${cmd}" not found on PATH`) + '\n');
+    }
+    if (process.platform === 'darwin') {
+        const running = checkBinary('iterm-running');
+        if (running.installed) {
+            log(statusRow('✓', 'iTerm running', '') + '\n');
+        }
+        else {
+            log(statusRow('⚠', 'iTerm not running', 'to start iTerm:  open -a iTerm') + '\n');
+        }
+        const appl = checkBinary('iterm-applescript');
+        if (appl.installed) {
+            log(statusRow('✓', 'iTerm AppleScript reachable', appl.version ?? '') + '\n');
+        }
+        else {
+            log(statusRow('⚠', 'iTerm AppleScript', appl.version ? `probe failed: ${appl.version}` : 'probe failed') + '\n');
+            log('      ' + 'System Settings → Privacy & Security → Automation → allow your terminal to control iTerm.' + '\n');
+        }
+    }
+    for (const name of EXPECTED_MCPS) {
+        const r = checkBinary(`mcp:${name}`);
+        if (r.installed) {
+            log(statusRow('✓', `MCP ${name}`, '') + '\n');
+        }
+        else {
+            log(statusRow('⚠', `MCP ${name}`, 'not configured in ~/.claude.json') + '\n');
+        }
+    }
+    for (const name of EXPECTED_SKILLS) {
+        const r = checkBinary(`skill:${name}`);
+        if (r.installed) {
+            log(statusRow('✓', `Skill ${name}`, '') + '\n');
+        }
+        else {
+            log(statusRow('⚠', `Skill ${name}`, 'not installed under ~/.claude/skills/') + '\n');
+        }
+    }
+    void serverOk;
+    return exitCode;
+}

package/dist/commands/login.js

@@ -0,0 +1,112 @@
+import readline from 'node:readline';
+import { saveAuth } from '../lib/auth.js';
+import { VERSION } from '../version.js';
+import { c, statusRow, wordmark } from '../lib/output.js';
+const DEFAULT_BASE_URL = 'https://non.bot';
+export function parseLoginArgs(args) {
+    const opts = {};
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--token' && i + 1 < args.length) {
+            opts.token = args[++i];
+        }
+        else if (a === '--base-url' && i + 1 < args.length) {
+            opts.baseUrl = args[++i];
+        }
+    }
+    return opts;
+}
+async function promptForPat() {
+    process.stdout.write('First, generate a Personal Access Token at:\n');
+    process.stdout.write('  https://non.bot/settings/connections#api-tokens\n\n');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const rlAny = rl;
+        const originalWrite = rlAny._writeToOutput?.bind(rl);
+        if (originalWrite) {
+            let inPrompt = true;
+            rlAny._writeToOutput = (s) => {
+                if (inPrompt && s.includes('Paste your PAT')) {
+                    inPrompt = false;
+                    originalWrite(s);
+                    return;
+                }
+                if (s === '\r\n' || s === '\n') {
+                    originalWrite(s);
+                    return;
+                }
+                originalWrite('*'.repeat(s.length));
+            };
+        }
+        return await new Promise((resolve) => {
+            rl.question("Paste your PAT (starts with 'pat_'): ", (answer) => {
+                resolve(answer.trim());
+            });
+        });
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function runLoginCommand(args = [], deps = {}) {
+    const opts = parseLoginArgs(args);
+    const baseUrl = (opts.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const log = deps.log ?? ((s) => process.stdout.write(s));
+    const errLog = deps.errLog ?? ((s) => process.stderr.write(s));
+    let pat = opts.token?.trim() ?? '';
+    if (!pat) {
+        const reader = deps.readPat ?? promptForPat;
+        pat = (await reader()).trim();
+    }
+    if (!pat) {
+        errLog(statusRow('✗', 'No PAT provided', '', { stream: process.stderr }) + '\n');
+        return 1;
+    }
+    if (!pat.startsWith('pat_')) {
+        errLog(statusRow('✗', "Token doesn't look like a PAT", "should start with 'pat_'", { stream: process.stderr }) + '\n');
+        return 1;
+    }
+    let res;
+    try {
+        res = await fetchImpl(`${baseUrl}/api/auth/me`, {
+            headers: {
+                Authorization: `Bearer ${pat}`,
+                'X-Requested-With': 'ConradPM-Native',
+                'X-CLI-Version': VERSION,
+            },
+        });
+    }
+    catch (e) {
+        errLog(statusRow('✗', 'Network error', `${baseUrl}: ${e.message}`, { stream: process.stderr }) + '\n');
+        return 1;
+    }
+    if (!res.ok) {
+        errLog(statusRow('✗', `Login failed (HTTP ${res.status})`, 'Check the PAT and try again', { stream: process.stderr }) + '\n');
+        return 1;
+    }
+    let body;
+    try {
+        body = (await res.json());
+    }
+    catch {
+        errLog(statusRow('✗', 'Login failed', 'server returned non-JSON', { stream: process.stderr }) + '\n');
+        return 1;
+    }
+    if (!body.authenticated || !body.user?.email || !body.user?.id) {
+        errLog(statusRow('✗', 'Login failed', 'server says token is not valid', { stream: process.stderr }) + '\n');
+        return 1;
+    }
+    const auth = {
+        pat,
+        baseUrl,
+        email: body.user.email,
+        userId: body.user.id,
+        savedAt: Date.now(),
+    };
+    await saveAuth(auth);
+    log('\n' + wordmark(`v${VERSION}`, { state: 'READY' }) + '\n\n');
+    log(statusRow('✓', 'Logged in', `as ${c.cyan(auth.email)}`) + '\n');
+    log(statusRow('✓', 'Saved auth', '~/.config/nonbot/auth.json (mode 600)') + '\n');
+    return 0;
+}

package/dist/commands/logs.js

@@ -0,0 +1,113 @@
+import { readActivityLog as readActivityLogDefault, } from '../lib/activity-log.js';
+import { header, statusRow, eventRow } from '../lib/output.js';
+const FOLLOW_INTERVAL_MS = 1000;
+function parseArgs(args) {
+    let limit = 20;
+    let json = false;
+    let follow = false;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--json') {
+            json = true;
+        }
+        else if (a === '--follow' || a === '-f') {
+            follow = true;
+        }
+        else if (a === '--limit') {
+            const v = args[i + 1];
+            const n = Number(v);
+            if (!v || !Number.isFinite(n) || n <= 0) {
+                return { limit, json, follow, error: '--limit needs a positive number' };
+            }
+            limit = Math.floor(n);
+            i++;
+        }
+        else if (a.startsWith('--limit=')) {
+            const n = Number(a.slice('--limit='.length));
+            if (!Number.isFinite(n) || n <= 0) {
+                return { limit, json, follow, error: '--limit needs a positive number' };
+            }
+            limit = Math.floor(n);
+        }
+        else {
+            return { limit, json, follow, error: `unknown flag "${a}"` };
+        }
+    }
+    return { limit, json, follow };
+}
+function relativeTime(ts, now) {
+    const deltaSec = Math.max(0, Math.round((now - ts) / 1000));
+    if (deltaSec < 60)
+        return `${deltaSec}s ago`;
+    const min = Math.round(deltaSec / 60);
+    if (min < 60)
+        return `${min}m ago`;
+    const hr = Math.round(min / 60);
+    if (hr < 24)
+        return `${hr}h ago`;
+    const days = Math.round(hr / 24);
+    return `${days}d ago`;
+}
+function formatEntry(e, now) {
+    const status = e.status === 'launched' ? '✓' : '✗';
+    const when = relativeTime(e.ts, now);
+    const target = `${e.mode}/${e.target}`;
+    const parts = [e.id, e.kind, target, when];
+    if (e.repoPath)
+        parts.push(e.repoPath);
+    if (e.status === 'failed' && e.reason)
+        parts.push(`reason: ${e.reason}`);
+    return eventRow(parts, { status }) + '\n';
+}
+export async function runLogsCommand(args = [], deps = {}) {
+    const log = deps.log ?? ((s) => process.stdout.write(s));
+    const errLog = deps.errLog ?? ((s) => process.stderr.write(s));
+    const readActivityLog = deps.readActivityLog ?? readActivityLogDefault;
+    const now = deps.now ?? (() => Date.now());
+    const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const opts = parseArgs(args);
+    if (opts.error) {
+        errLog(statusRow('✗', 'nonbot logs', opts.error, { stream: process.stderr }) + '\n');
+        errLog('      Usage: nonbot logs [--limit <n>] [--json] [--follow|-f]\n');
+        return 1;
+    }
+    const entries = await readActivityLog(opts.limit);
+    if (opts.json) {
+        for (const e of entries)
+            log(JSON.stringify(e) + '\n');
+    }
+    else {
+        log(header('nonbot logs', `last ${entries.length} ${entries.length === 1 ? 'entry' : 'entries'}`) + '\n');
+        if (entries.length === 0) {
+            log(statusRow('ℹ', 'No activation history yet', '') + '\n');
+        }
+        else {
+            for (const e of entries)
+                log(formatEntry(e, now()));
+        }
+    }
+    if (!opts.follow)
+        return 0;
+    let highWater = entries.length > 0 ? entries[entries.length - 1].ts : 0;
+    let running = true;
+    const sigHandler = () => {
+        running = false;
+        log('\n' + statusRow('✓', 'stopped following', 'Ctrl-C received') + '\n');
+    };
+    process.on('SIGINT', sigHandler);
+    log(statusRow('ℹ', 'Following activation log', 'Ctrl-C to stop') + '\n');
+    while (running) {
+        await sleep(FOLLOW_INTERVAL_MS);
+        if (!running)
+            break;
+        const recent = await readActivityLog(200);
+        for (const e of recent) {
+            if (e.ts > highWater) {
+                log(formatEntry(e, now()));
+                highWater = e.ts;
+            }
+        }
+    }
+    process.off('SIGINT', sigHandler);
+    return 0;
+}

package/dist/commands/profiles.js

@@ -0,0 +1,24 @@
+import { listProfiles as listProfilesDefault, getActiveProfile } from '../lib/auth.js';
+export async function runProfilesCommand(args = [], deps = {}) {
+    void args;
+    const log = deps.log ?? ((s) => process.stdout.write(s));
+    const errLog = deps.errLog ?? ((s) => process.stderr.write(s));
+    const listProfiles = deps.listProfiles ?? listProfilesDefault;
+    const active = getActiveProfile();
+    const profiles = await listProfiles();
+    if (profiles.length === 0) {
+        log('ℹ No profiles found. Run: nonbot login\n');
+        log(`ℹ Active profile: ${active} (no auth saved yet)\n`);
+        return 0;
+    }
+    log('Profiles:\n');
+    for (const name of profiles) {
+        const marker = name === active ? '●' : ' ';
+        log(`  ${marker} ${name}\n`);
+    }
+    if (!profiles.includes(active)) {
+        log(`\nℹ Active profile "${active}" has no auth saved. Run: nonbot login --profile ${active}\n`);
+    }
+    void errLog;
+    return 0;
+}

package/dist/commands/run.js

@@ -0,0 +1,63 @@
+import { loadAuth } from '../lib/auth.js';
+import { fireActivation, makeHeadlessSpawner, } from '../lib/activations.js';
+import { VERSION } from '../version.js';
+export async function runRunCommand(args = [], deps = {}) {
+    const log = deps.log ?? ((s) => process.stdout.write(s));
+    const errLog = deps.errLog ?? ((s) => process.stderr.write(s));
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const loader = deps.loadAuth ?? loadAuth;
+    const headless = args.includes('--headless') || args.includes('--no-terminal');
+    if (headless) {
+        deps.headless = true;
+        if (!deps.spawnTerminal) {
+            deps.spawnTerminal = makeHeadlessSpawner({ wait: true, log, errLog });
+        }
+    }
+    const id = args.find((a) => !a.startsWith('-'));
+    if (!id) {
+        errLog('Usage: nonbot run <activation-id> [--headless]\n');
+        return 1;
+    }
+    const auth = await loader();
+    if (!auth) {
+        errLog('✗ Not logged in. Run: nonbot login\n');
+        return 1;
+    }
+    let res;
+    try {
+        res = await fetchImpl(`${auth.baseUrl}/api/cli/activations/pending`, {
+            headers: {
+                Authorization: `Bearer ${auth.pat}`,
+                'X-Requested-With': 'ConradPM-Native',
+                'X-CLI-Version': VERSION,
+            },
+        });
+    }
+    catch (e) {
+        errLog(`✗ Network error: ${e.message}\n`);
+        return 1;
+    }
+    if (res.status === 401) {
+        errLog('✗ Auth failed (401). Re-run: nonbot login\n');
+        return 1;
+    }
+    if (!res.ok) {
+        errLog(`✗ Server returned HTTP ${res.status}.\n`);
+        return 1;
+    }
+    let body;
+    try {
+        body = (await res.json());
+    }
+    catch {
+        errLog('✗ Server returned non-JSON.\n');
+        return 1;
+    }
+    const match = (body.activations ?? []).find((a) => a?.id === id);
+    if (!match) {
+        errLog(`✗ No pending activation with id ${id}. It may have already been delivered.\n`);
+        return 1;
+    }
+    await fireActivation(auth, match, deps, log, errLog);
+    return 0;
+}

package/dist/commands/status.js

@@ -0,0 +1,103 @@
+import { loadAuth } from '../lib/auth.js';
+import { readActivityLog as readActivityLogDefault } from '../lib/activity-log.js';
+import { VERSION } from '../version.js';
+import { header, formatKV, errorBlock, statusRow, clockTime } from '../lib/output.js';
+const HEARTBEAT_FRESH_MS = 15_000;
+function relativeTime(deltaMs) {
+    const deltaSec = Math.max(0, Math.round(deltaMs / 1000));
+    if (deltaSec < 60)
+        return `${deltaSec}s ago`;
+    const min = Math.round(deltaSec / 60);
+    if (min < 60)
+        return `${min}m ago`;
+    const hr = Math.round(min / 60);
+    if (hr < 24)
+        return `${hr}h ago`;
+    return `${Math.round(hr / 24)}d ago`;
+}
+export async function runStatusCommand(args = [], deps = {}) {
+    void args;
+    const log = deps.log ?? ((s) => process.stdout.write(s));
+    const errLog = deps.errLog ?? ((s) => process.stderr.write(s));
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const loader = deps.loadAuth ?? loadAuth;
+    const now = deps.now ?? (() => Date.now());
+    const readActivityLog = deps.readActivityLog ?? readActivityLogDefault;
+    const auth = await loader();
+    if (!auth) {
+        log(errorBlock('Not logged in', 'Run `nonbot login` to authenticate.', { stream: process.stdout }));
+        return 0;
+    }
+    let lastHeartbeat;
+    let serverError;
+    try {
+        const res = await fetchImpl(`${auth.baseUrl}/api/cli/daemon-status`, {
+            headers: {
+                Authorization: `Bearer ${auth.pat}`,
+                'X-Requested-With': 'ConradPM-Native',
+                'X-CLI-Version': VERSION,
+            },
+        });
+        if (res.ok) {
+            const body = (await res.json());
+            if (typeof body.lastHeartbeatAt === 'number') {
+                lastHeartbeat = body.lastHeartbeatAt;
+            }
+        }
+        else if (res.status === 401) {
+            errLog(errorBlock('Auth failed (HTTP 401)', 'Re-run: nonbot login', { stream: process.stderr }));
+            return 0;
+        }
+        else {
+            serverError = `HTTP ${res.status}`;
+        }
+    }
+    catch (e) {
+        serverError = e.message;
+    }
+    const isFresh = typeof lastHeartbeat === 'number' && now() - lastHeartbeat <= HEARTBEAT_FRESH_MS;
+    const hasStale = typeof lastHeartbeat === 'number' && !isFresh;
+    const leadStatus = isFresh ? '●' : hasStale ? '⚠' : '✗';
+    log(header('non.bot daemon', `v${VERSION}`, { status: leadStatus }) + '\n');
+    const hostUrl = new URL(auth.baseUrl).host;
+    const rows = [
+        ['Connection', `${hostUrl} (${auth.baseUrl})`],
+        ['Account', auth.email],
+    ];
+    if (typeof lastHeartbeat === 'number') {
+        rows.push(['Last poll', relativeTime(now() - lastHeartbeat)]);
+    }
+    else if (serverError) {
+        rows.push(['Last poll', `unknown (server: ${serverError})`]);
+    }
+    else {
+        rows.push(['Last poll', 'no heartbeat recorded yet']);
+    }
+    let lastFire;
+    try {
+        const recent = await readActivityLog(1);
+        if (recent.length > 0)
+            lastFire = recent[recent.length - 1];
+    }
+    catch {
+    }
+    if (lastFire) {
+        const ts = clockTime(new Date(lastFire.ts));
+        const outcome = lastFire.status === 'launched' ? 'launched' : 'failed';
+        rows.push([
+            'Last fire',
+            `${lastFire.id} (${ts}, ${outcome} in ${lastFire.target})`,
+        ]);
+    }
+    for (const r of formatKV(rows))
+        log(r + '\n');
+    if (!isFresh && !hasStale) {
+        log('\n');
+        log(statusRow('ℹ', 'Start it', 'nonbot daemon') + '\n');
+    }
+    else if (hasStale && lastHeartbeat) {
+        log('\n');
+        log(statusRow('⚠', 'Heartbeat stale', `${relativeTime(now() - lastHeartbeat)} — restart with: nonbot daemon`) + '\n');
+    }
+    return 0;
+}

package/dist/commands/test.js

@@ -0,0 +1,4 @@
+import { printDiagnosticBanner } from '../lib/banner.js';
+export function runTestCommand() {
+    printDiagnosticBanner(process.stdout);
+}