@beunec/rivine 0.3.0 → 0.3.2

package/dist/protocol/permissions.js

@@ -104,6 +104,96 @@ const ALWAYS_ASK_COMMANDS = [
     { pattern: /curl[^|]*\|\s*(sudo\s+)?(ba)?sh|wget[^|]*\|\s*(sudo\s+)?(ba)?sh/, reason: 'pipes a download into a shell' },
     { pattern: /:\(\)\s*\{.*\|.*&.*\}/, reason: 'fork bomb' },
 ];
+const IRREVERSIBLE_COMMANDS = [
+    { pattern: /\bgit\s+push\b[^\n;&|]*(--force\b|--force-with-lease\b|\s-f\b|\s\+[\w./-]+)/, reason: 'force-pushes, rewriting history others may have' },
+    { pattern: /\bgit\s+push\b[^\n;&|]*(--delete\b|\s-d\b|\s:[\w./-]+)/, reason: 'deletes a remote branch' },
+    { pattern: /\bgh\s+repo\s+delete\b/, reason: 'deletes a GitHub repository' },
+    { pattern: /\baws\s+[\w-]+\s+(delete|terminate|remove|purge|deregister|disable-key|schedule-key-deletion)[\w-]*/, reason: 'deletes or disables AWS resources' },
+    { pattern: /\baws\s+s3\s+(rm|rb)\b/, reason: 'deletes S3 objects or buckets' },
+    { pattern: /\baws\s+s3\s+sync\b[^\n;&|]*--delete\b/, reason: 'deletes S3 objects missing from the source' },
+    { pattern: /\bgcloud\b[^\n;&|]*\s(delete|destroy)\b/, reason: 'deletes Google Cloud resources' },
+    { pattern: /\bwrangler\s+(delete\b|secret\s+(put|delete|bulk)\b|r2\s+(bucket|object)\s+delete\b|kv\s+\S+\s+delete\b|d1\s+delete\b|queues\s+delete\b)/, reason: 'deletes Cloudflare resources or writes a secret' },
+    { pattern: /\bsupabase\s+(db\s+(reset|push)\b|projects\s+delete\b|branches\s+delete\b)/, reason: 'resets, overwrites or deletes a Supabase database or project' },
+    { pattern: /\bterraform\s+(destroy\b|apply\b[^\n;&|]*-destroy\b)/, reason: 'destroys infrastructure' },
+    { pattern: /\bkubectl\s+delete\b/, reason: 'deletes cluster resources' },
+    { pattern: /\bheroku\s+(apps:destroy|pg:reset)\b|\bfly\s+(apps\s+destroy|volumes\s+destroy)\b|\bvercel\s+remove\b/, reason: 'destroys a hosted app or its data' },
+    { pattern: /\b(DROP\s+(TABLE|DATABASE|SCHEMA|ROLE)|TRUNCATE\s+(TABLE\s+)?[\w."]+)/i, reason: 'drops or empties database data' },
+    { pattern: /\bDELETE\s+FROM\s+[\w."]+\s*(;|'|"|$)/i, reason: 'deletes every row of a table' },
+    { pattern: /\bprisma\s+(migrate\s+reset\b|db\s+push\b[^\n;&|]*--force-reset\b)/, reason: 'wipes the database' },
+    { pattern: /\b(redis-cli|valkey-cli)\b[^\n;&|]*\b(FLUSHALL|FLUSHDB)\b/i, reason: 'empties a Redis database' },
+    { pattern: /\bdocker\s+(volume\s+(rm|prune)\b|system\s+prune\b[^\n;&|]*(\s-a\b|--all\b|--volumes\b))/, reason: 'deletes Docker volumes (data)' },
+    { pattern: /\bdocker(-compose|\s+compose)\s+down\b[^\n;&|]*(\s-v\b|--volumes\b)/, reason: 'deletes Docker Compose volumes (data)' },
+    { pattern: /\bmkfs(\.\w+)?\b|\bdd\s+[^\n;&|]*\bof=\/dev\//, reason: 'overwrites a disk' },
+    { pattern: /\bfind\s+(\/|~|\$HOME)\S*\s[^\n;&|]*-delete\b/, reason: 'deletes files across the disk or home folder' },
+];
+const DANGEROUS_RM_EXACT = new Set([
+    '/', '/*', '~', '~/', '~/*', '$HOME', '$HOME/', '${HOME}', '${HOME}/', '.', './', '*', './*',
+    '/workspace', '/workspace/', '/workspace/*',
+]);
+const SYSTEM_DIRS = /^\/(etc|usr|bin|sbin|var|lib|lib64|boot|dev|proc|sys|opt|srv|root|System|Library|Applications|private|Volumes|home|Users)(\/[^/]*)?\/?$/;
+const HOME_CLEANUP = /^(~|\$HOME|\$\{HOME\})\/(\.cache|\.npm|\.pnpm-store|\.yarn\/cache|\.cargo\/registry|\.gradle\/caches|\.m2\/repository|Library\/Caches|Library\/Developer\/Xcode\/DerivedData|Library\/Logs|\.Trash)(\/|$)/;
+const RM_RECURSIVE_OR_FORCE = /^-[a-zA-Z]*[rRf][a-zA-Z]*$|^--(recursive|force)$/;
+const SEGMENT_SPLIT = /\|\||&&|[;|\n]/;
+function words(segment) {
+    const out = [];
+    const re = /'([^']*)'|"([^"]*)"|(\S+)/g;
+    let m;
+    while ((m = re.exec(segment)) !== null)
+        out.push(m[1] ?? m[2] ?? m[3] ?? '');
+    return out;
+}
+function rmProblem(command) {
+    for (const segment of command.split(SEGMENT_SPLIT)) {
+        let argv = words(segment);
+        while (argv.length && (['sudo', 'command', 'nohup', 'time'].includes(argv[0]) || argv[0].includes('='))) {
+            argv = argv.slice(1);
+        }
+        if (!argv.length || argv[0].replace(/^.*\//, '') !== 'rm')
+            continue;
+        const args = argv.slice(1);
+        if (!args.some((a) => a.startsWith('-') && RM_RECURSIVE_OR_FORCE.test(a)))
+            continue;
+        for (const target of args.filter((a) => !a.startsWith('-'))) {
+            const t = target.replace(/\/+$/, '') || '/';
+            if (DANGEROUS_RM_EXACT.has(target) || DANGEROUS_RM_EXACT.has(t) || SYSTEM_DIRS.test(t) || t === '..' || t.startsWith('../')) {
+                return `deletes '${target}', a whole disk, home folder, project or system folder`;
+            }
+            if (/^(~|\$HOME|\$\{HOME\})(\/|$)/.test(t) && !HOME_CLEANUP.test(t)) {
+                return `deletes '${target}' in the home folder (only caches there are cleanup)`;
+            }
+        }
+    }
+    return null;
+}
+export function irreversibleCommand(command) {
+    for (const { pattern, reason } of IRREVERSIBLE_COMMANDS) {
+        if (pattern.test(command))
+            return reason;
+    }
+    return rmProblem(command);
+}
+const SECRET_READERS = new Set([
+    'cat', 'head', 'tail', 'less', 'more', 'grep', 'rg', 'ag', 'sed', 'awk', 'bat', 'strings', 'xxd', 'od',
+    'base64', 'cp', 'jq', 'source', '.', 'sort', 'cut', 'tac', 'nl',
+]);
+export function commandReadsSecret(command) {
+    for (const segment of command.split(SEGMENT_SPLIT)) {
+        const argv = words(segment.trim());
+        if (!argv.length)
+            continue;
+        const head = argv[0].replace(/^.*\//, '');
+        if ((head === 'env' && argv.length === 1) || head === 'printenv') {
+            return 'prints every environment variable, which usually include credentials';
+        }
+        if (!SECRET_READERS.has(head))
+            continue;
+        const secret = argv.slice(1).find((a) => !a.startsWith('-') && isSecretPath(a.replace(/^\.\//, '')));
+        if (secret)
+            return `${secret} looks like it holds credentials — reading it would send them to the model`;
+    }
+    return null;
+}
+const ALLOW_DESTRUCTIVE = Boolean(process.env.RIVINE_ALLOW_DESTRUCTIVE);
 const SHELL_CHAINING = /[;&|]|\$\(|`|>>|>|<\(/;
 const AGENT_METADATA_DIR = /^\.rivine(\/|$)/;
 export function isAgentMetadataPath(relPath) {
@@ -187,6 +277,20 @@ export function decide(input) {
             reason: `${relPath ?? 'this path'} is outside the project directory`,
         };
     }
+    if (op === 'execute' && command) {
+        const irreversible = irreversibleCommand(command);
+        if (irreversible && !(mode === 'bypass' && ALLOW_DESTRUCTIVE)) {
+            return {
+                verdict: 'ask',
+                category: 'destructive',
+                reason: `${irreversible} — this cannot be undone` +
+                    (mode === 'bypass' ? ' (set RIVINE_ALLOW_DESTRUCTIVE=1 to allow these without asking)' : ''),
+            };
+        }
+        const secretRead = commandReadsSecret(command);
+        if (secretRead)
+            return { verdict: 'ask', category: 'secret', reason: secretRead };
+    }
     if (mode === 'bypass')
         return { verdict: 'allow' };
     if (relPath && isSecretPath(relPath)) {

package/dist/protocol/runner.js

@@ -8,7 +8,7 @@
  * accompanying it; it is not open source and is not licensed for
  * redistribution or derivative works.
  */
-import { closeSession, openTurn, postFsResult, resumeTurn } from '../api/workspace.js';
+import { cancelTurn, closeSession, getTurnStatus, openTurn, postFsResult, resumeTurn, TurnBusy } from '../api/workspace.js';
 import { apiUrl } from '../config.js';
 import { accessToken } from '../auth/session.js';
 import { classify, execute } from './fsExecutor.js';
@@ -18,6 +18,24 @@ import { selectRelevantTools } from '../mcp/relevance.js';
 import { readTurnStream } from './stream.js';
 import { displayStage } from '../ui/render.js';
 const PENDING_POLL_MS = 1200;
+const FOLLOW_POLL_MS = Number(process.env.RIVINE_FOLLOW_POLL_MS) || 3000;
+export function busyChoice(policy, message) {
+    if (policy !== 'auto')
+        return policy;
+    return /^\s*(continue|go on|keep going|resume|carry on)\b[\s.!]*$/i.test(message) ? 'follow' : 'stop';
+}
+export function writtenPaths(request) {
+    const args = (request.args ?? {});
+    let paths = [];
+    if (request.op === 'write' || request.op === 'edit')
+        paths = [String(args.file_path ?? args.path ?? '')];
+    else if (request.op === 'upload')
+        paths = (args.files ?? []).map((f) => String(f?.path ?? ''));
+    return paths.filter((p) => p && !/(^|\/)\.rivine\//.test(p));
+}
+function isFollowSignal(value) {
+    return value.follow === true;
+}
 export class TurnRunner {
     ctx;
     cb;
@@ -27,6 +45,8 @@ export class TurnRunner {
     approvalChain = Promise.resolve();
     inFlight = new Set();
     stopped = false;
+    turnActive = false;
+    following = false;
     pollTimer = null;
     constructor(ctx, cb, mcp) {
         this.ctx = ctx;
@@ -82,6 +102,7 @@ export class TurnRunner {
             };
         }
         this.stopped = false;
+        this.turnActive = true;
         this.startPolling();
         const selection = selectRelevantTools(message, this.ctx.mcpTools ?? []);
         if (selection.servers.length) {
@@ -89,7 +110,7 @@ export class TurnRunner {
                 (selection.skipped.length ? ` (not needed: ${selection.skipped.join(', ')})` : ''));
         }
         try {
-            const response = await openTurn({
+            const request = {
                 workspaceId: this.ctx.workspaceId,
                 chatSpaceId: this.ctx.chatSpaceId,
                 sessionId: this.ctx.sessionId,
@@ -104,115 +125,246 @@ export class TurnRunner {
                     input_schema,
                 })),
                 sessionKey: this.key.toBase64(),
-            });
+            };
+            let response;
+            try {
+                response = await openTurn(request);
+            }
+            catch (err) {
+                if (!(err instanceof TurnBusy))
+                    throw err;
+                const choice = busyChoice(this.ctx.onBusy ?? 'auto', message);
+                if (choice === 'fail') {
+                    return {
+                        answer: '',
+                        cancelled: false,
+                        error: `${err.detail} Re-run with --on-busy follow to wait for it, or --on-busy stop to stop it and send this.`,
+                    };
+                }
+                if (choice === 'follow') {
+                    this.cb.onNotice('Your previous request is still running on the server — following it.');
+                    return await this.follow('');
+                }
+                this.cb.onNotice('Your previous request is still running on the server — stopping it and sending this one.');
+                await cancelTurn(this.ctx.workspaceId, this.ctx.chatSpaceId);
+                await this.waitUntilIdle();
+                response = await openTurn(request);
+            }
             return await this.consume(response);
         }
         finally {
+            this.turnActive = false;
+            this.following = false;
             this.stopPolling();
             await Promise.allSettled([...this.inFlight]);
         }
     }
+    async waitUntilIdle(maxMs = 30_000) {
+        const until = Date.now() + maxMs;
+        while (Date.now() < until) {
+            try {
+                const status = await getTurnStatus(this.ctx.workspaceId, this.ctx.chatSpaceId);
+                if (status.status !== 'running')
+                    return;
+            }
+            catch {
+            }
+            await new Promise((r) => setTimeout(r, 1500));
+        }
+    }
+    async stop() {
+        this.stopped = true;
+        await cancelTurn(this.ctx.workspaceId, this.ctx.chatSpaceId);
+    }
     async consume(response) {
         let answer = '';
         let pendingHitl = null;
-        for await (const event of readTurnStream(response)) {
-            switch (event.type) {
-                case 'token':
-                    answer += event.content ?? '';
-                    this.cb.onToken(event.content ?? '');
-                    break;
-                case 'stage': {
-                    const label = displayStage(String(event.label ?? ''));
-                    if (label)
-                        this.cb.onStage(label);
-                    break;
+        let continuing = false;
+        try {
+            for await (const event of readTurnStream(response)) {
+                switch (event.type) {
+                    case 'token':
+                        answer += event.content ?? '';
+                        this.cb.onToken(event.content ?? '');
+                        break;
+                    case 'stage': {
+                        const label = displayStage(String(event.label ?? ''));
+                        if (label)
+                            this.cb.onStage(label);
+                        break;
+                    }
+                    case 'tool_call_start': {
+                        const e = event;
+                        const detail = e.args?.command ?? e.args?.filename ?? '';
+                        this.cb.onTool(String(e.name ?? 'tool'), String(detail));
+                        break;
+                    }
+                    case 'file_diff': {
+                        const e = event;
+                        const path = String(e.path ?? '').trim();
+                        if (!path)
+                            break;
+                        this.cb.onFileDiff?.({
+                            path: path.replace(/^\/workspace\/?/, ''),
+                            stat: String(e.stat ?? ''),
+                            patch: String(e.patch ?? ''),
+                            added: Number(e.added ?? 0),
+                            removed: Number(e.removed ?? 0),
+                            isNew: Boolean(e.is_new),
+                            isDelete: Boolean(e.is_delete),
+                            binary: Boolean(e.binary),
+                        });
+                        break;
+                    }
+                    case 'code_file': {
+                        const e = event;
+                        const path = String(e.path ?? '').trim();
+                        const rel = path.replace(/^\/workspace\/?/, '');
+                        if (!rel || rel === '.' || rel.endsWith('/'))
+                            break;
+                        this.cb.onFileTouched(path, e.status);
+                        break;
+                    }
+                    case 'fs_request':
+                        this.dispatch(event);
+                        break;
+                    case 'approval_request': {
+                        const e = event;
+                        pendingHitl = {
+                            message: String(e.message ?? 'Approval required.'),
+                            tool: e.tool ? String(e.tool) : undefined,
+                            options: extractOptions(e),
+                            multi: Boolean(e.ui_schema?.multi ?? e.args?.multi),
+                            threadId: String(e.thread_id ?? `${this.ctx.workspaceId}_${this.ctx.chatSpaceId}`),
+                            kind: hitlKind(e.hitl_type, e.args),
+                        };
+                        break;
+                    }
+                    case 'final_answer':
+                        answer = String(event.content ?? answer);
+                        break;
+                    case 'turn_continuing':
+                        continuing = true;
+                        break;
+                    case 'error': {
+                        const e = event;
+                        return { answer, cancelled: Boolean(e.cancelled), error: String(e.content ?? 'Unknown error') };
+                    }
+                    case 'done':
+                        break;
+                    default:
+                        break;
                 }
-                case 'tool_call_start': {
-                    const e = event;
-                    const detail = e.args?.command ?? e.args?.filename ?? '';
-                    this.cb.onTool(String(e.name ?? 'tool'), String(detail));
-                    break;
+            }
+        }
+        catch (err) {
+            if (this.stopped)
+                throw err;
+            this.cb.onNotice(`The connection to this turn dropped (${err.message}); following it on the server…`);
+            return this.follow(answer);
+        }
+        if (pendingHitl) {
+            const settled = await this.settleHitl(pendingHitl, answer);
+            if (isFollowSignal(settled))
+                return this.follow(settled.answer);
+            return settled;
+        }
+        if (continuing) {
+            return this.follow(answer);
+        }
+        return { answer, cancelled: false };
+    }
+    async follow(partial) {
+        this.following = true;
+        let lastSlice = -1;
+        this.cb.onStage('Still working — continuing on the server…');
+        try {
+            while (!this.stopped) {
+                await new Promise((r) => setTimeout(r, FOLLOW_POLL_MS));
+                let status;
+                try {
+                    status = await getTurnStatus(this.ctx.workspaceId, this.ctx.chatSpaceId);
                 }
-                case 'file_diff': {
-                    const e = event;
-                    const path = String(e.path ?? '').trim();
-                    if (!path)
-                        break;
-                    this.cb.onFileDiff?.({
-                        path: path.replace(/^\/workspace\/?/, ''),
-                        stat: String(e.stat ?? ''),
-                        patch: String(e.patch ?? ''),
-                        added: Number(e.added ?? 0),
-                        removed: Number(e.removed ?? 0),
-                        isNew: Boolean(e.is_new),
-                        isDelete: Boolean(e.is_delete),
-                        binary: Boolean(e.binary),
-                    });
-                    break;
+                catch {
+                    continue;
                 }
-                case 'code_file': {
-                    const e = event;
-                    const path = String(e.path ?? '').trim();
-                    const rel = path.replace(/^\/workspace\/?/, '');
-                    if (!rel || rel === '.' || rel.endsWith('/'))
-                        break;
-                    this.cb.onFileTouched(path, e.status);
-                    break;
+                if (typeof status.slice === 'number' && status.slice !== lastSlice) {
+                    lastSlice = status.slice;
+                    this.cb.onStage(`Still working — part ${status.slice + 1}`);
                 }
-                case 'fs_request':
-                    this.dispatch(event);
-                    break;
-                case 'approval_request': {
-                    const e = event;
-                    pendingHitl = {
-                        message: String(e.message ?? 'Approval required.'),
-                        tool: e.tool ? String(e.tool) : undefined,
-                        options: extractOptions(e),
-                        multi: Boolean(e.ui_schema?.multi ?? e.args?.multi),
-                        threadId: String(e.thread_id ?? `${this.ctx.workspaceId}_${this.ctx.chatSpaceId}`),
-                        kind: hitlKind(e.hitl_type, e.args),
-                    };
-                    break;
+                if (status.status === 'done') {
+                    return { answer: String(status.content ?? partial), cancelled: false };
                 }
-                case 'final_answer':
-                    answer = String(event.content ?? answer);
-                    break;
-                case 'error': {
-                    const e = event;
-                    return { answer, cancelled: Boolean(e.cancelled), error: String(e.content ?? 'Unknown error') };
+                if (status.status === 'error') {
+                    return { answer: partial, cancelled: false, error: String(status.error ?? 'The turn failed.') };
+                }
+                if (status.status === 'cancelled') {
+                    return { answer: partial, cancelled: true };
+                }
+                if (status.status === 'paused') {
+                    if (String(status.hitl_type ?? '') === 'time_slice') {
+                        this.cb.onStage('Still working — continuing on the server…');
+                        continue;
+                    }
+                    const settled = await this.settleHitl({
+                        message: String(status.hitl_prompt ?? 'Approval required.'),
+                        tool: status.hitl_tool ? String(status.hitl_tool) : undefined,
+                        options: extractOptions({ ui_schema: status.hitl_ui_schema, args: status.hitl_args }),
+                        multi: Boolean(status.hitl_ui_schema?.multi),
+                        threadId: `${this.ctx.workspaceId}_${this.ctx.chatSpaceId}`,
+                        kind: hitlKind(status.hitl_type, status.hitl_args),
+                    }, partial);
+                    if (isFollowSignal(settled)) {
+                        partial = settled.answer;
+                        this.cb.onStage('Still working — continuing on the server…');
+                        continue;
+                    }
+                    return settled;
+                }
+                if (status.status === 'idle') {
+                    return { answer: partial, cancelled: false, error: 'The turn ended without a result.' };
                 }
-                case 'done':
-                    break;
-                default:
-                    break;
             }
+            return { answer: partial, cancelled: true };
         }
-        if (pendingHitl) {
-            return { answer: await this.settleHitl(pendingHitl), cancelled: false };
+        finally {
+            this.following = false;
         }
-        return { answer, cancelled: false };
     }
-    async settleHitl(first) {
+    async settleHitl(first, priorAnswer = '') {
         let current = first;
-        let answer = '';
+        let answer = priorAnswer;
         for (let round = 0; current && round < 25; round += 1) {
             const decision = await this.enqueuePrompt(() => this.cb.requestDecision(current));
             if (decision.codeMode)
                 this.setCodeMode(decision.codeMode);
-            const body = (await resumeTurn({
-                workspaceId: this.ctx.workspaceId,
-                chatSpaceId: this.ctx.chatSpaceId,
-                threadId: current.threadId,
-                sessionId: this.ctx.sessionId,
-                sessionKey: this.key.toBase64(),
-                approved: decision.approved,
-                feedback: decision.feedback,
-                modifiedArgs: decision.modifiedArgs,
-                codeMode: decision.codeMode ?? null,
-                codeRate: decision.codeMode ? permissionModeToRate(this.ctx.mode) : null,
-            }));
+            let body;
+            try {
+                body = await resumeTurn({
+                    workspaceId: this.ctx.workspaceId,
+                    chatSpaceId: this.ctx.chatSpaceId,
+                    threadId: current.threadId,
+                    sessionId: this.ctx.sessionId,
+                    sessionKey: this.key.toBase64(),
+                    approved: decision.approved,
+                    feedback: decision.feedback,
+                    modifiedArgs: decision.modifiedArgs,
+                    codeMode: decision.codeMode ?? null,
+                    codeRate: decision.codeMode ? permissionModeToRate(this.ctx.mode) : null,
+                });
+            }
+            catch (err) {
+                const detail = String(err.message ?? '');
+                if (/still running|background/i.test(detail)) {
+                    return this.continueAfterHitl(answer);
+                }
+                throw err;
+            }
             answer = String(body.response ?? answer);
             const meta = body.context_metadata ?? {};
+            if (meta.continuing) {
+                return this.continueAfterHitl(answer);
+            }
             current = meta.paused
                 ? {
                     message: String(meta.hitl_prompt ?? body.response ?? 'Approval required.'),
@@ -224,7 +376,39 @@ export class TurnRunner {
                 }
                 : null;
         }
-        return answer;
+        try {
+            const status = await getTurnStatus(this.ctx.workspaceId, this.ctx.chatSpaceId);
+            if (status.status === 'running' || status.continuing) {
+                return this.continueAfterHitl(answer);
+            }
+            if (status.status === 'paused' && String(status.hitl_type ?? '') !== 'time_slice') {
+                return this.settleHitl({
+                    message: String(status.hitl_prompt ?? 'Approval required.'),
+                    tool: status.hitl_tool ? String(status.hitl_tool) : undefined,
+                    options: extractOptions({ ui_schema: status.hitl_ui_schema, args: status.hitl_args }),
+                    multi: Boolean(status.hitl_ui_schema?.multi),
+                    threadId: `${this.ctx.workspaceId}_${this.ctx.chatSpaceId}`,
+                    kind: hitlKind(status.hitl_type, status.hitl_args),
+                }, answer);
+            }
+            if (status.status === 'error') {
+                return { answer, cancelled: false, error: String(status.error ?? 'The turn failed.') };
+            }
+            if (status.status === 'cancelled') {
+                return { answer, cancelled: true };
+            }
+            if (status.status === 'done' && status.content) {
+                return { answer: String(status.content), cancelled: false };
+            }
+        }
+        catch {
+        }
+        return { answer, cancelled: false };
+    }
+    async continueAfterHitl(answer) {
+        if (this.following)
+            return { follow: true, answer };
+        return this.follow(answer);
     }
     dispatch(request) {
         if (this.stopped || this.seen.has(request.request_id))
@@ -236,6 +420,10 @@ export class TurnRunner {
                 this.seen.add(id);
         }
         this.seen.add(request.request_id);
+        if (this.following && request.op !== 'ask') {
+            const args = (request.args ?? {});
+            this.cb.onTool(String(request.op), String(args.command ?? args.path ?? args.file_path ?? ''));
+        }
         const task = (async () => {
             let outcome;
             try {
@@ -285,6 +473,10 @@ export class TurnRunner {
             catch (err) {
                 outcome = { ok: false, error: err.message };
             }
+            if (this.following && outcome.ok) {
+                for (const path of writtenPaths(request))
+                    this.cb.onFileTouched(path, 'written');
+            }
             try {
                 await postFsResult(this.ctx.sessionId, request.request_id, outcome, this.key);
             }
@@ -352,8 +544,11 @@ export class TurnRunner {
         }
     }
     async shutdown() {
+        const wasActive = this.turnActive;
         this.stopped = true;
         this.stopPolling();
+        if (wasActive)
+            await cancelTurn(this.ctx.workspaceId, this.ctx.chatSpaceId);
         await closeSession(this.ctx.sessionId);
     }
 }

package/dist/protocol/shell.js

@@ -104,6 +104,9 @@ function shellInvocation(command) {
     }
     return { file: process.env.SHELL || '/bin/sh', args: ['-c', command] };
 }
+export function agentEnv() {
+    return { ...process.env, CI: process.env.CI || '1', GIT_PAGER: 'cat', PAGER: 'cat', GIT_TERMINAL_PROMPT: '0' };
+}
 function runWithPty(pty, command, options) {
     const { file, args } = shellInvocation(command);
     const tail = new Tail(MAX_OUTPUT_CHARS);
@@ -112,7 +115,7 @@ function runWithPty(pty, command, options) {
         cols: options.cols ?? 120,
         rows: options.rows ?? 30,
         cwd: options.cwd,
-        env: process.env,
+        env: agentEnv(),
     });
     let settled = false;
     let timedOut = false;
@@ -189,7 +192,7 @@ function runWithPipes(command, options) {
     const tail = new Tail(MAX_OUTPUT_CHARS);
     const child = spawn(file, args, {
         cwd: options.cwd,
-        env: process.env,
+        env: agentEnv(),
         stdio: ['pipe', 'pipe', 'pipe'],
     });
     let settled = false;

package/dist/runHeadless.js

@@ -59,6 +59,7 @@ export async function runHeadless(options) {
             root: options.cwd,
             mode: options.mode,
             codeMode: options.codeMode,
+            onBusy: options.onBusy ?? 'fail',
         }, {
             onToken: (text) => out.token(text),
             onStage: (label) => out.status(label),
@@ -105,6 +106,11 @@ export async function runHeadless(options) {
         answer = result.answer ?? '';
         if (result.error) {
             out.line('error', result.error);
+            if (/credit|insufficient/i.test(result.error)) {
+                out.line('notice', `Top up at ${siteUrl()}/credits`);
+                emit(false, 2, result.error);
+                return 2;
+            }
             emit(false, 1, result.error);
             return 1;
         }