@nonbot/cli 0.9.11 → 0.9.13

package/dist/commands/daemon.js

@@ -12,6 +12,7 @@ import { groupBySession, launchCoordinatedSet, setIsIsolated, } from '../lib/cho
 import { IsolatedSessionTracker, reconcileAndCleanup as defaultReconcileAndCleanup, resolveBaseBranch as defaultResolveBaseBranch, } from '../lib/choir/isolated-session.js';
 import { applyPaneTitle, applyPaneState } from '../lib/pane-title.js';
 import { installService, uninstallService } from '../lib/service.js';
+import { probeTmuxAttached, postDaemonStopAck, requestRemoteDaemonStop, stopDaemonLocally, attachDaemonSession, writePidFile, removePidFile, } from '../lib/daemon-lifecycle.js';
 import { detectTmuxSession, inTmuxSession, nonbotTmuxOptOut, resolveTerminal, } from '../lib/terminal.js';
 import { VERSION } from '../version.js';
 import { errorBlock, statusRow, daemonOpener, daemonCloser, activationCard, runSummary, formatElapsed, liveFooter, needsYouBanner, resumedLine, buildPaneBorderFormat, buildTmuxStatusLeft, buildTmuxStatusRight, WORDMARK_WIDTH, c, } from '../lib/output.js';
@@ -160,6 +161,36 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
     const fixedInterval = options.pollIntervalMs;
     const maxIntervalMs = options.maxPollIntervalMs ?? POLL_MAX_MS;
     let currentInterval = fixedInterval ?? POLL_FAST_MS;
+    if (args[0] === 'stop') {
+        const stopArgs = args.slice(1);
+        const all = stopArgs.includes('--all');
+        const machineFlag = stopArgs.indexOf('--machine');
+        const targetMachine = machineFlag >= 0 ? stopArgs[machineFlag + 1] : undefined;
+        if (all || targetMachine) {
+            const auth = await loader();
+            if (!auth) {
+                errLog(errorBlock('Not logged in', 'Run `nonbot login` to authenticate.', { stream: process.stderr }));
+                return 1;
+            }
+            return requestRemoteDaemonStop({
+                auth, machineId: targetMachine ?? null, all, fetchImpl,
+                log: rawLog, errLog,
+            });
+        }
+        return stopDaemonLocally({
+            log: rawLog, errLog,
+            spawnImpl: deps.spawnSync,
+        });
+    }
+    if (args[0] === 'attach') {
+        const sessionFlag = args.indexOf('--session');
+        const sessionName = sessionFlag >= 0 ? args[sessionFlag + 1] : undefined;
+        return attachDaemonSession({
+            log: rawLog, errLog,
+            spawnImpl: deps.spawnSync,
+            ...(sessionName ? { sessionName } : {}),
+        });
+    }
     if (args.includes('--install')) {
         const install = deps.installService ?? installService;
         const res = await install();
@@ -198,6 +229,8 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
     const tmuxSessionName = detectTmux();
     const machineId = deps.machineId ?? loadOrCreateMachineId();
     const machineName = resolveMachineName();
+    if (!options.oneShot)
+        writePidFile(process.pid);
     const tmuxChromeEnabled = tmuxSessionName !== null &&
         !nonbotTmuxOptOut() &&
         process.env.NONBOT_NO_TMUX_STATUS !== '1';
@@ -399,10 +432,12 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
             for (const id of [...runHeartbeats.keys()])
                 stopHeartbeat(id);
             pushTmuxStatus(0, true);
-            rawLog('\n' + statusRow('✓', 'daemon stopped', 'Ctrl-C received') + '\n');
+            removePidFile();
+            rawLog('\n' + statusRow('✓', 'daemon stopped', 'signal received') + '\n');
             process.exit(0);
         };
         process.on('SIGINT', sigHandler);
+        process.on('SIGTERM', sigHandler);
     }
     const hostUrl = new URL(auth.baseUrl).host;
     const profileName = getActiveProfile();
@@ -476,8 +511,12 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                 'X-Prompts-Open': String(openPrompts.size),
                 'X-Poll-Interval-Ms': String(fixedInterval ?? currentInterval),
             };
-            if (tmuxSessionName)
+            if (tmuxSessionName) {
                 headers['X-Tmux-Session'] = tmuxSessionName;
+                const attached = (deps.probeTmuxAttached ?? probeTmuxAttached)(deps.spawnSync);
+                if (attached !== null)
+                    headers['X-Tmux-Attached'] = attached ? 'true' : 'false';
+            }
             if (lastFailureReason)
                 headers['X-Last-Failure-Reason'] = lastFailureReason;
             const res = await fetchImpl(`${auth.baseUrl}/api/cli/activations/pending`, {
@@ -485,8 +524,11 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
             });
             if (res.status === 401) {
                 errLog(errorBlock('Auth failed (HTTP 401)', 'Re-run: nonbot login', { stream: process.stderr }));
-                if (sigHandler)
+                if (sigHandler) {
                     process.off('SIGINT', sigHandler);
+                    process.off('SIGTERM', sigHandler);
+                }
+                removePidFile();
                 return 1;
             }
             if (res.ok) {
@@ -515,6 +557,45 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                     }
                     void activations.executePendingKills(pendingKills, auth.baseUrl, auth.pat);
                 }
