@atolis-hq/wake 0.3.88 → 0.3.89

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

@@ -55,7 +55,7 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
                 throw new Error('Workspace resource ' + id + ' does not identify a GitHub repository');
             return 'https://github.com/' + match[1] + '.git';
         },
-    });
+    }, undefined, undefined, config.execution.workspaceHooks?.prepare);
     const transcriptStore = config.transcripts.enabled
         ? (options.transcriptStore ?? new TranscriptStore(paths.transcriptsRoot))
         : undefined;

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 = "gead96c0";
+export const wakeVersion = "gbc199da";

package/dist/src/execution/contracts/config.js

@@ -31,5 +31,17 @@ export const executionConfigSchema = z
     leaseDurationMs: z.number().int().positive().optional(),
     leaseRenewalIntervalMs: z.number().int().positive().optional(),
     maxAmbiguityReconciliationAttempts: z.number().int().positive().optional(),
+    workspaceHooks: z
+        .object({
+        prepare: z
+            .object({
+            command: z.string().trim().min(1),
+            timeoutMs: z.number().int().positive().default(300_000),
+        })
+            .strict()
+            .optional(),
+    })
+        .strict()
+        .optional(),
 })
     .strict();

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

@@ -2,24 +2,26 @@ 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) {
+export function runProcess(command, args, cwd, signal, timeoutMs, shell = false) {
     const child = spawn(command, args, {
         ...(cwd === undefined ? {} : { cwd }),
-        shell: false,
+        shell,
+        ...(shell && process.platform !== 'win32' ? { detached: true } : {}),
         stdio: ['ignore', 'pipe', 'pipe'],
     });
-    const result = captureProcessOutput(child, signal, timeoutMs);
+    const result = captureProcessOutput(child, signal, timeoutMs, shell);
     return {
         result,
         cancel: async () => {
-            terminate(child);
+            terminate(child, shell);
         },
     };
 }
-function captureProcessOutput(child, signal, timeoutMs) {
+function captureProcessOutput(child, signal, timeoutMs, shell) {
     return new Promise((resolve) => {
         const stdout = [];
         const stderr = [];
+        const combinedOutput = [];
         let capturedBytes = 0;
         let timedOut = false;
         let overflowed = false;
@@ -28,20 +30,24 @@ function captureProcessOutput(child, signal, timeoutMs) {
             overflowed = true;
             child.stdout?.destroy();
             child.stderr?.destroy();
-            terminate(child);
+            terminate(child, shell);
         };
         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));
+                if (remaining > 0) {
+                    const captured = chunk.subarray(0, remaining);
+                    destination.push(captured);
+                    combinedOutput.push(captured);
+                }
                 capturedBytes = maximumCapturedProcessOutputBytes;
                 terminateForOverflow();
                 return;
             }
             destination.push(chunk);
+            combinedOutput.push(chunk);
             capturedBytes += chunk.length;
         };
         child.stdout?.on('data', capture(stdout));
@@ -50,9 +56,9 @@ function captureProcessOutput(child, signal, timeoutMs) {
             ? undefined
             : setTimeout(() => {
                 timedOut = true;
-                terminate(child);
+                terminate(child, shell);
             }, timeoutMs);
-        const onAbort = () => terminate(child);
+        const onAbort = () => terminate(child, shell);
         signal.addEventListener('abort', onAbort, { once: true });
         child.once('error', (caught) => {
             error = caught;
@@ -64,6 +70,7 @@ function captureProcessOutput(child, signal, timeoutMs) {
             resolve({
                 stdout: Buffer.concat(stdout).toString('utf8'),
                 stderr: error?.message ?? Buffer.concat(stderr).toString('utf8'),
+                combinedOutput: Buffer.concat(combinedOutput),
                 exitCode: exitCode ?? undefined,
                 timedOut,
                 ...(overflowed
@@ -76,7 +83,16 @@ function captureProcessOutput(child, signal, timeoutMs) {
         });
     });
 }
-function terminate(child) {
+function terminate(child, shell = false) {
+    if (shell && process.platform !== 'win32' && child.pid !== undefined) {
+        try {
+            process.kill(-child.pid);
+            return;
+        }
+        catch {
+            // The process may have already exited; fall through to the direct signal.
+        }
+    }
     if (!child.killed && child.exitCode === null)
         child.kill();
 }

package/dist/src/execution/infrastructure/workspace/fake-workspace.js

@@ -1,13 +1,25 @@
 export class FakeWorkspaceProvider {
     path;
     branch;
+    prepareHook;
+    prepareOutcome;
     requests = [];
-    constructor(path = '/fake/workspace', branch = 'wake/fake-work') {
+    prepareInvocations = [];
+    constructor(path = '/fake/workspace', branch = 'wake/fake-work', prepareHook, prepareOutcome = { kind: 'success' }) {
         this.path = path;
         this.branch = branch;
+        this.prepareHook = prepareHook;
+        this.prepareOutcome = prepareOutcome;
     }
     async acquire(request) {
         this.requests.push(request);
+        if (this.prepareHook !== undefined) {
+            this.prepareInvocations.push({ command: this.prepareHook.command, cwd: this.path });
+            if (this.prepareOutcome.kind === 'timed-out')
+                throw new Error(`Fake workspace prepare hook (${this.prepareHook.command}) timed out`);
+            if (this.prepareOutcome.kind === 'exit' && this.prepareOutcome.exitCode !== 0)
+                throw new Error(`Fake workspace prepare hook (${this.prepareHook.command}) exited with code ${this.prepareOutcome.exitCode}`);
+        }
         return {
             workspaceId: `workspace-${this.requests.length}`,
             path: this.path,

package/dist/src/execution/infrastructure/workspace/git-workspace.js

@@ -3,11 +3,13 @@ import { access, mkdir, readdir, readFile, realpath, rm, writeFile } from 'node:
 import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { promisify } from 'node:util';
 import { RunStatus, WorkspaceMode } from '../../contracts/vocabulary.js';
+import { prepareWorkspace } from './prepare-workspace.js';
 const exec = promisify(execFile);
 export class GitWorkspaceProvider {
     root;
     resolver;
     git;
+    prepareHook;
     markerRoot;
     recoveryFileSystem;
     constructor(root, resolver, git = async (arguments_) => {
@@ -15,10 +17,11 @@ export class GitWorkspaceProvider {
     }, recoveryFileSystem = {
         remove: async (path) => rm(path, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 }),
         canonicalize: realpath,
-    }) {
+    }, prepareHook) {
         this.root = root;
         this.resolver = resolver;
         this.git = git;
+        this.prepareHook = prepareHook;
         this.markerRoot = join(this.root, '.wake-workspace-ownership');
         this.recoveryFileSystem = recoveryFileSystem;
     }
@@ -44,6 +47,8 @@ export class GitWorkspaceProvider {
         const branch = request.mode === WorkspaceMode.Branch ? request.workItemId : undefined;
         if (branch !== undefined)
             await this.git(['-C', path, 'switch', ...(existingWorkspace ? [] : ['--create']), branch]);
+        if (this.prepareHook !== undefined)
+            await prepareWorkspace(path, this.prepareHook);
         return {
             workspaceId: name,
             path,

package/dist/src/execution/infrastructure/workspace/prepare-workspace.js

@@ -0,0 +1,16 @@
+import { runProcess } from '../process-execution.js';
+const prepareOutputTailBytes = 4096;
+export async function prepareWorkspace(path, hook) {
+    const process = runProcess(hook.command, [], path, new AbortController().signal, hook.timeoutMs, true);
+    const result = await process.result;
+    if (result.exitCode === 0 && !result.timedOut && result.failureKind === undefined)
+        return;
+    throw new Error(prepareFailureMessage(hook.command, result));
+}
+function prepareFailureMessage(command, result) {
+    const reason = result.timedOut
+        ? 'timed out'
+        : (result.failureMessage ?? `exited with code ${result.exitCode ?? 'unavailable'}`);
+    const output = result.combinedOutput.subarray(-prepareOutputTailBytes).toString('utf8');
+    return `Workspace prepare hook (${command}) ${reason}. Combined output tail (last ${prepareOutputTailBytes} bytes):\n${output}`;
+}

package/package.json

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