@nonbot/cli 0.5.13

package/dist/index.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+import { VERSION } from './version.js';
+import { runTestCommand } from './commands/test.js';
+import { runStatusCommand } from './commands/status.js';
+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 { runLogsCommand } from './commands/logs.js';
+import { runProfilesCommand } from './commands/profiles.js';
+import { setActiveProfile } from './lib/auth.js';
+import { header, kvRow, ANSI, isTTY } from './lib/output.js';
+const COMMANDS = [
+    {
+        name: 'login',
+        description: 'Paste a PAT from /settings/connections; saves to ~/.config/nonbot/auth.json.',
+        run: (args) => runLoginCommand(args),
+    },
+    {
+        name: 'daemon',
+        description: 'Long-running listener — polls /api/cli/activations/pending every 2s.',
+        run: (args) => runDaemonCommand(args),
+    },
+    {
+        name: 'run',
+        description: 'One-shot: fire a single activation by id. Usage: nonbot run <activation-id>',
+        run: (args) => runRunCommand(args),
+    },
+    {
+        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 lines = [];
+    lines.push(header('nonbot', `non.bot CLI host  ·  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('');
+    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('');
+    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('');
+    process.stdout.write(lines.join('\n') + '\n');
+}
+function extractProfileFlag(args) {
+    let profile;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--profile') {
+            profile = args[i + 1];
+            args.splice(i, profile === undefined ? 1 : 2);
+            i--;
+        }
+        else if (args[i].startsWith('--profile=')) {
+            profile = args[i].slice('--profile='.length);
+            args.splice(i, 1);
+            i--;
+        }
+    }
+    return profile;
+}
+async function main(argv) {
+    const args = argv.slice(2);
+    const profile = extractProfileFlag(args);
+    if (profile !== undefined) {
+        if (profile.length === 0) {
+            process.stderr.write('nonbot: --profile needs a name\n');
+            return 1;
+        }
+        try {
+            setActiveProfile(profile);
+        }
+        catch (e) {
+            process.stderr.write(`nonbot: ${e.message}\n`);
+            return 1;
+        }
+    }
+    if (args.length === 0) {
+        printHelp();
+        return 0;
+    }
+    const first = args[0];
+    if (first === '-v' || first === '--version') {
+        printVersion();
+        return 0;
+    }
+    if (first === '-h' || first === '--help') {
+        printHelp();
+        return 0;
+    }
+    const cmd = COMMANDS.find((c) => c.name === first);
+    if (!cmd) {
+        process.stderr.write(`nonbot: unknown command "${first}"\n\n`);
+        printHelp();
+        return 1;
+    }
+    const result = await cmd.run(args.slice(1));
+    return typeof result === 'number' ? result : 0;
+}
+main(process.argv).then((code) => process.exit(code), (err) => {
+    process.stderr.write(`nonbot: fatal: ${err.message}\n`);
+    process.exit(1);
+});

package/dist/lib/activations.js

@@ -0,0 +1,480 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import { tmpdir, homedir } from 'node:os';
+import path from 'node:path';
+import { VERSION } from '../version.js';
+import { resolveTerminal } from './terminal.js';
+import { getActiveProfile } from './auth.js';
+import { appendActivityLog } from './activity-log.js';
+import { activationCard, clockTime } from './output.js';
+import { buildCommandFromParams, shellQuoteSingle } from './command-builders.js';
+import { validatePayload, validateActivationId, validateRepoPath, ValidationError, extractTerminalTheme, } from './payload-validator.js';
+export const BUILT_COMMAND_MAX_LENGTH = 32 * 1024;
+export const WIRE_COMMAND_MAX_LENGTH = 4096;
+export const COMMAND_WARN_LENGTH = 8192;
+export const COMMAND_MAX_LENGTH = 16384;
+export function resolveExecutableCommand(act, warn = (s) => console.warn(s)) {
+    if (process.env.NONBOT_TEST_DIRECT_SHELL === '1' && act.payload) {
+        const p = act.payload;
+        if (p.template === 'test-direct-shell' && typeof p.shell === 'string') {
+            return {
+                shell: p.shell,
+                params: { template: 'diagnostic', activationId: act.id, repoPath: '' },
+            };
+        }
+    }
+    if (act.payload === undefined || act.payload === null) {
+        throw new Error('activation has no payload — server is on a pre-SEC1 version (see https://non.bot/docs/cli-daemon/upgrading). Daemon will not execute server-supplied shell text verbatim.');
+    }
+    if (typeof act.command === 'string' && act.command.length > WIRE_COMMAND_MAX_LENGTH) {
+        throw new Error(`[${act.id}] command_oversize: wire act.command is ${act.command.length} chars, cap ${WIRE_COMMAND_MAX_LENGTH}. The wire field is informational post-SEC1; an over-cap value suggests a server bug or a stolen-PAT log-flood attempt.`);
+    }
+    if (typeof act.command === 'string' &&
+        act.command.length > 0 &&
+        !act.command.startsWith('cd ')) {
+        warn(`[${act.id}] note: unusual prefix on wire act.command (does not start with 'cd ') — command_prefix drift. Executing daemon-built command anyway; wire field is informational.\n`);
+    }
+    let params;
+    try {
+        params = validatePayload(act.payload);
+    }
+    catch (e) {
+        if (e instanceof ValidationError) {
+            throw new Error(`[${act.id}] payload validation failed (${e.field}): ${e.reason}`);
+        }
+        throw e;
+    }
+    let shell;
+    try {
+        shell = buildCommandFromParams(params);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`[${act.id}] command builder failed: ${msg}`);
+    }
+    if (shell.length > BUILT_COMMAND_MAX_LENGTH) {
+        throw new Error(`[${act.id}] built command is too large (${shell.length} chars, cap ${BUILT_COMMAND_MAX_LENGTH}). This indicates an oversized AGENTS.md or a builder bug.`);
+    }
+    if (typeof act.command === 'string' && act.command.length > 0 && act.command !== shell) {
+        warn(`[${act.id}] note: daemon-built command differs from server-supplied command (executing daemon-built; server text is informational).\n`);
+    }
+    return { shell, params };
+}
+export function validateActivationEnvelope(act) {
+    try {
+        validateActivationId(act.id);
+    }
+    catch (e) {
+        if (e instanceof ValidationError) {
+            throw new Error(`[${String(act.id)}] outer envelope validation failed (act.id): ${e.reason}`);
+        }
+        throw e;
+    }
+    if (act.repoPath !== undefined && act.repoPath !== null && act.repoPath !== '') {
+        try {
+            validateRepoPath(act.repoPath);
+        }
+        catch (e) {
+            if (e instanceof ValidationError) {
+                throw new Error(`[${act.id}] outer envelope validation failed (act.repoPath): ${e.reason}`);
+            }
+            throw e;
+        }
+    }
+    if (act.payload &&
+        typeof act.payload === 'object' &&
+        'repoPath' in act.payload) {
+        const inner = act.payload.repoPath;
+        if (act.repoPath !== undefined &&
+            act.repoPath !== null &&
+            act.repoPath !== '' &&
+            typeof inner === 'string' &&
+            inner !== '' &&
+            inner !== act.repoPath) {
+            throw new Error(`[${act.id}] outer envelope drift: act.repoPath (${JSON.stringify(act.repoPath)}) does not match payload.repoPath (${JSON.stringify(inner)})`);
+        }
+    }
+}
+export function validateActivationCommand(act, warn = (s) => console.warn(s)) {
+    if (!act.command || typeof act.command !== 'string') {
+        throw new Error('activation has no command');
+    }
+    if (act.command.length > COMMAND_MAX_LENGTH) {
+        throw new Error(`Run command is too large (${act.command.length} chars, cap ${COMMAND_MAX_LENGTH}). This usually means the ticket tree is enormous — consider running the leaf stories individually, or filing a bug if the parent ticket really has that many descendants.`);
+    }
+    if (act.command.length > COMMAND_WARN_LENGTH) {
+        warn(`[${act.id}] note: large Run command (${act.command.length} chars, soft warn at ${COMMAND_WARN_LENGTH}) — likely a deep ticket tree. Proceeding.\n`);
+    }
+}
+const CAPTURED_OUTPUT_MAX = 4096;
+function truncate(s, max) {
+    if (!s)
+        return s;
+    if (s.length <= max)
+        return s;
+    return s.slice(0, max - 32) + `\n…[truncated to ${max}B]`;
+}
+export function makeHeadlessSpawner(opts) {
+    return (act) => new Promise((resolve, reject) => {
+        try {
+            validateActivationEnvelope(act);
+        }
+        catch (e) {
+            reject(e instanceof Error ? e : new Error(String(e)));
+            return;
+        }
+        let resolved;
+        try {
+            resolved = resolveExecutableCommand(act, opts.errLog);
+        }
+        catch (e) {
+            reject(e instanceof Error ? e : new Error(String(e)));
+            return;
+        }
+        const cwd = act.repoPath || undefined;
+        if (opts.wait) {
+            const proc = spawn('bash', ['-c', resolved.shell], { cwd, stdio: 'inherit' });
+            proc.on('error', (e) => {
+                const err = e;
+                reject(new Error(`failed to run headless: ${err.message}`));
+            });
+            proc.on('exit', () => resolve());
+            return;
+        }
+        const proc = spawn('bash', ['-c', resolved.shell], {
+            cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const prefixLines = (chunk, sink) => {
+            const text = chunk.toString('utf-8');
+            for (const line of text.split('\n')) {
+                if (line.length > 0)
+                    sink(`[${act.id}] ${line}\n`);
+            }
+        };
+        proc.stdout?.on('data', (c) => prefixLines(c, opts.log));
+        proc.stderr?.on('data', (c) => prefixLines(c, opts.errLog));
+        proc.on('error', (e) => {
+            const err = e;
+            reject(new Error(`failed to run headless: ${err.message}`));
+        });
+        proc.on('exit', (code) => opts.log(`[${act.id}] exited ${code}\n`));
+        proc.on('spawn', () => resolve());
+    });
+}
+async function captureSpawn(cmd, args) {
+    return new Promise((resolve) => {
+        const stderrChunks = [];
+        const stdoutChunks = [];
+        let stderrLen = 0;
+        let stdoutLen = 0;
+        const proc = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        proc.stderr?.on('data', (c) => {
+            if (stderrLen >= CAPTURED_OUTPUT_MAX)
+                return;
+            stderrChunks.push(c);
+            stderrLen += c.length;
+        });
+        proc.stdout?.on('data', (c) => {
+            if (stdoutLen >= CAPTURED_OUTPUT_MAX)
+                return;
+            stdoutChunks.push(c);
+            stdoutLen += c.length;
+        });
+        proc.on('error', (e) => {
+            resolve({
+                exitCode: null,
+                stderr: Buffer.concat(stderrChunks).toString('utf-8'),
+                stdout: Buffer.concat(stdoutChunks).toString('utf-8'),
+                spawnError: e,
+            });
+        });
+        proc.on('exit', (code) => {
+            resolve({
+                exitCode: code,
+                stderr: Buffer.concat(stderrChunks).toString('utf-8'),
+                stdout: Buffer.concat(stdoutChunks).toString('utf-8'),
+            });
+        });
+    });
+}
+export const _captureSpawnForTests = captureSpawn;
+export async function spawnTerminalDefault(act, auth) {
+    validateActivationEnvelope(act);
+    const resolved = resolveExecutableCommand(act);
+    const ext = process.platform === 'darwin' ? 'command' : 'sh';
+    const scriptPath = path.join(tmpdir(), `nonbot-${act.id}.${ext}`);
+    if (path.dirname(scriptPath) !== tmpdir()) {
+        throw new Error(`[${act.id}] refusing to write script outside tmpdir(): resolved path is ${JSON.stringify(scriptPath)}`);
+    }
+    let envPrefix = '';
+    if (auth) {
+        const patLine = `export NONBOT_PAT=${shellQuoteSingle(auth.pat)}`;
+        const runIdLine = `export NONBOT_RUN_ID=${shellQuoteSingle(act.id)}`;
+        const baseUrlLine = `export NONBOT_BASE_URL=${shellQuoteSingle(auth.baseUrl)}`;
+        const roleLine = `export NONBOT_ROLE='lead'`;
+        envPrefix = `${patLine}\n${runIdLine}\n${baseUrlLine}\n${roleLine}\n`;
+    }
+    const body = `#!/bin/bash\n${envPrefix}${resolved.shell}\n`;
+    await fs.writeFile(scriptPath, body, { mode: 0o700 });
+    await fs.chmod(scriptPath, 0o700);
+    const profile = resolveTerminal(act.terminal);
+    const theme = extractTerminalTheme(act.payload);
+    let itermProfileName;
+    if (theme) {
+        if (profile.id === 'tmux') {
+            const themeConfPath = path.join(tmpdir(), `nonbot-theme-${act.id}.conf`);
+            await fs.writeFile(themeConfPath, theme.tmuxConf, { mode: 0o600 });
+            const safePath = themeConfPath.replace(/'/g, `'\\''`);
+            const sourceLine = `tmux source-file '${safePath}'\n`;
+            const existingContent = await fs.readFile(scriptPath, 'utf-8');
+            const withTheme = existingContent.replace(/^(#!\/bin\/bash\n)/, `$1${sourceLine}`);
+            await fs.writeFile(scriptPath, withTheme, { mode: 0o700 });
+            await fs.chmod(scriptPath, 0o700);
+        }
+        else if (profile.id === 'iterm' || profile.id === 'iterm-tab') {
+            const profileDir = path.join(homedir(), 'Library', 'Application Support', 'iTerm2', 'DynamicProfiles');
+            await fs.mkdir(profileDir, { recursive: true });
+            const profileFilePath = path.join(profileDir, `nonbot-${act.id}.json`);
+            await fs.writeFile(profileFilePath, theme.itermProfileJson, { mode: 0o600 });
+            itermProfileName = theme.name;
+        }
+        else if (profile.id === 'terminal') {
+            console.info(`[nonbot] terminal-theme: Terminal.app per-window theming is not supported via AppleScript. ` +
+                `Switch to iTerm for theme support. Launching un-themed.`);
+        }
+    }
+    const { cmd, args } = profile.launch(scriptPath, itermProfileName ? { itermProfileName } : undefined);
+    const result = await captureSpawn(cmd, args);
+    const unlinkBest = async () => {
+        try {
+            await fs.unlink(scriptPath);
+        }
+        catch {
+        }
+    };
+    if (result.spawnError) {
+        await unlinkBest();
+        const err = result.spawnError;
+        const why = err.code === 'ENOENT'
+            ? `${profile.displayName} launcher "${cmd}" not found on PATH`
+            : err.message;
+        const failure = Object.assign(new Error(`failed to launch ${profile.displayName}: ${why}`), {
+            launcherStderr: result.stderr,
+            launcherStdout: result.stdout,
+        });
+        throw failure;
+    }
+    if (result.exitCode !== 0) {
+        await unlinkBest();
+        const tail = (result.stderr || result.stdout || '').trim().split('\n').slice(-3).join(' | ') ||
+            `(no output)`;
+        const failure = Object.assign(new Error(`${profile.displayName} launcher "${cmd}" exited ${result.exitCode}: ${tail}`), {
+            launcherStderr: result.stderr,
+            launcherStdout: result.stdout,
+            launcherExitCode: result.exitCode ?? undefined,
+        });
+        throw failure;
+    }
+    let tmuxPaneId;
+    if (profile.id === 'tmux') {
+        const first = result.stdout.trim().split(/\s+/)[0] ?? '';
+        if (/^%\d+$/.test(first))
+            tmuxPaneId = first;
+    }
+    return { tmuxPaneId };
+}
+export async function ack(auth, id, body, fetchImpl = fetch) {
+    try {
+        await fetchImpl(`${auth.baseUrl}/api/cli/activations/${id}/ack`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${auth.pat}`,
+                'X-Requested-With': 'ConradPM-Native',
+                'X-CLI-Version': VERSION,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body),
+        });
+    }
+    catch {
+    }
+}
+class TraceBuilder {
+    steps = [];
+    lastTs = 0;
+    add(name, status, detail) {
+        const ts = Date.now();
+        const durationMs = this.lastTs === 0 ? undefined : Math.max(0, ts - this.lastTs);
+        this.steps.push({ name, status, detail, ts, durationMs });
+        this.lastTs = ts;
+    }
+    snapshot() {
+        return this.steps.slice();
+    }
+}
+export async function fireActivation(auth, act, deps = {}, log = (s) => process.stdout.write(s), errLog = (s) => process.stderr.write(s)) {
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const spawnFn = deps.spawnTerminal ?? ((a) => spawnTerminalDefault(a, auth));
+    const headless = deps.headless === true;
+    const trace = new TraceBuilder();
+    trace.add('received', 'ok', `id=${act.id} kind=${act.kind} repoPath=${act.repoPath ?? '(none)'} preference=${act.terminal ?? '(none)'}`);
+    const profile = resolveTerminal(act.terminal);
+    const terminal = headless ? 'headless' : profile.displayName;
+    if (headless) {
+        trace.add('resolved_terminal', 'ok', `headless (no terminal app)`);
+    }
+    else {
+        const { cmd } = profile.launch('/tmp/nonbot-probe');
+        trace.add('resolved_terminal', 'ok', `${terminal} (${cmd})`);
+    }
+    const payloadAny = (act.payload ?? {});
+    const storyTitle = payloadAny.storyTitle && typeof payloadAny.storyTitle === 'string'
+        ? payloadAny.storyTitle
+        : `${act.kind} activation`;
+    const providerName = payloadAny.provider && typeof payloadAny.provider === 'string'
+        ? payloadAny.provider
+        : 'unknown';
+    const cardKv = [
+        ['STORY', storyTitle],
+        ['PROVIDER', providerName],
+        ['PANE', terminal],
+        ['AT', clockTime()],
+    ];
+    if (act.repoPath)
+        cardKv.push(['REPO', act.repoPath]);
+    log(activationCard({
+        marker: '▶',
+        color: 'green',
+        id: act.id,
+        headerSuffix: 'RUNNING',
+        kv: cardKv,
+    }) + '\n');
+    const mode = headless ? 'headless' : 'terminal';
+    let launcherStderr;
+    let launcherStdout;
+    let launcherExitCode;
+    try {
+        trace.add('spawned_launcher', 'ok', `dispatched to ${terminal}`);
+        const spawnResult = (await spawnFn(act)) ?? {};
+        const tmuxPaneId = spawnResult.tmuxPaneId ?? undefined;
+        launcherExitCode = 0;
+        trace.add('launcher_exited', 'ok', `exit 0`);
+        trace.add('acked', 'ok', `status=launched terminal=${terminal}`);
+        const body = {
+            status: 'launched',
+            terminalAppUsed: terminal,
+            trace: trace.snapshot(),
+            launcherExitCode,
+        };
+        if (tmuxPaneId)
+            body.tmuxPaneId = tmuxPaneId;
+        await ack(auth, act.id, body, fetchImpl);
+        await logActivity({
+            ts: Date.now(),
+            id: act.id,
+            kind: act.kind,
+            mode,
+            target: terminal,
+            repoPath: act.repoPath,
+            status: 'launched',
+            profile: getActiveProfile(),
+        });
+        return { id: act.id, status: 'launched', kind: act.kind, tmuxPaneId: tmuxPaneId ?? null };
+    }
+    catch (e) {
+        const reason = e.message || 'unknown error';
+        const failure = e;
+        launcherStderr = truncate(failure.launcherStderr, CAPTURED_OUTPUT_MAX);
+        launcherStdout = truncate(failure.launcherStdout, CAPTURED_OUTPUT_MAX);
+        launcherExitCode = failure.launcherExitCode;
+        const failKv = [
+            ['REASON', reason],
+            ['PANE', terminal],
+            ['AT', clockTime()],
+        ];
+        if (launcherStderr) {
+            failKv.push(['STDERR', launcherStderr.slice(0, 500).replace(/\n/g, ' | ')]);
+        }
+        errLog(activationCard({
+            marker: 'X',
+            color: 'red',
+            id: act.id,
+            headerSuffix: 'FAILED',
+            kv: failKv,
+            stream: process.stderr,
+        }) + '\n');
+        trace.add('launcher_exited', 'failed', reason);
+        trace.add('acked', 'ok', `status=failed terminal=${terminal}`);
+        const body = {
+            status: 'failed',
+            terminalAppUsed: terminal,
+            errorReason: reason,
+            trace: trace.snapshot(),
+            launcherStderr,
+            launcherStdout,
+            launcherExitCode,
+        };
+        await ack(auth, act.id, body, fetchImpl);
+        await logActivity({
+            ts: Date.now(),
+            id: act.id,
+            kind: act.kind,
+            mode,
+            target: terminal,
+            repoPath: act.repoPath,
+            status: 'failed',
+            reason,
+            profile: getActiveProfile(),
+        });
+        return { id: act.id, status: 'failed', kind: act.kind };
+    }
+}
+async function logActivity(entry) {
+    try {
+        await appendActivityLog(entry);
+    }
+    catch {
+    }
+}
+export async function executePendingKills(kills, baseUrl, token) {
+    if (!Array.isArray(kills) || kills.length === 0)
+        return;
+    const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+    const runOne = async (k) => {
+        try {
+            spawnSync('tmux', ['send-keys', '-t', k.tmuxPaneId, 'C-c'], {
+                encoding: 'utf-8',
+                timeout: 2000,
+                windowsHide: true,
+            });
+        }
+        catch {
+        }
+        await sleep(2000);
+        try {
+            spawnSync('tmux', ['kill-pane', '-t', k.tmuxPaneId], {
+                encoding: 'utf-8',
+                timeout: 2000,
+                windowsHide: true,
+            });
+        }
+        catch {
+        }
+        try {
+            await fetch(`${baseUrl}/api/cli/activations/${k.activationId}/stop-ack`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    'X-Requested-With': 'ConradPM-Native',
+                    'X-CLI-Version': VERSION,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ ok: true }),
+            });
+        }
+        catch {
+        }
+    };
+    await Promise.all(kills.map(runOne));
+}