+                if (body?.shutdown?.requested === true) {
+                    running = false;
+                    const scopeLabel = body.shutdown.scope === 'all' ? 'all machines' : 'this machine';
+                    log('\n' + statusRow('⚠', 'daemon stop received', `remote stop · ${scopeLabel}`) + '\n');
+                    const kills = [...trackedPanes.entries()]
+                        .filter(([id]) => !killedByStop.has(id))
+                        .map(([activationId, tmuxPaneId]) => ({ activationId, tmuxPaneId }));
+                    for (const k of kills) {
+                        killedByStop.add(k.activationId);
+                        retitlePane('stopping', k.tmuxPaneId, trackedMeta.get(k.activationId)?.story ?? '');
+                        safeEmit(k.activationId, RUN_STAGE.STOPPED);
+                        stopHeartbeat(k.activationId);
+                    }
+                    if (kills.length > 0) {
+                        log(statusRow('⚠', `stopping ${kills.length} run${kills.length === 1 ? '' : 's'}`, '^C -> 2s grace -> kill-pane') + '\n');
+                        try {
+                            await activations.executePendingKills(kills, auth.baseUrl, auth.pat);
+                        }
+                        catch { }
+                    }
+                    for (const id of [...runHeartbeats.keys()])
+                        stopHeartbeat(id);
+                    await postDaemonStopAck({ baseUrl: auth.baseUrl, pat: auth.pat, machineId, fetchImpl });
+                    pushTmuxStatus(0, true);
+                    removePidFile();
+                    if (sigHandler) {
+                        process.off('SIGINT', sigHandler);
+                        process.off('SIGTERM', sigHandler);
+                    }
+                    rawLog('\n' + statusRow('✓', 'daemon stopped', `remote stop · ${scopeLabel}`) + '\n');
+                    if (tmuxSessionName) {
+                        const sp = (deps.spawnSync ?? nodeSpawnSync);
+                        try {
+                            sp('tmux', ['kill-session', '-t', tmuxSessionName], { timeout: 2000 });
+                        }
+                        catch { }
+                    }
+                    return 0;
+                }
                 const snapshotRequests = body?.snapshotRequests ?? [];
                 if (Array.isArray(snapshotRequests) && snapshotRequests.length > 0) {
                     try {
@@ -765,7 +846,11 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
             }
         }
     }
-    if (sigHandler)
+    if (sigHandler) {
         process.off('SIGINT', sigHandler);
+        process.off('SIGTERM', sigHandler);
+    }
+    if (!options.oneShot)
+        removePidFile();
     return 0;
 }

package/dist/index.js

