@nonbot/cli 0.5.13

package/CHANGELOG.md

@@ -0,0 +1,35 @@
+# @nonbot/cli changelog
+
+## 0.5.10
+
+- Build now strips source comments from the published output, so no internal
+  file paths or developer environment details ship in the package.
+
+## 0.5.9
+
+- Docs: rewrote the README as clean end-user docs; removed internal
+  implementation and security-mechanism detail not meant for a public package.
+- Scrubbed an example email address from the `nonbot status` banner output.
+- First release published via npm trusted publishing (OIDC) — no token.
+
+## 0.5.8
+
+- Runs are now marked complete automatically when their terminal closes, so the
+  Recent Activations view on non.bot stays accurate.
+
+## 0.5.x
+
+- `nonbot doctor` health check (auth, server, provider CLIs, terminal).
+- Headless mode (`--headless`) to run inline without opening a window.
+- Multiple accounts via `--profile`.
+- Local launch history (`nonbot logs`).
+- Run the daemon at login (`daemon --install` / `--uninstall`).
+- tmux support: Runs open as tmux windows when the daemon runs inside tmux, and can be
+  stopped from non.bot.
+- Adaptive polling — the daemon checks more often while a Run is active and backs off
+  when idle.
+
+## 0.2.0 – 0.4.0
+
+- Initial release: `login`, `daemon`, `run`, `status`, and cross-platform terminal
+  launching (macOS, Linux, Windows).

package/LICENSE

@@ -0,0 +1,43 @@
+Copyright (c) 2026 non.bot. All rights reserved.
+
+PROPRIETARY SOFTWARE — NOT OPEN SOURCE
+
+This software (the "@nonbot/cli" package and all of its contents, the
+"Software") is the proprietary and confidential property of non.bot. It is
+published to the npm registry for the sole purpose of allowing authorized
+non.bot account holders to install and run it as the local host for the
+non.bot "Run" feature.
+
+PERMITTED USE
+
+Subject to your compliance with the non.bot Terms of Service, you are granted
+a limited, non-exclusive, non-transferable, revocable license to download,
+install, and execute unmodified copies of the Software on machines you control,
+solely to connect to and operate the non.bot service.
+
+PROHIBITED WITHOUT PRIOR WRITTEN PERMISSION FROM non.bot
+
+  - Copying, redistributing, sublicensing, selling, or publishing the Software
+    or any portion of it;
+  - Modifying, adapting, translating, or creating derivative works;
+  - Reverse-engineering, decompiling, or disassembling the Software except to
+    the limited extent such restriction is prohibited by applicable law;
+  - Using the Software, or any technique, method, or design embodied in it, to
+    build, train, or operate a competing product or service.
+
+NO PATENT OR OTHER IP LICENSE
+
+No license to any patent, patent application, trademark, trade secret, or other
+intellectual-property right of non.bot is granted, whether expressly, by
+implication, by estoppel, or otherwise, except for the limited execution right
+stated above. All such rights are expressly reserved.
+
+NO WARRANTY
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL
+non.bot BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY ARISING FROM, OUT
+OF, OR IN CONNECTION WITH THE SOFTWARE OR ITS USE.
+
+Contact: legal@non.bot

package/README.md

