@atolis-hq/wake 0.3.62 → 0.3.63

package/dist/src/bootstrap/version.js

@@ -108,4 +108,4 @@ export function resolveWakeVersion(options = {}) {
         return `g${headHash.slice(0, 7)}`;
     return '0.1.0-dev';
 }
-export const wakeVersion = "g8095980";
+export const wakeVersion = "gb19302c";

package/dist/src/execution/infrastructure/process-execution.js

@@ -1,34 +1,82 @@
-import { execa } from 'execa';
-// Agent CLIs can emit arbitrarily large machine-readable transcripts. Wake
-// retains their complete result only after the process exits, so cap capture
-// below the resident's heap limit and surface the existing output-limit failure.
+import { spawn } from 'node:child_process';
+// Agent CLIs can emit arbitrarily large machine-readable transcripts. Capture
+// raw bytes ourselves so overflow never enters a third-party string buffer.
 const maximumCapturedProcessOutputBytes = 1024 * 1024;
 export function runProcess(command, args, cwd, signal, timeoutMs) {
-    const child = execa(command, args, {
+    const child = spawn(command, args, {
         ...(cwd === undefined ? {} : { cwd }),
         shell: false,
-        stdin: 'ignore',
-        stdout: 'pipe',
-        stderr: 'pipe',
-        maxBuffer: maximumCapturedProcessOutputBytes,
-        cancelSignal: signal,
-        ...(timeoutMs === undefined ? {} : { timeout: timeoutMs }),
-        reject: false,
-        stripFinalNewline: false,
+        stdio: ['ignore', 'pipe', 'pipe'],
     });
+    const result = captureProcessOutput(child, signal, timeoutMs);
     return {
-        result: child.then((result) => ({
-            stdout: result.stdout,
-            stderr: result.stderr,
-            exitCode: result.exitCode,
-            timedOut: result.timedOut,
-            ...(result.isMaxBuffer
-                ? {
-                    failureKind: 'output-limit',
-                    ...(result.shortMessage === undefined ? {} : { failureMessage: result.shortMessage }),
-                }
-                : {}),
-        })),
-        cancel: async () => void child.kill(),
+        result,
+        cancel: async () => {
+            terminate(child);
+        },
     };
 }
+function captureProcessOutput(child, signal, timeoutMs) {
+    return new Promise((resolve) => {
+        const stdout = [];
+        const stderr = [];
+        let capturedBytes = 0;
+        let timedOut = false;
+        let overflowed = false;
+        let error;
+        const terminateForOverflow = () => {
+            overflowed = true;
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+            terminate(child);
+        };
+        const capture = (destination) => (chunk) => {
+            if (overflowed)
+                return;
+            const remaining = maximumCapturedProcessOutputBytes - capturedBytes;
+            if (remaining <= 0 || chunk.length > remaining) {
+                if (remaining > 0)
+                    destination.push(chunk.subarray(0, remaining));
+                capturedBytes = maximumCapturedProcessOutputBytes;
+                terminateForOverflow();
+                return;
+            }
+            destination.push(chunk);
+            capturedBytes += chunk.length;
+        };
+        child.stdout?.on('data', capture(stdout));
+        child.stderr?.on('data', capture(stderr));
+        const timeout = timeoutMs === undefined
+            ? undefined
+            : setTimeout(() => {
+                timedOut = true;
+                terminate(child);
+            }, timeoutMs);
+        const onAbort = () => terminate(child);
+        signal.addEventListener('abort', onAbort, { once: true });
+        child.once('error', (caught) => {
+            error = caught;
+        });
+        child.once('close', (exitCode) => {
+            if (timeout !== undefined)
+                clearTimeout(timeout);
+            signal.removeEventListener('abort', onAbort);
+            resolve({
+                stdout: Buffer.concat(stdout).toString('utf8'),
+                stderr: error?.message ?? Buffer.concat(stderr).toString('utf8'),
+                exitCode: exitCode ?? undefined,
+                timedOut,
+                ...(overflowed
+                    ? {
+                        failureKind: 'output-limit',
+                        failureMessage: `Process output exceeded ${maximumCapturedProcessOutputBytes} bytes`,
+                    }
+                    : {}),
+            });
+        });
+    });
+}
+function terminate(child) {
+    if (!child.killed && child.exitCode === null)
+        child.kill();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.3.62",
+  "version": "0.3.63",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {
@@ -73,7 +73,6 @@
   "dependencies": {
     "@octokit/rest": "^22.0.0",
     "cron-parser": "^5.10.0",
-    "execa": "^10.0.1",
     "handlebars": "^4.7.9",
     "ulid": "^3.0.2",
     "yaml": "^2.9.0",