package/dist/lib/activity-log.js

@@ -0,0 +1,48 @@
+import { promises as fs } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+function configDir() {
+    const override = process.env.NONBOT_CONFIG_DIR;
+    if (override && override.length > 0)
+        return override;
+    return path.join(homedir(), '.config', 'nonbot');
+}
+function logPath() {
+    return path.join(configDir(), 'activations.log');
+}
+const realFs = {
+    mkdir: (dir, opts) => fs.mkdir(dir, opts),
+    appendFile: (file, data) => fs.appendFile(file, data),
+    readFile: (file, enc) => fs.readFile(file, enc),
+};
+export async function appendActivityLog(entry, fsImpl = realFs) {
+    await fsImpl.mkdir(configDir(), { recursive: true, mode: 0o700 });
+    await fsImpl.appendFile(logPath(), JSON.stringify(entry) + '\n');
+}
+export async function readActivityLog(limit = 50, fsImpl = realFs) {
+    let raw;
+    try {
+        raw = await fsImpl.readFile(logPath(), 'utf-8');
+    }
+    catch {
+        return [];
+    }
+    const lines = raw.split('\n').filter((l) => l.trim().length > 0);
+    const out = [];
+    for (const line of lines) {
+        try {
+            const parsed = JSON.parse(line);
+            if (typeof parsed.ts === 'number' &&
+                typeof parsed.id === 'string' &&
+                typeof parsed.status === 'string') {
+                out.push(parsed);
+            }
+        }
+        catch {
+        }
+    }
+    return out.slice(-limit);
+}
+export function _activityLogPathForTests() {
+    return logPath();
+}