@@ -0,0 +1,93 @@
+# @nonbot/cli
+
+The local host for non.bot **▶ Run**. Install it, log in once, and leave the daemon
+running — when you click ▶ Run on a story in non.bot, a terminal opens on your machine
+and starts the work in your linked repo.
+
+```bash
+npm install -g @nonbot/cli
+nonbot login
+nonbot daemon
+```
+
+## How it works
+
+The daemon runs as an ordinary process in your shell. It polls non.bot for Runs you've
+started, and when one arrives it opens a terminal in your linked repository and launches
+your CLI agent (`claude`, `codex`, or `gemini`). Because it's a plain Node process, it
+uses your existing `PATH` and whatever CLI logins you already have — no extra setup.
+
+## Getting started
+
+```bash
+# 1. Install
+npm install -g @nonbot/cli
+
+# 2. Create a Personal Access Token on non.bot
+#    Settings → Connections → API tokens → "New token"
+
+# 3. Log in (paste the token when prompted)
+nonbot login
+
+# 4. Leave the daemon running in a terminal tab
+nonbot daemon
+
+# 5. Click ▶ Run on non.bot — a terminal opens and starts the work.
+```
+
+Non-interactive login (for CI or scripting):
+
+```bash
+nonbot login --token "$NONBOT_PAT"
+```
+
+## Commands
+
+```
+nonbot login            Log in with a Personal Access Token
+nonbot daemon           Run the poll loop and launch terminals (the main command)
+nonbot run <id>         Launch a single Run by id, then exit
+nonbot status           Show login + daemon status
+nonbot doctor           Health check — auth, server, providers, terminal
+nonbot logs             Show recent local Run launches
+nonbot profiles         List configured accounts
+nonbot test             Print a local diagnostic banner (no server needed)
+nonbot --help           Full command list
+nonbot --version        Print the version
+```
+
+### Useful flags
+
+| Flag | Effect |
+|---|---|
+| `--headless` | Run inline without opening a terminal window (`daemon`, `run`) |
+| `--profile <name>` | Use a named account instead of the default |
+| `daemon --install` / `--uninstall` | Run the daemon automatically at login |
+
+## Terminals
+
+On macOS the daemon launches Terminal or iTerm; on Linux it uses your system terminal;
+on Windows it uses Windows Terminal. If you run the daemon inside a `tmux` session, Runs
+open as new tmux windows instead of separate terminal windows.
+
+Override the terminal with `NONBOT_TERMINAL` (e.g. `NONBOT_TERMINAL=iterm`), or set a
+preferred terminal in your non.bot settings.
+
+## Configuration
+
+Credentials are stored in `~/.config/nonbot/auth.json` (file mode `0600`). Override the
+config directory with `NONBOT_CONFIG_DIR`.
+
+If a token is lost or compromised, rotate it at
+**non.bot → Settings → Connections → API tokens**.
+
+## Requirements
+
+- Node.js 18 or newer
+- A non.bot account with a linked repository
+
+## License
+
+Proprietary — all rights reserved. See [LICENSE](./LICENSE). This package is
+published to npm solely to function as the local host for non.bot ▶ Run; it is
+not open-source software.

package/dist/commands/daemon.js

