@atolis-hq/wake 0.3.63 → 0.3.65

package/dist/src/bootstrap/composition-root.js

@@ -1,6 +1,6 @@
 import { createPullRequestService } from '../activities/index.js';
 import { ControlStreamKind, DispatchPolicy, createAdvanceOnce, createControlPlaneService, createRunnerControlService, ineligibleRunners, } from '../control-plane/index.js';
-import { ExecutionCancellationReason, ExternalExecutionState, GitWorkspaceProvider, RecoveryService, TranscriptStore, createExecutionService, } from '../execution/index.js';
+import { ExecutionCancellationReason, ExternalExecutionState, GitWorkspaceProvider, RecoveryService, TranscriptStore, createExecutionService, createRunnerMemoryProfileDecorator, } from '../execution/index.js';
 import { createGitHubAgentContextReader, gitHubProviderDefinition, resolveGitHubResourceUrl, } from '../integrations/github/index.js';
 import { SystemClock, UlidIdGenerator, } from '../kernel/index.js';
 import { compileWorkflow, createOrchestrationService } from '../orchestration/index.js';
@@ -59,10 +59,22 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
     const transcriptStore = config.transcripts.enabled
         ? (options.transcriptStore ?? new TranscriptStore(paths.transcriptsRoot))
         : undefined;
+    const profileDecorator = process.env.WAKE_MEMORY_PROFILE === 'runner'
+        ? createRunnerMemoryProfileDecorator({
+            write: (line) => process.stderr.write(line),
+            now: () => clock.now().toISOString(),
+            memoryUsage: () => process.memoryUsage(),
+        })
+        : undefined;
+    const decorateRunner = profileDecorator === undefined
+        ? options.decorateRunner
+        : options.decorateRunner === undefined
+            ? profileDecorator
+            : (runner, name) => profileDecorator(options.decorateRunner(runner, name), name);
     const execution = createExecutionService(journal, activities, config.execution, {
         clock,
         ids,
-        runners: createRunnerRegistry(config.execution, fakeScenarios, options.decorateRunner),
+        runners: createRunnerRegistry(config.execution, fakeScenarios, decorateRunner),
         reportRunnerQuota: createRunnerQuotaReporter(journal, clock, ids),
         ...(transcriptStore !== undefined
             ? {

package/dist/src/bootstrap/surface-cli-applications.js

@@ -179,6 +179,7 @@ function sandboxDockerOptions(root, overrides) {
         containerHomeMountPath: root.config.host.sandbox.containerHomeMountPath,
         extraMounts: root.config.host.sandbox.extraMounts,
         startEnabled: root.config.host.sandbox.start.enabled,
+        ...(process.env.WAKE_MEMORY_PROFILE === 'runner' ? { memoryProfile: 'runner' } : {}),
         inspect: createDockerInspection(root.paths.wakeRoot),
         resolveBuildVersion: () => resolveSandboxBuildVersion(root),
     };

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 = "gb19302c";
+export const wakeVersion = "gcf37d8a";

package/dist/src/execution/index.js

@@ -26,6 +26,7 @@ export * from './infrastructure/runners/cursor.js';
 export * from './infrastructure/runners/fake.js';
 export * from './infrastructure/runners/fake-scenarios.js';
 export * from './infrastructure/runners/registry.js';
+export * from './infrastructure/runner-memory-profile.js';
 export * from './infrastructure/transcripts.js';
 export * from './infrastructure/transcript-store.js';
 export * from './infrastructure/workspace/fake-workspace.js';

package/dist/src/execution/infrastructure/runner-memory-profile.js

@@ -0,0 +1,34 @@
+export function createRunnerMemoryProfileDecorator(options) {
+    return (runner, name) => ({
+        ...(runner.supportsSessionResume === undefined
+            ? {}
+            : { supportsSessionResume: runner.supportsSessionResume }),
+        start: async (request, signal) => {
+            writeSample(options, 'runner.start.before', name, request.runId);
+            const execution = await runner.start(request, signal);
+            writeSample(options, 'runner.start.returned', name, request.runId);
+            return {
+                ...execution,
+                result: execution.result.finally(() => {
+                    writeSample(options, 'runner.result.settled', name, request.runId);
+                }),
+            };
+        },
+    });
+}
+function writeSample(options, phase, runner, runId) {
+    const memory = options.memoryUsage();
+    options.write(`${JSON.stringify({
+        type: 'wake.runner-memory',
+        phase,
+        at: options.now(),
+        pid: process.pid,
+        runner,
+        runId,
+        rss: memory.rss,
+        heapTotal: memory.heapTotal,
+        heapUsed: memory.heapUsed,
+        external: memory.external,
+        arrayBuffers: memory.arrayBuffers,
+    })}\n`);
+}

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/dist/src/surfaces/cli/infrastructure/docker-cli.js

@@ -197,6 +197,9 @@ async function createContainer(docker, options) {
                 `WAKE_HOME_INIT_DIRS=${homeInitDirectories.join('\n')}`,
             ]),
         ...(options.startEnabled === true ? ['-e', 'WAKE_START_ENABLED=true'] : []),
+        ...(options.memoryProfile === undefined
+            ? []
+            : ['-e', `WAKE_MEMORY_PROFILE=${options.memoryProfile}`]),
         options.image,
     ]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.3.63",
+  "version": "0.3.65",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {