@atolis-hq/wake 0.3.62 → 0.3.64

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 = "gfe73f33";

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/dist/src/integrations/github/infrastructure/bounded-fetch.js

@@ -0,0 +1,75 @@
+const defaultMaximumGitHubResponseBytes = 8 * 1024 * 1024;
+export class GitHubResponseTooLargeError extends Error {
+    maximumBytes;
+    observedBytes;
+    constructor(maximumBytes, observedBytes) {
+        super(`GitHub response exceeded ${maximumBytes} bytes (observed ${observedBytes})`);
+        this.maximumBytes = maximumBytes;
+        this.observedBytes = observedBytes;
+        this.name = 'GitHubResponseTooLargeError';
+    }
+}
+export function createBoundedGitHubFetch(baseFetch = globalThis.fetch, maximumResponseBytes = defaultMaximumGitHubResponseBytes) {
+    return async (input, init) => {
+        const response = await baseFetch(input, init);
+        const declaredBytes = contentLength(response);
+        if (declaredBytes !== undefined && declaredBytes > maximumResponseBytes) {
+            await response.body?.cancel();
+            throw new GitHubResponseTooLargeError(maximumResponseBytes, declaredBytes);
+        }
+        return new Proxy(response, {
+            get(target, property) {
+                if (property === 'text')
+                    return async () => decode(await readBoundedBody(target, maximumResponseBytes));
+                if (property === 'arrayBuffer')
+                    return async () => (await readBoundedBody(target, maximumResponseBytes)).buffer;
+                if (property === 'json')
+                    return async () => JSON.parse(decode(await readBoundedBody(target, maximumResponseBytes)));
+                const value = Reflect.get(target, property, target);
+                return typeof value === 'function' ? value.bind(target) : value;
+            },
+        });
+    };
+}
+function contentLength(response) {
+    const value = response.headers.get('content-length');
+    if (value === null)
+        return undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}
+async function readBoundedBody(response, maximumBytes) {
+    if (response.body === null)
+        return new Uint8Array();
+    const reader = response.body.getReader();
+    const chunks = [];
+    let observedBytes = 0;
+    try {
+        while (true) {
+            const chunk = await reader.read();
+            if (chunk.done)
+                return concatChunks(chunks, observedBytes);
+            observedBytes += chunk.value.byteLength;
+            if (observedBytes > maximumBytes) {
+                await reader.cancel();
+                throw new GitHubResponseTooLargeError(maximumBytes, observedBytes);
+            }
+            chunks.push(chunk.value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function decode(bytes) {
+    return new TextDecoder().decode(bytes);
+}
+function concatChunks(chunks, length) {
+    const body = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        body.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return body;
+}

package/dist/src/integrations/github/infrastructure/client.js

@@ -1,6 +1,7 @@
 import { Octokit } from '@octokit/rest';
 import { MergeMethod, ProviderPermission, PullRequestState } from '../../../activities/index.js';
 import { GitHubOutboundAction } from '../contracts/vocabulary.js';
+import { createBoundedGitHubFetch } from './bounded-fetch.js';
 import { branch, getCombinedStatusForRef, getIssueLabels, getPullRequest, listCheckRunsForRef, listIssueComments, listIssues, listPullRequestFiles, listPullRequests, listReviewComments, listReviews, } from './client-reads.js';
 import { createEtagCache } from './etag-cache.js';
 // Octokit's request-log plugin reports every non-2xx response through this
@@ -29,6 +30,7 @@ function logGitHubRequestFailure(message) {
 export function createGitHubClient(token) {
     const octokit = new Octokit({
         auth: token,
+        request: { fetch: createBoundedGitHubFetch() },
         log: { debug() { }, info() { }, warn() { }, error: logGitHubRequestFailure },
     });
     const cache = createEtagCache();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.3.62",
+  "version": "0.3.64",
   "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",