@@ -0,0 +1,286 @@
+import { spawnSync as nodeSpawnSync } from 'node:child_process';
+import { loadAuth, getActiveProfile } from '../lib/auth.js';
+import * as activations from '../lib/activations.js';
+import { fireActivation, makeHeadlessSpawner, } from '../lib/activations.js';
+import { checkCompletions } from '../lib/completion.js';
+import { installService, uninstallService } from '../lib/service.js';
+import { detectTmuxSession, inTmuxSession, nonbotTmuxOptOut, resolveTerminal, } from '../lib/terminal.js';
+import { VERSION } from '../version.js';
+import { errorBlock, statusRow, daemonOpener, daemonCloser, pollTick, activationCard, c, } from '../lib/output.js';
+export const POLL_FAST_MS = 2000;
+export const POLL_MAX_MS = 30000;
+export const POLL_INTERVAL_MS = POLL_FAST_MS;
+export function applyNonbotTmuxConfig(deps = {}) {
+    const spawnSync = deps.spawnSync ?? nodeSpawnSync;
+    const stdoutWrite = deps.stdoutWrite ?? ((s) => process.stdout.write(s));
+    const env = deps.env ?? process.env;
+    const stdoutIsTTY = deps.stdoutIsTTY ?? (process.stdout?.isTTY !== false);
+    const tmux = (...args) => {
+        try {
+            spawnSync('tmux', args, { encoding: 'utf-8', timeout: 1000, windowsHide: true });
+        }
+        catch {
+        }
+    };
+    tmux('set-option', '-wg', 'automatic-rename', 'off');
+    tmux('set-option', '-wg', 'allow-rename', 'off');
+    tmux('rename-window', 'NONBOT TMUX');
+    tmux('set-option', 'set-titles', 'on');
+    tmux('set-option', 'set-titles-string', 'NONBOT TMUX │ #W');
+    tmux('refresh-client', '-S');
+    if (!stdoutIsTTY)
+        return;
+    const insideTmux = inTmuxSession(env);
+    if (insideTmux) {
+        tmux('set-option', '-p', 'allow-passthrough', 'on');
+    }
+    const NONBOT_TMUX_OSC = '\x1b]2;NONBOT TMUX\x07';
+    const payload = insideTmux
+        ? `\x1bPtmux;\x1b${NONBOT_TMUX_OSC}\x1b\\`
+        : NONBOT_TMUX_OSC;
+    try {
+        stdoutWrite(payload);
+    }
+    catch {
+    }
+}
+export function maybeReexecIntoTmux(deps = {}) {
+    const env = deps.env ?? process.env;
+    const spawn = deps.spawnSync ?? nodeSpawnSync;
+    const argv = deps.argv ?? process.argv;
+    const stdinIsTTY = deps.stdinIsTTY ?? (process.stdin?.isTTY !== false);
+    const exit = deps.exit ?? ((code) => process.exit(code));
+    const log = deps.log ?? ((s) => process.stderr.write(s));
+    if (env.VITEST)
+        return 'skipped';
+    if (inTmuxSession(env))
+        return 'in-tmux';
+    const userArgs = argv.slice(2);
+    if (userArgs.includes('--no-tmux') || nonbotTmuxOptOut(env))
+        return 'skipped';
+    if (userArgs.includes('--headless') || userArgs.includes('--no-terminal'))
+        return 'skipped';
+    if (!stdinIsTTY)
+        return 'skipped';
+    let probeStatus = null;
+    try {
+        const probe = spawn('tmux', ['-V'], { stdio: 'ignore' });
+        probeStatus = probe.status;
+    }
+    catch {
+        probeStatus = 1;
+    }
+    if (probeStatus !== 0) {
+        log('▶ tmux not installed — running daemon bare (each activation will open a new terminal window).\n');
+        log('  Install tmux for the multi-pane experience: brew install tmux\n');
+        return 'skipped';
+    }
+    log("▶ wrapping daemon in tmux session 'nonbot' — activations will land as tabs in this window.\n");
+    log("  (use `nonbot daemon --no-tmux` if you want bare iTerm windows instead.)\n");
+    const wrap = spawn('tmux', ['new-session', '-A', '-s', 'nonbot', '--', ...argv], { stdio: 'inherit' });
+    exit(wrap.status ?? 0);
+    return 'reexeced';
+}
+export async function runDaemonCommand(args = [], options = {}, 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 sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const fixedInterval = options.pollIntervalMs;
+    const maxIntervalMs = options.maxPollIntervalMs ?? POLL_MAX_MS;
+    let currentInterval = fixedInterval ?? POLL_FAST_MS;
+    if (args.includes('--install')) {
+        const install = deps.installService ?? installService;
+        const res = await install();
+        if (res.ok)
+            log(statusRow('✓', 'Service installed', res.message) + '\n');
+        else
+            errLog(statusRow('✗', 'Service install failed', res.message, { stream: process.stderr }) + '\n');
+        return res.ok ? 0 : 1;
+    }
+    if (args.includes('--uninstall')) {
+        const uninstall = deps.uninstallService ?? uninstallService;
+        const res = await uninstall();
+        if (res.ok)
+            log(statusRow('✓', 'Service removed', res.message) + '\n');
+        else
+            errLog(statusRow('✗', 'Service uninstall failed', res.message, { stream: process.stderr }) + '\n');
+        return res.ok ? 0 : 1;
+    }
+    const autoWrap = deps.maybeReexecIntoTmux ?? maybeReexecIntoTmux;
+    const wrapResult = autoWrap();
+    if (wrapResult === 'reexeced')
+        return 0;
+    const headless = args.includes('--headless') || args.includes('--no-terminal');
+    if (headless) {
+        deps.headless = true;
+        if (!deps.spawnTerminal) {
+            deps.spawnTerminal = makeHeadlessSpawner({ wait: false, log, errLog });
+        }
+    }
+    const auth = await loader();
+    if (!auth) {
+        errLog(errorBlock('Not logged in', 'Run `nonbot login` to authenticate.', { stream: process.stderr }));
+        return 1;
+    }
+    const detectTmux = deps.detectTmuxSession ?? detectTmuxSession;
+    const tmuxSessionName = detectTmux();
+    if (tmuxSessionName) {
+        applyNonbotTmuxConfig({ spawnSync: deps.spawnSync });
+    }
+    const seen = new Set();
+    const trackedPanes = new Map();
+    const killedByStop = new Set();
+    let running = true;
+    let sigHandler;
+    if (!options.oneShot) {
+        sigHandler = () => {
+            running = false;
+            log('\n' + statusRow('✓', 'daemon stopped', 'Ctrl-C received') + '\n');
+            process.exit(0);
+        };
+        process.on('SIGINT', sigHandler);
+    }
+    const hostUrl = new URL(auth.baseUrl).host;
+    const profileName = getActiveProfile();
+    const pollingLabel = fixedInterval !== undefined
+        ? `${fixedInterval}ms fixed`
+        : `${Math.round(POLL_FAST_MS / 1000)}s -> ${Math.round(maxIntervalMs / 1000)}s adaptive`;
+    let terminalLabel;
+    if (headless) {
+        terminalLabel = 'headless (inline, no terminal window)';
+    }
+    else {
+        const profile = resolveTerminal(undefined);
+        terminalLabel = tmuxSessionName
+            ? `${profile.displayName}  ·  tmux pane (in session '${tmuxSessionName}')`
+            : profile.displayName;
+    }
+    const badgeSublines = [
+        `listening on ${auth.baseUrl}`,
+        `poll ${Math.round(POLL_FAST_MS / 1000)}s  ·  ${Math.round(maxIntervalMs / 1000)}s on idle  ·  adaptive`,
+    ];
+    if (tmuxSessionName)
+        badgeSublines.push(`tmux host: ${tmuxSessionName}`);
+    log(daemonOpener(`v${VERSION}`, {
+        state: 'IDLE',
+        badgeColor: 'green',
+        badgeLabel: 'CONNECTED',
+        badgeSublines,
+    }) + '\n\n');
+    const headerMarker = c.green('[ + ]');
+    const headerLabel = c.white('LISTENING  ·  READY FOR ACTIVATIONS');
+    log(`${headerMarker} ${c.bold(headerLabel)}\n`);
+    const ctxRows = [
+        ['YOU', auth.email],
+        ['LISTENING', `${hostUrl}/api/cli/activations/pending`],
+        ['PROFILE', profileName],
+        ['LANDING', terminalLabel],
+    ];
+    const LABEL_WIDTH = 9;
+    for (const [k, v] of ctxRows) {
+        const label = c.cyan(k.padEnd(LABEL_WIDTH, ' '));
+        const value = c.white(v);
+        log(`      ${label}  ${value}\n`);
+    }
+    log('\n');
+    log(`${c.bold(c.white('LIVESTREAM'))}\n`);
+    log('\n');
+    log(daemonCloser({
+        inTmux: tmuxSessionName !== null,
+    }) + '\n');
+    log('\n');
+    while (running) {
+        let firedThisPoll = false;
+        try {
+            const headers = {
+                Authorization: `Bearer ${auth.pat}`,
+                'X-Requested-With': 'ConradPM-Native',
+                'X-CLI-Version': VERSION,
+            };
+            if (tmuxSessionName)
+                headers['X-Tmux-Session'] = tmuxSessionName;
+            const res = await fetchImpl(`${auth.baseUrl}/api/cli/activations/pending`, {
+                headers,
+            });
+            if (res.status === 401) {
+                errLog(errorBlock('Auth failed (HTTP 401)', 'Re-run: nonbot login', { stream: process.stderr }));
+                if (sigHandler)
+                    process.off('SIGINT', sigHandler);
+                return 1;
+            }
+            if (res.ok) {
+                const body = (await res.json());
+                const pendingKills = body?.pendingKills ?? [];
+                if (pendingKills.length > 0) {
+                    for (const k of pendingKills) {
+                        log(activationCard({
+                            marker: '■',
+                            color: 'amber',
+                            id: k.activationId,
+                            headerSuffix: 'STOPPING',
+                            kv: [
+                                ['PANE', `${k.tmuxPaneId} · ^C -> 2s grace -> kill-pane`],
+                                ['REASON', 'stop received from web canvas'],
+                            ],
+                        }) + '\n');
+                    }
+                    for (const k of pendingKills)
+                        killedByStop.add(k.activationId);
+                    void activations.executePendingKills(pendingKills, auth.baseUrl, auth.pat);
+                }
+                const acts = body?.activations ?? [];
+                for (const act of acts) {
+                    if (!act?.id || seen.has(act.id))
+                        continue;
+                    seen.add(act.id);
+                    firedThisPoll = true;
+                    const outcome = await fireActivation(auth, act, deps, log, errLog);
+                    if (outcome.status === 'launched' && outcome.kind === 'real' && outcome.tmuxPaneId) {
+                        trackedPanes.set(outcome.id, outcome.tmuxPaneId);
+                    }
+                }
+                if (trackedPanes.size > 0) {
+                    await checkCompletions({
+                        tracked: trackedPanes,
+                        killed: killedByStop,
+                        baseUrl: auth.baseUrl,
+                        pat: auth.pat,
+                        spawnImpl: deps.spawnSync,
+                        fetchImpl,
+                        log,
+                    });
+                }
+                if (!firedThisPoll && pendingKills.length === 0) {
+                    log(pollTick({
+                        pending: 0,
+                        sleepMs: fixedInterval ?? currentInterval,
+                        backingOff: fixedInterval === undefined && currentInterval > POLL_FAST_MS,
+                    }) + '\n');
+                }
+                if (seen.size > 500)
+                    seen.clear();
+            }
+        }
+        catch (e) {
+            errLog(statusRow('⚠', 'poll error', e.message, { stream: process.stderr }) + '\n');
+        }
+        if (options.oneShot)
+            break;
+        if (fixedInterval !== undefined) {
+            await sleep(fixedInterval);
+        }
+        else {
+            if (firedThisPoll)
+                currentInterval = POLL_FAST_MS;
+            await sleep(currentInterval);
+            if (!firedThisPoll) {
+                currentInterval = Math.min(currentInterval * 2, maxIntervalMs);
+            }
+        }
+    }
+    if (sigHandler)
+        process.off('SIGINT', sigHandler);
+    return 0;
+}