@nonbot/cli 0.9.12 → 0.10.0

package/dist/lib/activations.js

@@ -7,8 +7,9 @@ import { resolveTerminal } from './terminal.js';
 import { getActiveProfile } from './auth.js';
 import { appendActivityLog } from './activity-log.js';
 import { activationCard, clockTime } from './output.js';
+import { scrubLine } from './snapshot.js';
 import { buildCommandFromParams, hookSettingsPathFor, shellQuoteSingle, } from './command-builders.js';
-import { validatePayload, validateActivationId, validateRepoPath, ValidationError, extractTerminalTheme, } from './payload-validator.js';
+import { validatePayload, validateActivationId, validateRepoPath, validateRepoUrl, validateRepoRef, ValidationError, extractTerminalTheme, } from './payload-validator.js';
 const PANE_ID_RE = /^%\d+$/;
 export const BUILT_COMMAND_MAX_LENGTH = 32 * 1024;
 export const WIRE_COMMAND_MAX_LENGTH = 4096;
@@ -56,7 +57,8 @@ export function resolveExecutableCommand(act, warn = (s) => console.warn(s), opt
     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) {
+    const driftBase = params.template === 'real' ? buildCommandFromParams({ ...params, wallClock: false }) : shell;
+    if (typeof act.command === 'string' && act.command.length > 0 && act.command !== driftBase) {
         warn(`[${act.id}] note: daemon-built command differs from server-supplied command (executing daemon-built; server text is informational).\n`);
     }
     if (opts.injectClaudeHook && params.template === 'real' && params.provider === 'claude') {
@@ -89,6 +91,16 @@ export function validateActivationEnvelope(act) {
             throw e;
         }
     }
+    try {
+        validateRepoUrl(act.repoUrl);
+        validateRepoRef(act.repoRef);
+    }
+    catch (e) {
+        if (e instanceof ValidationError) {
+            throw new Error(`[${act.id}] outer envelope validation failed (act.${e.field}): ${e.reason}`);
+        }
+        throw e;
+    }
     if (act.payload &&
         typeof act.payload === 'object' &&
         'repoPath' in act.payload) {
@@ -122,6 +134,23 @@ function truncate(s, max) {
         return s;
     return s.slice(0, max - 32) + `\n…[truncated to ${max}B]`;
 }
+const CHILD_ENV_ALLOW = new Set([
+    'PATH', 'HOME', 'SHELL', 'TERM', 'LANG', 'LC_ALL', 'USER', 'LOGNAME', 'TMPDIR',
+    'TMUX', 'TMUX_PANE', 'NODE_ENV', 'NONBOT_PAT', 'NONBOT_BASE_URL', 'NONBOT_RUN_ID',
+    'NONBOT_ROLE', 'NONBOT_CONFIG_DIR', 'CLAUDE_CODE_OAUTH_TOKEN',
+    'NONBOT_RUN_TIMEOUT_MIN',
+    'HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY', 'http_proxy', 'https_proxy', 'no_proxy',
+]);
+export function buildChildEnv(base, opts) {
+    const out = {};
+    for (const [k, v] of Object.entries(base)) {
+        if (CHILD_ENV_ALLOW.has(k))
+            out[k] = v;
+        else if (opts.byok && (k === 'ANTHROPIC_API_KEY' || k === 'ANTHROPIC_AUTH_TOKEN'))
+            out[k] = v;
+    }
+    return out;
+}
 export function makeHeadlessSpawner(opts) {
     return (act) => new Promise((resolve, reject) => {
         try {
@@ -140,8 +169,12 @@ export function makeHeadlessSpawner(opts) {
             return;
         }
         const cwd = act.repoPath || undefined;
+        const childEnv = buildChildEnv(process.env, {
+            byok: !process.env.CLAUDE_CODE_OAUTH_TOKEN &&
+                (!!process.env.ANTHROPIC_API_KEY || !!process.env.ANTHROPIC_AUTH_TOKEN),
+        });
         if (opts.wait) {
-            const proc = spawn('bash', ['-c', resolved.shell], { cwd, stdio: 'inherit' });
+            const proc = spawn('bash', ['-c', resolved.shell], { cwd, env: childEnv, stdio: 'inherit' });
             proc.on('error', (e) => {
                 const err = e;
                 reject(new Error(`failed to run headless: ${err.message}`));
@@ -151,13 +184,14 @@ export function makeHeadlessSpawner(opts) {
         }
         const proc = spawn('bash', ['-c', resolved.shell], {
             cwd,
+            env: childEnv,
             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`);
+                    sink(`[${act.id}] ${scrubLine(line)}\n`);
             }
         };
         proc.stdout?.on('data', (c) => prefixLines(c, opts.log));
@@ -207,7 +241,11 @@ async function captureSpawn(cmd, args) {
     });
 }
 export const _captureSpawnForTests = captureSpawn;
-export async function spawnTerminalDefault(act, auth) {
+export function exitFilePathFor(activationId) {
+    const ext = process.platform === 'darwin' ? 'command' : 'sh';
+    return path.join(tmpdir(), `nonbot-${activationId}.${ext}.exit`);
+}
+export async function spawnTerminalDefault(act, auth, opts) {
     validateActivationEnvelope(act);
     const resolved = resolveExecutableCommand(act, undefined, { injectClaudeHook: true });
     const ext = process.platform === 'darwin' ? 'command' : 'sh';
@@ -253,7 +291,9 @@ export async function spawnTerminalDefault(act, auth) {
                 `Switch to iTerm for theme support. Launching un-themed.`);
         }
     }
-    const { cmd, args } = profile.launch(scriptPath, itermProfileName ? { itermProfileName } : undefined);
+    const cloudExitFile = opts?.cloud && profile.id === 'tmux' ? exitFilePathFor(act.id) : undefined;
+    const launchOpts = itermProfileName || cloudExitFile ? { itermProfileName, cloudExitFile } : undefined;
+    const { cmd, args } = profile.launch(scriptPath, launchOpts);
     const result = await captureSpawn(cmd, args);
     const unlinkBest = async () => {
         try {

package/dist/lib/activity-log.js

@@ -1,6 +1,12 @@
 import { promises as fs } from 'node:fs';
 import { homedir } from 'node:os';
 import path from 'node:path';
+export function isExitTranscriptEntry(e) {
+    return (!!e &&
+        typeof e === 'object' &&
+        e.kind === 'exit-transcript' &&
+        typeof e.tail === 'string');
+}
 function configDir() {
     const override = process.env.NONBOT_CONFIG_DIR;
     if (override && override.length > 0)

package/dist/lib/choir/hub.js

@@ -9,6 +9,41 @@ import { makeEvent, sanitizeForEgress, assertNoForbiddenFields } from './progres
 import { LOCAL_TEXT_MAX, SUMMARY_MAX, } from './types.js';
 const DEFAULT_POLL_MS = 5_000;
 const DEFAULT_HEARTBEAT_MS = 30_000;
+const EGRESS_CHUNK = 25;
+const CLIENT_MINTED_SESSION_PREFIX = 'choir_';
+export function isClientMintedSessionId(sessionId) {
+    return typeof sessionId === 'string' && sessionId.startsWith(CLIENT_MINTED_SESSION_PREFIX);
+}
+export const EGRESS_RETRY_MAX = 200;
+const EGRESS_RETRY_BASE_MS = 5_000;
+const EGRESS_RETRY_MAX_MS = 5 * 60_000;
+export function retryQueueKey(ev) {
+    const s = typeof ev.sessionId === 'string' ? ev.sessionId : '';
+    const p = typeof ev.paneId === 'string' ? ev.paneId : '';
+    return `${s}|${p}`;
+}
+export function trimRetryQueue(queue, cap, keyOf = retryQueueKey) {
+    const limit = Number.isFinite(cap) && cap > 0 ? Math.floor(cap) : 0;
+    if (queue.length <= limit)
+        return queue;
+    const cut = queue.length - limit;
+    const tail = queue.slice(cut);
+    const covered = new Set();
+    for (const ev of tail)
+        covered.add(keyOf(ev));
+    const survivors = [];
+    for (let i = cut - 1; i >= 0; i--) {
+        const k = keyOf(queue[i]);
+        if (covered.has(k))
+            continue;
+        covered.add(k);
+        survivors.push([i, queue[i]]);
+    }
+    if (survivors.length === 0)
+        return tail;
+    survivors.reverse();
+    return [...survivors.map(([, ev]) => ev), ...tail];
+}
 const DEFAULT_WRITE_RATE_LIMIT = 60;
 const DEFAULT_WRITE_RATE_WINDOW_MS = 60_000;
 const READ_TOOLS = new Set(['run_radar', 'run_check', 'run_status']);
@@ -34,6 +69,7 @@ function constantTimeEqual(a, b) {
 export function createHub(opts) {
     const now = opts.now ?? (() => Date.now());
     const fetchImpl = opts.fetchImpl ?? fetch;
+    const log = opts.log ?? ((_s) => { });
     const spawnImpl = opts.spawnImpl;
     const journalFs = opts.journalFs ?? {
         appendFileSync: nodeAppendFileSync,
@@ -55,6 +91,10 @@ export function createHub(opts) {
     const rateWindows = new Map();
     const gate = new EmissionGate();
     let pendingEvents = [];
+    let retryQueue = [];
+    let retryNotBefore = 0;
+    let retryBackoffMs = EGRESS_RETRY_BASE_MS;
+    const localOnly = isClientMintedSessionId(opts.sessionId);
     let server = null;
     let pollTimer = null;
     let heartbeatTimer = null;
@@ -350,25 +390,76 @@ export function createHub(opts) {
                 return null;
         }
     }
-    function flushEgress() {
-        if (pendingEvents.length === 0)
-            return;
-        const batch = pendingEvents.map((e) => sanitizeForEgress(e));
-        pendingEvents = [];
-        const safe = [];
-        for (const ev of batch) {
-            try {
-                assertNoForbiddenFields(ev);
-                safe.push(ev);
+    async function flushEgress() {
+        try {
+            if (pendingEvents.length > 0) {
+                const batch = pendingEvents.map((e) => sanitizeForEgress(e));
+                pendingEvents = [];
+                for (const ev of batch) {
+                    try {
+                        assertNoForbiddenFields(ev);
+                        retryQueue.push(ev);
+                    }
+                    catch {
+                    }
+                }
+                retryQueue = trimRetryQueue(retryQueue, EGRESS_RETRY_MAX);
             }
-            catch {
+            if (localOnly) {
+                retryQueue = [];
+                return;
+            }
+            if (retryQueue.length === 0)
+                return;
+            if (now() < retryNotBefore)
+                return;
+            while (retryQueue.length > 0) {
+                const chunk = retryQueue.slice(0, EGRESS_CHUNK);
+                const outcome = await postEvents(chunk);
+                if (outcome === 'throttled') {
+                    retryQueue = trimRetryQueue(retryQueue, EGRESS_RETRY_MAX);
+                    retryNotBefore = now() + retryBackoffMs;
+                    retryBackoffMs = Math.min(retryBackoffMs * 2, EGRESS_RETRY_MAX_MS);
+                    return;
+                }
+                retryQueue = retryQueue.slice(chunk.length);
+                retryBackoffMs = EGRESS_RETRY_BASE_MS;
             }
         }
-        if (safe.length === 0)
-            return;
-        postJson(`${baseUrl}/api/cli/choir/events`, { sessionId: state.sessionId, events: safe });
+        catch {
+        }
+    }
+    async function postEvents(events) {
+        const res = await postJson(`${baseUrl}/api/cli/choir/events`, {
+            sessionId: state.sessionId,
+            events,
+        });
+        if (!res)
+            return 'dropped';
+        const status = res.status;
+        if (status === 429)
+            return 'throttled';
+        try {
+            if (typeof res.json !== 'function')
+                return 'sent';
+            const body = (await res.json());
+            if (!body || typeof body !== 'object')
+                return 'sent';
+            const skipped = body.skipped;
+            if (typeof skipped === 'number' && skipped > 0) {
+                const accepted = body.accepted;
+                log(`⚠ choir events: server skipped ${skipped} of ${events.length} ` +
+                    `(accepted ${typeof accepted === 'number' ? accepted : '?'}) — ` +
+                    `session not persisted server-side\n`);
+            }
+        }
+        catch {
+        }
+        return 'sent';
     }
     function sendHeartbeat() {
+        if (localOnly)
+            return;
         const panes = Object.values(state.panes);
         const body = {
             sessionId: state.sessionId,
@@ -407,17 +498,21 @@ export function createHub(opts) {
                 },
                 body: JSON.stringify(body),
             });
-            if (p && typeof p.catch === 'function') {
-                ;
-                p.catch(() => {
-                });
+            if (p && typeof p.then === 'function') {
+                return p.catch(() => null);
             }
+            return Promise.resolve(p ?? null);
         }
         catch {
+            return Promise.resolve(null);
         }
     }
     return {
         start() {
+            if (localOnly) {
+                log('ℹ choir hub: local session telemetry stays LOCAL — the web only ' +
+                    'persists events for server-issued run sessions.\n');
+            }
             try {
                 const impl = opts.netImpl;
                 if (!impl)
@@ -459,6 +554,9 @@ export function createHub(opts) {
         getState() {
             return state;
         },
+        retryQueueSize() {
+            return retryQueue.length;
+        },
         dispatch,
         pollOnce,
         flushEgress,

package/dist/lib/cloud-repo.js

@@ -0,0 +1,306 @@
+import { spawn as nodeSpawn, spawnSync as nodeSpawnSync } from 'node:child_process';
+import { readdirSync as nodeReaddirSync, rmSync as nodeRmSync, statSync as nodeStatSync, writeFileSync as nodeWriteFileSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { validateActivationId, validateRepoRef, repoUrlLooksSafe } from './payload-validator.js';
+const defaultWorkspaceFs = {
+    readdirSync: (p) => nodeReaddirSync(p),
+    statSync: (p) => nodeStatSync(p),
+    rmSync: (p, opts) => nodeRmSync(p, opts),
+    writeFileSync: (p, data) => nodeWriteFileSync(p, data),
+};
+const CLONE_TIMEOUT_MS = 45_000;
+const GIT_TIMEOUT_MS = 30_000;
+export const DEFAULT_CLOUD_BASE_DIR = path.join(tmpdir(), 'nonbot-cloud');
+export const MAX_CLOUD_WORKSPACES = 20;
+export const WORKSPACE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+export const REASON_TOO_MANY_WORKSPACES = 'too many workspaces';
+export const REASON_ORIGIN_TOO_BROAD = 'allowlist entry too broad';
+const OWN_REASONS = new Set([
+    'invalid repo url',
+    'origin not allowed',
+    REASON_ORIGIN_TOO_BROAD,
+    'invalid repo ref',
+    'invalid activation id',
+    REASON_TOO_MANY_WORKSPACES,
+]);
+const EXIT_CODED_REASON_RE = /^(clone|checkout) failed \(exit [-\w]+\)$/;
+const REASON_MAX = 200;
+function runGit(spawnImpl, cwd, args) {
+    return spawnImpl('git', ['-C', cwd, ...args], {
+        encoding: 'utf-8',
+        timeout: GIT_TIMEOUT_MS,
+        windowsHide: true,
+    });
+}
+function exitLabel(r) {
+    const status = r?.status;
+    return status === null || status === undefined ? 'unknown' : String(status);
+}
+function exitLabelFor(code) {
+    return code === null ? 'unknown' : String(code);
+}
+function runGitAsync(spawnImpl, args, timeoutMs) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const done = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(code);
+        };
+        let child;
+        try {
+            child = spawnImpl('git', args, {
+                timeout: timeoutMs,
+                windowsHide: true,
+                stdio: 'ignore',
+            });
+        }
+        catch {
+            done(null);
+            return;
+        }
+        try {
+            child.on('error', () => done(null));
+            child.on('close', (code) => done(typeof code === 'number' ? code : null));
+        }
+        catch {
+            done(null);
+        }
+    });
+}
+export function countCloudWorkspaces(baseDir = DEFAULT_CLOUD_BASE_DIR, fsImpl = defaultWorkspaceFs) {
+    try {
+        return fsImpl.readdirSync(baseDir).length;
+    }
+    catch {
+        return 0;
+    }
+}
+export function removeCloudWorkspace(repoPath, opts = {}) {
+    const baseDir = opts.baseDir ?? DEFAULT_CLOUD_BASE_DIR;
+    const fsImpl = opts.fsImpl ?? defaultWorkspaceFs;
+    if (typeof repoPath !== 'string' || repoPath.length === 0)
+        return false;
+    const resolved = path.resolve(repoPath);
+    const base = path.resolve(baseDir);
+    if (path.dirname(resolved) !== base)
+        return false;
+    try {
+        fsImpl.rmSync(resolved, { recursive: true, force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export const WORKSPACE_LIVENESS_FILE = '.nonbot-live';
+export function touchWorkspaceLiveness(repoPath, opts = {}) {
+    const baseDir = opts.baseDir ?? DEFAULT_CLOUD_BASE_DIR;
+    const fsImpl = opts.fsImpl ?? defaultWorkspaceFs;
+    const now = opts.now ?? Date.now;
+    if (typeof repoPath !== 'string' || repoPath.length === 0)
+        return false;
+    const resolved = path.resolve(repoPath);
+    if (path.dirname(resolved) !== path.resolve(baseDir))
+        return false;
+    if (typeof fsImpl.writeFileSync !== 'function')
+        return false;
+    try {
+        fsImpl.writeFileSync(path.join(resolved, WORKSPACE_LIVENESS_FILE), `${now()}\n`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function reapStaleWorkspaces(opts = {}) {
+    const baseDir = opts.baseDir ?? DEFAULT_CLOUD_BASE_DIR;
+    const maxAgeMs = opts.maxAgeMs ?? WORKSPACE_MAX_AGE_MS;
+    const now = opts.now ?? Date.now;
+    const fsImpl = opts.fsImpl ?? defaultWorkspaceFs;
+    const active = new Set(opts.activeIds ?? []);
+    let removed = 0;
+    let entries;
+    try {
+        entries = fsImpl.readdirSync(baseDir);
+    }
+    catch {
+        return 0;
+    }
+    const cutoff = now() - maxAgeMs;
+    for (const name of entries) {
+        if (active.has(name))
+            continue;
+        const full = path.join(baseDir, name);
+        try {
+            const st = fsImpl.statSync(full);
+            if (!st.isDirectory())
+                continue;
+            if (st.mtimeMs >= cutoff)
+                continue;
+            if (isMarkedLive(full, cutoff, fsImpl))
+                continue;
+            fsImpl.rmSync(full, { recursive: true, force: true });
+            removed++;
+        }
+        catch {
+        }
+    }
+    return removed;
+}
+function isMarkedLive(workspaceDir, cutoff, fsImpl) {
+    const marker = path.join(workspaceDir, WORKSPACE_LIVENESS_FILE);
+    let st;
+    try {
+        st = fsImpl.statSync(marker);
+    }
+    catch {
+        return false;
+    }
+    if (!st || typeof st.mtimeMs !== 'number' || !Number.isFinite(st.mtimeMs))
+        return true;
+    return st.mtimeMs >= cutoff;
+}
+export function normalizeRepoPrefix(url) {
+    let u;
+    try {
+        u = new URL(url);
+    }
+    catch {
+        return null;
+    }
+    let pathname = u.pathname.replace(/\/+$/, '');
+    while (pathname.endsWith('.git')) {
+        pathname = pathname.slice(0, -4).replace(/\/+$/, '');
+    }
+    return `${u.origin}${pathname}/`;
+}
+export function isHostWidePrefix(normalized) {
+    if (typeof normalized !== 'string' || normalized.length === 0)
+        return false;
+    try {
+        return new URL(normalized).pathname === '/';
+    }
+    catch {
+        return false;
+    }
+}
+export function classifyRepoUrl(repoUrl, allowedOrigins) {
+    if (!repoUrlLooksSafe(repoUrl))
+        return 'not_allowed';
+    if (!Array.isArray(allowedOrigins))
+        return 'not_allowed';
+    const candidate = normalizeRepoPrefix(repoUrl);
+    if (candidate === null)
+        return 'not_allowed';
+    let sawHostWideCover = false;
+    for (const o of allowedOrigins) {
+        if (typeof o !== 'string' || o.length === 0)
+            continue;
+        const entry = normalizeRepoPrefix(o);
+        if (entry === null)
+            continue;
+        if (!candidate.startsWith(entry))
+            continue;
+        if (isHostWidePrefix(entry)) {
+            sawHostWideCover = true;
+            continue;
+        }
+        return 'allowed';
+    }
+    return sawHostWideCover ? 'too_broad' : 'not_allowed';
+}
+export function repoUrlAllowed(repoUrl, allowedOrigins) {
+    return classifyRepoUrl(repoUrl, allowedOrigins) === 'allowed';
+}
+export function runBranchFor(activationId) {
+    return `run/${activationId.replace(/^act_/, '').slice(0, 8)}`;
+}
+export async function prepareCloneWorkspace(args) {
+    const spawnImpl = args.spawnImpl ?? nodeSpawn;
+    if (!repoUrlLooksSafe(args.repoUrl)) {
+        throw new Error('invalid repo url');
+    }
+    const verdict = classifyRepoUrl(args.repoUrl, args.allowedOrigins);
+    if (verdict === 'too_broad') {
+        throw new Error(REASON_ORIGIN_TOO_BROAD);
+    }
+    if (verdict !== 'allowed') {
+        throw new Error('origin not allowed');
+    }
+    let ref;
+    try {
+        ref = validateRepoRef(args.repoRef);
+    }
+    catch {
+        throw new Error('invalid repo ref');
+    }
+    try {
+        validateActivationId(args.activationId);
+    }
+    catch {
+        throw new Error('invalid activation id');
+    }
+    const baseDir = args.baseDir ?? DEFAULT_CLOUD_BASE_DIR;
+    if (countCloudWorkspaces(baseDir, args.fsImpl ?? defaultWorkspaceFs) >= MAX_CLOUD_WORKSPACES) {
+        throw new Error(REASON_TOO_MANY_WORKSPACES);
+    }
+    const repoPath = path.join(baseDir, args.activationId);
+    const branch = runBranchFor(args.activationId);
+    const cloneArgs = [
+        'clone',
+        '--depth',
+        '1',
+        '--filter=blob:none',
+        ...(ref ? ['--branch', ref] : []),
+        args.repoUrl,
+        repoPath,
+    ];
+    const cloneCode = await runGitAsync(spawnImpl, cloneArgs, CLONE_TIMEOUT_MS);
+    if (cloneCode !== 0) {
+        throw new Error(`clone failed (exit ${exitLabelFor(cloneCode)})`);
+    }
+    const checkoutCode = await runGitAsync(spawnImpl, ['-C', repoPath, 'checkout', '-b', branch], GIT_TIMEOUT_MS);
+    if (checkoutCode !== 0) {
+        throw new Error(`checkout failed (exit ${exitLabelFor(checkoutCode)})`);
+    }
+    touchWorkspaceLiveness(repoPath, { baseDir, fsImpl: args.fsImpl ?? defaultWorkspaceFs });
+    return { repoPath, branch };
+}
+export function pushRunBranch(args) {
+    const spawnImpl = args.spawnImpl ?? nodeSpawnSync;
+    const { repoPath, branch, activationId } = args;
+    const status = runGit(spawnImpl, repoPath, ['status', '--porcelain']);
+    if (!status || status.status !== 0) {
+        return { pushed: false, reason: `status failed (exit ${exitLabel(status)})` };
+    }
+    const dirty = String(status.stdout ?? '').trim() !== '';
+    if (dirty) {
+        const added = runGit(spawnImpl, repoPath, ['add', '-A']);
+        if (!added || added.status !== 0) {
+            return { pushed: false, reason: `add failed (exit ${exitLabel(added)})` };
+        }
+        const committed = runGit(spawnImpl, repoPath, [
+            'commit',
+            '-m',
+            `wip(run): ${activationId} — auto-push on exit`,
+        ]);
+        if (!committed || committed.status !== 0) {
+            return { pushed: false, reason: `commit failed (exit ${exitLabel(committed)})` };
+        }
+    }
+    const pushed = runGit(spawnImpl, repoPath, ['push', '-u', 'origin', branch]);
+    if (!pushed || pushed.status !== 0) {
+        return { pushed: false, reason: `push failed (exit ${exitLabel(pushed)})` };
+    }
+    return { pushed: true };
+}
+export function shortCloneFailureReason(e) {
+    const msg = e instanceof Error && typeof e.message === 'string' ? e.message : '';
+    if (OWN_REASONS.has(msg) || EXIT_CODED_REASON_RE.test(msg)) {
+        return msg.slice(0, REASON_MAX);
+    }
+    return 'workspace preparation failed';
+}

package/dist/lib/command-builders.js

@@ -12,6 +12,33 @@ const ESC_GREEN = '\\033[32m';
 const ESC_RED = '\\033[31m';
 const ESC_CYAN = '\\033[36m';
 const ESC_PRIMARY = '\\033[38;5;141m';
+export const RUN_TIMEOUT_DEFAULT_MIN = 95;
+export const RUN_TIMEOUT_KILL_AFTER = '60s';
+export const RUN_TIMEOUT_BIN_VAR = 'NB_RUN_TIMEOUT_BIN';
+export function resolveRunTimeoutMinutes(env = process.env) {
+    const raw = env.NONBOT_RUN_TIMEOUT_MIN;
+    if (typeof raw !== 'string' || raw.trim() === '')
+        return RUN_TIMEOUT_DEFAULT_MIN;
+    const n = Number(raw.trim());
+    if (!Number.isInteger(n) || n < 1)
+        return RUN_TIMEOUT_DEFAULT_MIN;
+    return n;
+}
+export function wallClockExceededReason(minutes) {
+    return `wall clock exceeded (${minutes}m)`;
+}
+const RUN_TIMEOUT_MISSING_NOTE = 'wall clock unenforced: no timeout/gtimeout on PATH (install coreutils)';
+export function buildRunTimeoutPrelude() {
+    const warn = emitBanner('  ' + ESC_RED + '⚠' + ESC_RESET + ' ' + ESC_DIM + RUN_TIMEOUT_MISSING_NOTE + ESC_RESET + '\n');
+    return (`if command -v timeout >/dev/null 2>&1; then ${RUN_TIMEOUT_BIN_VAR}=timeout; ` +
+        `elif command -v gtimeout >/dev/null 2>&1; then ${RUN_TIMEOUT_BIN_VAR}=gtimeout; ` +
+        `else ${RUN_TIMEOUT_BIN_VAR}=; ${warn}; fi; `);
+}
+export function buildRunTimeoutPrefix() {
+    return (`\${${RUN_TIMEOUT_BIN_VAR}:+\$${RUN_TIMEOUT_BIN_VAR} --signal=TERM ` +
+        `--kill-after=${RUN_TIMEOUT_KILL_AFTER} ` +
+        `\${NONBOT_RUN_TIMEOUT_MIN:-${RUN_TIMEOUT_DEFAULT_MIN}}m} `);
+}
 export const PROVIDER_PROFILES = {
     claude: {
         realCli: 'claude',
@@ -294,7 +321,11 @@ export function buildRealCommand(params) {
     const settingsFlag = wantHook
         ? `--settings ${shellQuoteSingle(params.hookSettingsPath)} `
         : '';
-    return `${head}${agentsMdPrefix}${hookHeredocPrefix}${bannerEmit}${cli} ${settingsFlag}${shellQuoteSingle(prompt)}`;
+    const wallClock = params.wallClock !== false;
+    const timeoutPrelude = wallClock ? buildRunTimeoutPrelude() : '';
+    const timeoutPrefix = wallClock ? buildRunTimeoutPrefix() : '';
+    return (`${head}${agentsMdPrefix}${hookHeredocPrefix}${timeoutPrelude}` +
+        `${bannerEmit}${timeoutPrefix}${cli} ${settingsFlag}${shellQuoteSingle(prompt)}`);
 }
 export function buildCommandFromParams(params) {
     switch (params.template) {