@north-light/crouter 0.3.302 → 0.3.304

package/dist/pi-extensions/__tests__/integration/canvas-bash-valve.test.js

@@ -0,0 +1,133 @@
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { test } from 'node:test';
+import { backgroundRunningBashJobs, bashJobsDir, bashJobPaths, readJobPgid, stopBackgroundBashJob } from '../../../core/bash-jobs.js';
+import { capturePidIdentities, isPidAlive } from '../../../core/canvas/pid.js';
+import { BACKGROUND_BASH_LOG_TRUNCATION_MARKER, MAX_BACKGROUND_BASH_LOG_BYTES, createValveOperations } from '../../canvas-bash-valve.js';
+const POLL_MS = 20;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitFor(condition, message) {
+    const deadline = Date.now() + 4_000;
+    while (Date.now() < deadline) {
+        if (condition())
+            return;
+        await sleep(POLL_MS);
+    }
+    throw new Error(message);
+}
+async function backgroundOneJob(contextDir) {
+    await waitFor(() => backgroundRunningBashJobs(contextDir).length === 1, 'bash job did not start');
+    await waitFor(() => {
+        try {
+            return readdirSync(bashJobsDir(contextDir)).length === 1;
+        }
+        catch {
+            return false;
+        }
+    }, 'background job directory was not created');
+    return readdirSync(bashJobsDir(contextDir))[0];
+}
+function killOwnedProcess(pid) {
+    if (pid === undefined)
+        return;
+    try {
+        process.kill(pid, 'SIGKILL');
+    }
+    catch {
+        // The test already stopped this exact process.
+    }
+}
+test('background cancellation reaches a descendant that changed process groups', { timeout: 10_000 }, async () => {
+    const root = mkdtempSync(join(tmpdir(), 'crtr-bash-tree-'));
+    const contextDir = join(root, 'context');
+    const escapedPidPath = join(root, 'escaped.pid');
+    let escapedPid;
+    try {
+        const python = [
+            'import os, pathlib, time',
+            'os.setpgrp()',
+            `pathlib.Path(${JSON.stringify(escapedPidPath)}).write_text(f"{os.getpid()} {os.getpgrp()}")`,
+            'time.sleep(30)',
+        ].join('; ');
+        const run = createValveOperations('test-node', contextDir).exec(`python3 -c ${JSON.stringify(python)}`, root, { onData: () => { } });
+        const jobId = await backgroundOneJob(contextDir);
+        await run;
+        await waitFor(() => existsSync(escapedPidPath), 'escaped descendant did not start');
+        const [pidText, pgidText] = readFileSync(escapedPidPath, 'utf8').split(' ');
+        escapedPid = Number(pidText);
+        const escapedPgid = Number(pgidText);
+        assert.ok(Number.isInteger(escapedPid) && escapedPid > 1);
+        assert.notEqual(escapedPgid, readJobPgid(contextDir, jobId));
+        const stopped = await stopBackgroundBashJob(contextDir, jobId);
+        assert.equal(stopped.kind, 'stopped');
+        assert.equal(stopped.signaled, true);
+        await waitFor(() => {
+            try {
+                process.kill(escapedPid, 0);
+                return false;
+            }
+            catch {
+                return true;
+            }
+        }, 'escaped descendant survived background cancellation');
+    }
+    finally {
+        killOwnedProcess(escapedPid);
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('stale background metadata never signals a reused supervisor PID', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'crtr-bash-stale-pid-'));
+    const contextDir = join(root, 'context');
+    const child = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 30_000)']);
+    try {
+        assert.notEqual(child.pid, undefined);
+        const actualIdentity = capturePidIdentities([child.pid])?.get(child.pid);
+        assert.notEqual(actualIdentity, undefined);
+        const paths = bashJobPaths(contextDir, '1234567890-stale');
+        mkdirSync(paths.dir, { recursive: true });
+        writeFileSync(paths.jobBg, '');
+        writeFileSync(paths.jobPgid, String(child.pid));
+        writeFileSync(paths.jobPgidIdentity, 'stale-supervisor');
+        const stopped = await stopBackgroundBashJob(contextDir, paths.jobId);
+        assert.deepEqual(stopped, { kind: 'stopped', signaled: false, pgid: child.pid, logPath: paths.jobLog });
+        assert.equal(isPidAlive(child.pid), true, 'a process with a reused supervisor PID was signaled');
+    }
+    finally {
+        child.kill('SIGKILL');
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('background log retains a capped prefix, truncation marker, and does not grow afterward', { timeout: 10_000 }, async () => {
+    const root = mkdtempSync(join(tmpdir(), 'crtr-bash-log-'));
+    const contextDir = join(root, 'context');
+    try {
+        const writer = [
+            'const chunk = Buffer.alloc(1024 * 1024, 120)',
+            'setTimeout(() => {',
+            '  for (let i = 0; i < 11; i += 1) process.stdout.write(chunk)',
+            '  setTimeout(() => process.stdout.write("after-cap"), 200)',
+            '}, 200)',
+            'setTimeout(() => {}, 1_000)',
+        ].join('; ');
+        const run = createValveOperations('test-node', contextDir).exec(`${process.execPath} -e ${JSON.stringify(writer)}`, root, { onData: () => { } });
+        const jobId = await backgroundOneJob(contextDir);
+        await run;
+        const { jobExit, jobLog } = bashJobPaths(contextDir, jobId);
+        await waitFor(() => existsSync(jobLog) && readFileSync(jobLog, 'utf8').includes(BACKGROUND_BASH_LOG_TRUNCATION_MARKER), 'log did not record truncation');
+        const sizeAtCap = statSync(jobLog).size;
+        assert.ok(sizeAtCap <= MAX_BACKGROUND_BASH_LOG_BYTES);
+        await sleep(500);
+        assert.equal(statSync(jobLog).size, sizeAtCap, 'discarded output continued growing the log');
+        await waitFor(() => existsSync(jobExit), 'writer did not finish');
+        assert.equal(readFileSync(jobExit, 'utf8').trim(), '0', 'collector changed the writer exit status');
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});

package/dist/pi-extensions/canvas-bash-valve.d.ts

@@ -1,8 +1,7 @@
 import { createBashToolDefinition, type BashOperations } from '@earendil-works/pi-coding-agent';
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
-/** Seconds a leading `sleep ...` will block for, or null when the command does
- *  not open with a sleep (or its duration isn't statically knowable). */
-export declare function leadingSleepSeconds(command: string): number | null;
+export declare const MAX_BACKGROUND_BASH_LOG_BYTES: number;
+export declare const BACKGROUND_BASH_LOG_TRUNCATION_MARKER = "\n[background bash job output truncated at 10 MiB; remaining output discarded]\n";
 /** The valve's BashOperations backend. Each tool execution closes over its own
  * `takePurpose` and its own preview-result path, so concurrent calls cannot
  * exchange labels or result mirrors. The purpose is consumed even when the

package/dist/pi-extensions/canvas-bash-valve.js

@@ -18,8 +18,9 @@
 // SIGPIPE, and its exit code is observable by nobody. So every command is
 // file-backed from birth via a tiny detached supervisor (a `bash -c` process
 // group leader) that redirects the real command's stdout+stderr to a log
-// file and records its exit code to a sentinel file — both readable, and
-// tail-able, independent of whether this pi process is even still alive.
+// file through a bounded collector and records its exit code to a sentinel
+// file — both readable and tail-able, independent of whether this pi process
+// is even still alive.
 //
 // Deviation from upstream: this backend pins `bash` as the shell (upstream
 // consults user shell config via non-exported helpers). Acceptable — crtr's
@@ -30,7 +31,9 @@ import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, rmS
 import { homedir } from 'node:os';
 import { dirname } from 'node:path';
 import { performance } from 'node:perf_hooks';
-import { backgroundBashJob, bashJobPaths, formatBashElapsed, newBashJobId, normalizeBashJobPurpose, readBashNiceness, writeJobDeadlineMs } from '../core/bash-jobs.js';
+import { backgroundBashJob, bashJobPaths, cancelBashJobProcessTree, formatBashElapsed, newBashJobId, normalizeBashJobPurpose, readBashNiceness, writeJobDeadlineMs } from '../core/bash-jobs.js';
+import { bashCommandRefusal } from '../core/bash-guard.js';
+import { capturePidIdentities } from '../core/canvas/pid.js';
 import { readConfig } from '../core/config.js';
 import { PREVIEW_RESULT_PATH_ENV, previewResultPath } from '../core/preview-result-path.js';
 import { resolveAdmittedHostCommand } from '../core/runtime/spawn-env.js';
@@ -42,18 +45,44 @@ const POLL_MS = 200;
 function resolveValveMs() {
     return envBashValveMs();
 }
-// The detached supervisor. Spawned with `detached: true` so it becomes its
-// own process-group leader (pgid === its pid) — killing `-pgid` reaches the
-// real command and anything it forked, even after this pi process exits.
-//
-// Positional argv (never interpolated into the script — the command text
-// lives only in cmd.sh):
+export const MAX_BACKGROUND_BASH_LOG_BYTES = 10 * 1024 * 1024;
+export const BACKGROUND_BASH_LOG_TRUNCATION_MARKER = '\n[background bash job output truncated at 10 MiB; remaining output discarded]\n';
+// This process owns one bounded prefix of the command stream. It keeps
+// draining after the cap so the command never sees a closed pipe/SIGPIPE, and
+// uses synchronous fixed-size stdin chunks plus direct file writes so neither
+// the collector nor the log can grow without bound.
+const LOG_COLLECTOR_SCRIPT = [
+    'const fs = require("node:fs");',
+    `const cap = ${MAX_BACKGROUND_BASH_LOG_BYTES};`,
+    `const marker = Buffer.from(${JSON.stringify(BACKGROUND_BASH_LOG_TRUNCATION_MARKER)});`,
+    'const prefixCap = cap - marker.length;',
+    'const fd = fs.openSync(process.argv[1], "w");',
+    'let written = 0;',
+    'let truncated = false;',
+    'process.stdin.on("data", (chunk) => {',
+    '  if (truncated) return;',
+    '  const available = prefixCap - written;',
+    '  if (available > 0) {',
+    '    const prefix = chunk.subarray(0, available);',
+    '    fs.writeSync(fd, prefix);',
+    '    written += prefix.length;',
+    '    if (prefix.length === chunk.length) return;',
+    '  }',
+    '  fs.writeSync(fd, marker);',
+    '  truncated = true;',
+    '});',
+    'process.stdin.on("end", () => fs.closeSync(fd));',
+].join(' ');
+// The detached supervisor owns the command and its bounded stream collector.
+// Positional argv (never interpolated into the script — the command text lives
+// only in cmd.sh):
 //   $1 cmd.sh     $2 job.log   $3 job.exit   $4 job.run
 //   $5 job.done   $6 job.bg    $7 jobId      $8 nodeId      $9 shell path
-//   ${10} niceness
+//   ${10} niceness ${11} node path
 //
 // `--` before the paths is a dummy $0 (a standard `bash -c script -- args`
 // idiom) so the real payload lands at $1 onward.
+//
 // The elapsed rendering mirrors formatBashElapsed() in core/bash-jobs.ts
 // (`12s` / `3m 40s` / `1h 04m`) so the completion message reads the same as the
 // handoff notice; it measures TOTAL runtime, foreground portion included.
@@ -63,8 +92,8 @@ function resolveValveMs() {
 const SUPERVISOR_SCRIPT = [
     'SECONDS=0',
     'n=$(command -v nice)',
-    '${n:+"$n" -n "${10}"} "${9}" "$1" > "$2" 2>&1',
-    'ec=$?',
+    '${n:+"$n" -n "${10}"} "${9}" "$1" 2>&1 | "${11}" -e ' + JSON.stringify(LOG_COLLECTOR_SCRIPT) + ' "$2"',
+    'ec=${PIPESTATUS[0]}',
     'd=$SECONDS',
     'echo "$ec" > "$3"',
     'if [ "$d" -lt 60 ]; then',
@@ -106,25 +135,9 @@ function installTerminationHandoff() {
     if (process.platform !== 'win32')
         process.prependListener('SIGHUP', backgroundLiveJobsForTermination);
 }
-function killGroup(pgid) {
-    try {
-        process.kill(-pgid, 'SIGTERM');
-    }
-    catch {
-        /* already gone */
-    }
-    const killer = setTimeout(() => {
-        try {
-            process.kill(-pgid, 'SIGKILL');
-        }
-        catch {
-            /* already gone */
-        }
-    }, 2000);
-    killer.unref?.();
-}
+const TAIL_CHUNK_BYTES = 64 * 1024;
 /** Read bytes appended to `path` since `offset`, feed them to onData, return
- *  the new offset. Best-effort — a not-yet-created log file is not an error. */
+ * the new offset. Best-effort — a not-yet-created log file is not an error. */
 function tailOnce(path, offset, onData) {
     let stat;
     try {
@@ -137,10 +150,16 @@ function tailOnce(path, offset, onData) {
         return offset;
     const fd = openSync(path, 'r');
     try {
-        const buf = Buffer.alloc(stat.size - offset);
-        readSync(fd, buf, 0, buf.length, offset);
-        onData(buf);
-        return stat.size;
+        while (offset < stat.size) {
+            const length = Math.min(TAIL_CHUNK_BYTES, stat.size - offset);
+            const buf = Buffer.allocUnsafe(length);
+            const bytesRead = readSync(fd, buf, 0, length, offset);
+            if (bytesRead === 0)
+                break;
+            onData(buf.subarray(0, bytesRead));
+            offset += bytesRead;
+        }
+        return offset;
     }
     finally {
         closeSync(fd);
@@ -164,39 +183,6 @@ function readExitCode(path) {
         return null;
     }
 }
-// Long-sleep guard. A command that opens with `sleep <long>` is a node burning
-// a live window to wait on a clock — the runtime already has waiting primitives
-// that cost nothing (`crtr cron` for a scheduled wake, `crtr node wait deadline`
-// for an inbox-vs-deadline race). Anything over 10s is refused before it runs.
-const MAX_INLINE_SLEEP_SECONDS = 10;
-const SLEEP_UNIT_SECONDS = { s: 1, m: 60, h: 3600, d: 86400 };
-/** Seconds a leading `sleep ...` will block for, or null when the command does
- *  not open with a sleep (or its duration isn't statically knowable). */
-export function leadingSleepSeconds(command) {
-    const match = /^\s*sleep(\s+[^;&|\n]+)/.exec(command);
-    if (!match)
-        return null;
-    // `sleep 1 2m 3` sums its operands.
-    let total = 0;
-    for (const operand of match[1].trim().split(/\s+/)) {
-        const parsed = /^([0-9]*\.?[0-9]+)([smhd]?)$/.exec(operand);
-        if (!parsed)
-            return null; // variable/expansion/flag — not statically knowable
-        total += Number(parsed[1]) * SLEEP_UNIT_SECONDS[parsed[2] || 's'];
-    }
-    return total;
-}
-function longSleepRefusal(command) {
-    const seconds = leadingSleepSeconds(command);
-    if (seconds === null || seconds <= MAX_INLINE_SLEEP_SECONDS)
-        return null;
-    return (`Refused: this command starts by sleeping ${seconds}s, over the ${MAX_INLINE_SLEEP_SECONDS}s inline limit.\n` +
-        `Holding a live window on a clock is never how you wait here. Instead:\n` +
-        `  - schedule the wake and end your turn: crtr cron -h (one-shot at a time, or recurring)\n` +
-        `  - race an inbox message against a deadline: crtr node wait deadline -h\n` +
-        `  - waiting on a child, a reply from the user, or any spine event: just stop — the runtime wakes you.\n` +
-        `If you truly need a short pause inline, sleep ${MAX_INLINE_SLEEP_SECONDS}s or less.`);
-}
 /** A node can legitimately remove its own merged worktree. Never recreate that
  *  path: it would look like a valid checkout but no longer be one. Run later
  *  commands from a durable directory instead, and make the changed semantics
@@ -228,7 +214,7 @@ export function createValveOperations(nodeId, contextDir, takePurpose = () => nu
                     reject(new Error('aborted'));
                     return;
                 }
-                const refusal = longSleepRefusal(command);
+                const refusal = bashCommandRefusal(command, cwd);
                 if (refusal !== null) {
                     reject(new Error(refusal));
                     return;
@@ -243,6 +229,7 @@ export function createValveOperations(nodeId, contextDir, takePurpose = () => nu
                 let offset = 0;
                 let settled = false;
                 let pgid;
+                let pgidIdentity;
                 const startedAt = performance.now();
                 const valveMs = resolveValveMs();
                 let interval;
@@ -277,7 +264,7 @@ export function createValveOperations(nodeId, contextDir, takePurpose = () => nu
                     const notice = `\n[backgrounded as job ${paths.jobId} after ${elapsed} in the foreground${auto ? ' (auto)' : ''}. ` +
                         deadlineNotice +
                         `It will interrupt you with a message when it exits. ` +
-                        `Watch: tail -f ${paths.jobLog} ; stop: kill -- -${pgid}]`;
+                        `Watch: tail -f ${paths.jobLog} ; stop: crtr node bash kill ${paths.jobId}]`;
                     onData(Buffer.from(notice));
                     finish(() => resolve({ exitCode: 0 }));
                     // Backgrounded — job dir persists (inspectable); no cleanup here.
@@ -311,8 +298,8 @@ export function createValveOperations(nodeId, contextDir, takePurpose = () => nu
                     // finish the job.run → job.done transition before cleanup.
                     if (existsSync(paths.jobExit))
                         return;
-                    if (pgid)
-                        killGroup(pgid);
+                    if (pgid !== undefined && pgidIdentity !== undefined)
+                        void cancelBashJobProcessTree(pgid, pgidIdentity);
                     finish(() => reject(new Error('aborted')));
                     cleanupJobDir(paths.dir);
                 }
@@ -334,7 +321,7 @@ export function createValveOperations(nodeId, contextDir, takePurpose = () => nu
                     childEnv = { ...childEnv, [PREVIEW_RESULT_PATH_ENV]: previewPath };
                 }
                 const shellPath = resolveAdmittedHostCommand('bash', childEnv, execution.cwd);
-                const child = spawn(shellPath, ['-c', SUPERVISOR_SCRIPT, '--', paths.cmdSh, paths.jobLog, paths.jobExit, paths.jobRun, paths.jobDone, paths.jobBg, paths.jobId, nodeId, shellPath, String(readBashNiceness(contextDir))], {
+                const child = spawn(shellPath, ['-c', SUPERVISOR_SCRIPT, '--', paths.cmdSh, paths.jobLog, paths.jobExit, paths.jobRun, paths.jobDone, paths.jobBg, paths.jobId, nodeId, shellPath, String(readBashNiceness(contextDir)), process.execPath], {
                     cwd: execution.cwd,
                     detached: true,
                     stdio: 'ignore',
@@ -345,11 +332,22 @@ export function createValveOperations(nodeId, contextDir, takePurpose = () => nu
                     cleanupJobDir(paths.dir);
                 });
                 pgid = child.pid;
-                // The detached supervisor IS the group leader, so its pid is the pgid.
-                // Persisting it is what lets a human stop the job from the Inspector
-                // later; the agent's own handoff notice quotes the same number.
+                // The detached supervisor starts this process tree. Its launch-time
+                // identity lets cancellation reject a stale PID that now belongs to an
+                // unrelated process; it is not a containment guarantee.
                 if (pgid !== undefined) {
+                    pgidIdentity = capturePidIdentities([pgid])?.get(pgid);
+                    if (pgidIdentity === undefined) {
+                        try {
+                            process.kill(-pgid, 'SIGKILL');
+                        }
+                        catch { /* the just-started supervisor already exited */ }
+                        finish(() => reject(new Error(`bash job ${paths.jobId} started without a process identity`)));
+                        cleanupJobDir(paths.dir);
+                        return;
+                    }
                     writeFileSync(paths.jobPgid, String(pgid));
+                    writeFileSync(paths.jobPgidIdentity, pgidIdentity);
                     liveForegroundJobs.add(paths);
                 }
                 child.unref();
@@ -370,8 +368,8 @@ export function createValveOperations(nodeId, contextDir, takePurpose = () => nu
                     const elapsedMs = performance.now() - startedAt;
                     if (timeout !== undefined && timeout > 0) {
                         if (elapsedMs >= timeout * 1000) {
-                            if (pgid)
-                                killGroup(pgid);
+                            if (pgid !== undefined && pgidIdentity !== undefined)
+                                void cancelBashJobProcessTree(pgid, pgidIdentity);
                             finish(() => reject(new Error(`timeout:${timeout}`)));
                             cleanupJobDir(paths.dir);
                         }

package/dist/pi-extensions/canvas-inbox-watcher.js

@@ -344,8 +344,6 @@ class CanvasInboxWatcher {
      *  reports would render as bare refs instead of inlined bodies. One refresh
      *  per unknown node id keeps a genuinely missing node from stalling delivery. */
     refreshForUnknownReportRefs() {
-        if (this.reportNodesRefreshing)
-            return true;
         const unknown = [];
         for (const entry of this.buffer) {
             const refNodeId = reportRefNodeId(entry.ref);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.302",
+  "version": "0.3.304",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.302",
+  "version": "0.3.304",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.302",
+      "version": "0.3.304",
       "hasInstallScript": true,
       "license": "MIT",
       "workspaces": [
@@ -5206,17 +5206,17 @@
     },
     "packages/crouter-api": {
       "name": "@north-light/crouter-api",
-      "version": "0.3.302",
+      "version": "0.3.304",
       "license": "UNLICENSED"
     },
     "packages/crouter-env-docker": {
       "name": "@north-light/crouter-env-docker",
-      "version": "0.3.302",
+      "version": "0.3.304",
       "license": "UNLICENSED"
     },
     "packages/crouter-sdk": {
       "name": "@north-light/crouter-sdk",
-      "version": "0.3.302",
+      "version": "0.3.304",
       "license": "UNLICENSED",
       "dependencies": {
         "@north-light/crouter-api": "^0.3.295"