@@ -21,7 +21,7 @@ const COMMANDS = [
     },
     {
         name: 'daemon',
-        description: 'Long-running listener — polls /api/cli/activations/pending every 2s.',
+        description: 'Long-running listener — polls /api/cli/activations/pending every 2s. `nonbot daemon stop` stops it (local; --machine <id> / --all go remote); `nonbot daemon attach` reattaches a lost tmux window.',
         run: (args) => runDaemonCommand(args),
     },
     {

package/dist/lib/daemon-lifecycle.js

@@ -0,0 +1,185 @@
+import { homedir } from 'node:os';
+import * as nodeFs from 'node:fs';
+import * as path from 'node:path';
+import { spawnSync as nodeSpawnSync } from 'node:child_process';
+import { VERSION } from '../version.js';
+function configDir() {
+    const override = process.env.NONBOT_CONFIG_DIR;
+    if (override && override.length > 0)
+        return override;
+    return path.join(homedir(), '.config', 'nonbot');
+}
+export function pidFilePath(dir = configDir()) {
+    return path.join(dir, 'daemon.pid');
+}
+export function writePidFile(pid, deps = {}) {
+    const fs = deps.fs ?? nodeFs;
+    const dir = deps.dir ?? configDir();
+    try {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        fs.writeFileSync(pidFilePath(dir), String(pid), { mode: 0o600 });
+    }
+    catch { }
+}
+export function readPidFile(deps = {}) {
+    const fs = deps.fs ?? nodeFs;
+    const dir = deps.dir ?? configDir();
+    try {
+        const file = pidFilePath(dir);
+        if (!fs.existsSync(file))
+            return null;
+        const pid = Number.parseInt(fs.readFileSync(file, 'utf-8').trim(), 10);
+        return Number.isInteger(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function removePidFile(deps = {}) {
+    const fs = deps.fs ?? nodeFs;
+    const dir = deps.dir ?? configDir();
+    try {
+        fs.unlinkSync(pidFilePath(dir));
+    }
+    catch { }
+}
+export function probeTmuxAttached(spawnImpl) {
+    const spawn = spawnImpl ?? nodeSpawnSync;
+    try {
+        const result = spawn('tmux', ['display-message', '-p', '#{session_attached}'], {
+            encoding: 'utf-8',
+            timeout: 1000,
+            windowsHide: true,
+        });
+        if (result.status === 0 && typeof result.stdout === 'string') {
+            const n = Number.parseInt(result.stdout.trim(), 10);
+            if (Number.isInteger(n) && n >= 0)
+                return n > 0;
+        }
+    }
+    catch { }
+    return null;
+}
+export async function postDaemonStopAck(opts) {
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    try {
+        const res = await fetchImpl(`${opts.baseUrl}/api/cli/daemon/stop-ack`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${opts.pat}`,
+                'Content-Type': 'application/json',
+                'X-Requested-With': 'ConradPM-Native',
+                'X-CLI-Version': VERSION,
+            },
+            body: JSON.stringify({ machineId: opts.machineId }),
+            signal: AbortSignal.timeout(5000),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export async function requestRemoteDaemonStop(opts) {
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    try {
+        const res = await fetchImpl(`${opts.auth.baseUrl}/api/run/daemon/stop`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${opts.auth.pat}`,
+                'Content-Type': 'application/json',
+                'X-Requested-With': 'ConradPM-Native',
+                'X-CLI-Version': VERSION,
+            },
+            body: JSON.stringify(opts.all ? { all: true } : { machineId: opts.machineId }),
+        });
+        if (res.ok) {
+            const target = opts.all ? 'every machine' : `machine ${opts.machineId}`;
+            opts.log(`✓ stop queued for ${target} — the daemon exits on its next poll (≤30s)\n`);
+            return 0;
+        }
+        opts.errLog(`✗ server refused the stop (HTTP ${res.status})\n`);
+        return 1;
+    }
+    catch (e) {
+        opts.errLog(`✗ could not reach the server: ${e.message}\n`);
+        return 1;
+    }
+}
+export function attachDaemonSession(deps) {
+    const spawn = deps.spawnImpl ?? nodeSpawnSync;
+    const sessionName = deps.sessionName ?? 'nonbot';
+    try {
+        const probe = spawn('tmux', ['has-session', '-t', sessionName], {
+            encoding: 'utf-8', timeout: 2000, windowsHide: true,
+        });
+        if (probe.status !== 0) {
+            deps.errLog(`✗ no tmux session '${sessionName}' to attach to.\n  Start the daemon first: nonbot daemon\n`);
+            return 1;
+        }
+    }
+    catch {
+        deps.errLog('✗ tmux not found — install it (brew install tmux) or run the daemon without tmux.\n');
+        return 1;
+    }
+    deps.log(`↳ attaching to tmux session '${sessionName}' — press Ctrl-B then D to detach again.\n`);
+    try {
+        const res = spawn('tmux', ['attach', '-t', sessionName], {
+            ...{ stdio: 'inherit' },
+            windowsHide: true,
+        });
+        return res.status === 0 ? 0 : 1;
+    }
+    catch {
+        deps.errLog(`✗ could not attach to '${sessionName}'.\n`);
+        return 1;
+    }
+}
+export async function stopDaemonLocally(deps) {
+    const kill = deps.kill ?? ((pid, sig) => process.kill(pid, sig));
+    const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const spawn = deps.spawnImpl ?? nodeSpawnSync;
+    const sessionName = deps.sessionName ?? 'nonbot';
+    const alive = (pid) => {
+        try {
+            kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const pid = readPidFile(deps);
+    if (pid !== null && alive(pid)) {
+        try {
+            kill(pid, 'SIGTERM');
+        }
+        catch { }
+        for (let i = 0; i < 6; i++) {
+            await sleep(500);
+            if (!alive(pid)) {
+                removePidFile(deps);
+                deps.log(`✓ daemon stopped (pid ${pid})\n`);
+                return 0;
+            }
+        }
+        deps.errLog(`⚠ pid ${pid} did not exit after SIGTERM — try: kill -9 ${pid}\n`);
+        return 1;
+    }
+    if (pid !== null)
+        removePidFile(deps);
+    try {
+        const result = spawn('tmux', ['kill-session', '-t', sessionName], {
+            encoding: 'utf-8',
+            timeout: 2000,
+            windowsHide: true,
+        });
+        if (result.status === 0) {
+            deps.log(`✓ tmux session '${sessionName}' killed (no PID file — pre-0.9.12 daemon?)\n`);
+            return 0;
+        }
+    }
+    catch { }
+    deps.errLog(`✗ nothing to stop — no PID file and no tmux session '${sessionName}'.\n  If a daemon is running elsewhere: nonbot daemon stop --machine <id> (see /run)\n`);
+    return 1;
+}

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.9.11';
+export const VERSION = '0.9.13';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nonbot/cli",
-  "version": "0.9.11",
+  "version": "0.9.13",
   "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",