@atolis-hq/wake 0.3.32 → 0.3.34

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

@@ -9,7 +9,7 @@ import { IntakeHost, ResidentHost, TickHost } from '../control-plane/index.js';
 import { ExecutionCancellationReason, RunStatus, loadPromptTemplate } from '../execution/index.js';
 import { EventActorKind, correlationId } from '../kernel/index.js';
 import { ResourceCorrelationRole, resourceId } from '../resources/index.js';
-import { createApiDispatcher, createApiHttpServer, createLoggedDockerCli, createPackagedAssetSource, createProcessLogSink, createSandboxDockerPort, drainProcessOutput, runDoctor, runSandbox, runSandboxEntrypoint, runSandboxSetup, runSelfUpdateLatestLoop, runTargetSmoke, verifyResidentStart, waitForActiveRuns, } from '../surfaces/index.js';
+import { DockerProcessError, createApiDispatcher, createApiHttpServer, createLoggedDockerCli, createPackagedAssetSource, createProcessLogSink, createSandboxDockerPort, drainProcessOutput, runDoctor, runSandbox, runSandboxEntrypoint, runSandboxSetup, runSelfUpdateLatestLoop, runTargetSmoke, verifyResidentStart, waitForActiveRuns, } from '../surfaces/index.js';
 import { WorkStreamKind, workItemId } from '../work/index.js';
 import { loadConfig } from './config/load-config.js';
 import { runtimeProjectionDefinitions } from './projection-runtime.js';
@@ -244,7 +244,9 @@ function createSandboxRuntimeApplications(root) {
                 return false;
             }
         },
-        exec: (arguments_) => docker.exec([...wakeInvocation, ...arguments_]),
+        async exec(arguments_) {
+            await docker.exec([...wakeInvocation, ...arguments_]);
+        },
     };
 }
 /**
@@ -371,32 +373,35 @@ function spawnDocker(arguments_, onChunk, cwd, options) {
             child.on('error', reject);
             child.on('close', (code) => {
                 if (code === 0)
-                    resolve();
+                    resolve({ stdout: '', stderr: '' });
                 else
-                    reject(new Error('docker ' + arguments_.join(' ') + ' exited with code ' + String(code)));
+                    reject(new DockerProcessError('docker ' + arguments_.join(' ') + ' exited with code ' + String(code), { stdout: '', stderr: '' }));
             });
             return;
         }
         let chain = Promise.resolve();
-        let stderrTail = '';
+        let stdout = '';
+        let stderr = '';
         const enqueue = (stream, text) => {
-            if (stream === 'stderr')
-                stderrTail = `${stderrTail}${text}`.slice(-4000);
+            if (stream === 'stdout')
+                stdout += text;
+            else
+                stderr += text;
             chain = chain.then(() => onChunk({ stream, text }));
         };
         child.stdout.on('data', (buffer) => enqueue('stdout', buffer.toString('utf8')));
         child.stderr.on('data', (buffer) => enqueue('stderr', buffer.toString('utf8')));
         child.on('error', (error) => {
-            void chain.then(() => reject(error));
+            void chain.then(() => reject(new DockerProcessError(error.message, { stdout, stderr }, error)));
         });
         child.on('close', (code) => {
             void chain.then(() => {
                 if (code === 0)
-                    resolve();
+                    resolve({ stdout, stderr });
                 else {
-                    const detail = stderrTail.trim();
-                    reject(new Error(`docker ${arguments_.join(' ')} exited with code ${String(code)}` +
-                        (detail.length > 0 ? `: ${detail}` : '')));
+                    const detail = stderr.trim();
+                    reject(new DockerProcessError(`docker ${arguments_.join(' ')} exited with code ${String(code)}` +
+                        (detail.length > 0 ? `: ${detail}` : ''), { stdout, stderr }));
                 }
             });
         });

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 = "g629cc1e";
+export const wakeVersion = "g01f75bf";

package/dist/src/integrations/delivery/application/delivery-outcome-reactor.js

@@ -16,48 +16,42 @@ export class DeliveryOutcomeReactor {
     async runOnce() {
         const consumer = 'reactor:delivery-outcomes';
         const events = await this.journal.readAll(await this.checkpoints.load(consumer));
+        const resolvedDeliveryEventIds = new Set();
         for (const event of events) {
-            const delivery = selectDeliveryEvent(event);
-            if (delivery !== null) {
-                const command = {
-                    workflowInstanceId: workflowInstanceId(delivery.payload.workflowInstanceId),
-                    activationId: activationId(delivery.payload.activationId),
-                };
-                if (await this.isAwaitingThisDelivery(command, delivery.payload.intentEventId)) {
-                    if (delivery.eventType === DeliveryEventType.Confirmed ||
-                        (delivery.eventType === DeliveryEventType.Reconciled &&
-                            delivery.payload.result === DeliveryResultKind.Confirmed))
-                        await this.orchestration.acceptOutcome({
-                            ...command,
-                            outcome: {
-                                kind: ActivityOutcomeKind.Done,
-                                data: { deliveryEventId: delivery.eventId },
-                            },
-                        }, {
-                            commandId: delivery.eventId,
-                            correlationId: event.correlationId,
-                            actor: { kind: EventActorKind.System, id: 'delivery-outcome-reactor' },
-                            occurredAt: event.recordedAt,
-                        });
-                    if (delivery.eventType === DeliveryEventType.Failed)
-                        await this.orchestration.acceptOutcome({
-                            ...command,
-                            outcome: {
-                                kind: ActivityOutcomeKind.Failed,
-                                data: { reason: delivery.payload.code },
-                            },
-                        }, {
-                            commandId: delivery.eventId,
-                            correlationId: event.correlationId,
-                            actor: { kind: EventActorKind.System, id: 'delivery-outcome-reactor' },
-                            occurredAt: event.recordedAt,
-                        });
-                }
-            }
+            await this.reconcile(event, resolvedDeliveryEventIds);
             await this.checkpoints.save(consumer, event.globalPosition);
         }
+        for (const event of await this.journal.readAll(0))
+            await this.reconcile(event, resolvedDeliveryEventIds);
         return events.length;
     }
+    async reconcile(event, seen) {
+        const delivery = selectDeliveryEvent(event);
+        if (delivery === null || seen.has(delivery.eventId))
+            return;
+        const outcome = delivery.eventType === DeliveryEventType.Confirmed ||
+            (delivery.eventType === DeliveryEventType.Reconciled &&
+                delivery.payload.result === DeliveryResultKind.Confirmed)
+            ? { kind: ActivityOutcomeKind.Done, data: { deliveryEventId: delivery.eventId } }
+            : delivery.eventType === DeliveryEventType.Failed
+                ? { kind: ActivityOutcomeKind.Failed, data: { reason: delivery.payload.code } }
+                : null;
+        if (outcome === null)
+            return;
+        const command = {
+            workflowInstanceId: workflowInstanceId(delivery.payload.workflowInstanceId),
+            activationId: activationId(delivery.payload.activationId),
+        };
+        if (!(await this.isAwaitingThisDelivery(command, delivery.payload.intentEventId)))
+            return;
+        seen.add(delivery.eventId);
+        await this.orchestration.acceptOutcome({ ...command, outcome }, {
+            commandId: delivery.eventId,
+            correlationId: event.correlationId,
+            actor: { kind: EventActorKind.System, id: 'delivery-outcome-reactor' },
+            occurredAt: event.recordedAt,
+        });
+    }
     /**
      * A delivery's own completion may only resolve the activation that
      * actually asked to wait on it (an activity outcome of `waiting` with

package/dist/src/surfaces/cli/infrastructure/docker-cli.js

@@ -1,20 +1,50 @@
 import { dirname, normalize } from 'node:path/posix';
+import { DockerProcessError, } from './docker-invocation.js';
 import { scrubProcessLog } from './process-log.js';
+export { DockerProcessError, } from './docker-invocation.js';
+export { verifyResidentStart } from './resident-start.js';
+const emptyDockerInvocationResult = { stdout: '', stderr: '' };
 export function createDockerCli(invoke) {
-    return { invoke };
+    return {
+        async invoke(arguments_, options) {
+            return (await invoke(arguments_, options)) ?? emptyDockerInvocationResult;
+        },
+    };
 }
 /** Streams Docker output through the target-owned scrubbed log boundary as it arrives. */
 export function createLoggedDockerCli(process, log) {
     return {
         async invoke(arguments_, options) {
-            await process.execute(arguments_, (chunk) => {
-                if (chunk.text.length === 0)
+            let stdout = '';
+            let stderr = '';
+            const onChunk = (chunk) => {
+                if (chunk.stream === 'stdout')
+                    stdout += chunk.text;
+                else
+                    stderr += chunk.text;
+                if (options?.suppressOutput || chunk.text.length === 0)
                     return;
                 return log.write(scrubProcessLog(chunk.text));
-            }, options);
+            };
+            try {
+                const result = await process.execute(arguments_, onChunk, options);
+                return mergeDockerOutput(result, { stdout, stderr });
+            }
+            catch (error) {
+                const result = mergeDockerOutput(error instanceof DockerProcessError ? error.result : undefined, { stdout, stderr });
+                throw new DockerProcessError(error instanceof Error ? error.message : String(error), result, error);
+            }
         },
     };
 }
+function mergeDockerOutput(result, captured) {
+    if (result === undefined)
+        return captured;
+    return {
+        stdout: result.stdout.length === 0 ? captured.stdout : result.stdout,
+        stderr: result.stderr.length === 0 ? captured.stderr : result.stderr,
+    };
+}
 /** Bounded target sandbox lifecycle; domain modules never name Docker. */
 const dockerRunCommand = String.fromCharCode(114, 117, 110);
 // The bounded lifecycle is intentionally co-located for command parity.
@@ -108,34 +138,6 @@ export function createSandboxDockerPort(docker, options) {
         },
     };
 }
-/**
- * Polls until the resident `wake start` process is alive inside the
- * container (pid file + live pid + expected cmdline), retrying on any
- * failure — `docker.invoke` already throws on a non-zero exit, so each
- * attempt is just resolve-or-throw. Used after a self-update container swap
- * to confirm the new image actually came up before trusting it.
- */
-export async function verifyResidentStart(docker, containerName, expectedCmdlineFragment, options) {
-    const attempts = options?.attempts ?? 15;
-    const intervalMs = options?.intervalMs ?? 1000;
-    const check = [
-        'pid="$(cat /wake/.wake/logs/start.pid)"',
-        'test -n "$pid"',
-        'kill -0 "$pid"',
-        `tr '\\0' ' ' < "/proc/$pid/cmdline" | grep -F ${shellQuote(expectedCmdlineFragment)} >/dev/null`,
-    ].join(' && ');
-    for (let attempt = 1; attempt <= attempts; attempt += 1) {
-        try {
-            await docker.invoke(['exec', '-i', containerName, 'sh', '-lc', check]);
-            return;
-        }
-        catch (error) {
-            if (attempt === attempts)
-                throw error;
-            await new Promise((resolve) => setTimeout(resolve, intervalMs));
-        }
-    }
-}
 function shellQuote(value) {
     return `'${value.replaceAll("'", `'\\''`)}'`;
 }

package/dist/src/surfaces/cli/infrastructure/docker-invocation.js

@@ -0,0 +1,9 @@
+/** A failed Docker invocation whose streamed output remains available for a concise caller diagnostic. */
+export class DockerProcessError extends Error {
+    result;
+    constructor(message, result, cause) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.result = result;
+        this.name = 'DockerProcessError';
+    }
+}

package/dist/src/surfaces/cli/infrastructure/resident-start.js

@@ -0,0 +1,42 @@
+import { DockerProcessError, } from './docker-invocation.js';
+/** Verifies the replacement sandbox has started its resident Wake process. */
+export async function verifyResidentStart(docker, containerName, expectedCmdlineFragment, options) {
+    const attempts = options?.attempts ?? 15;
+    const intervalMs = options?.intervalMs ?? 1000;
+    const check = [
+        'pid="$(cat /wake/.wake/logs/start.pid)"',
+        'test -n "$pid"',
+        'kill -0 "$pid"',
+        `tr '\\0' ' ' < "/proc/$pid/cmdline" | grep -F ${shellQuote(expectedCmdlineFragment)} >/dev/null`,
+    ].join(' && ');
+    for (let attempt = 1; attempt <= attempts; attempt += 1) {
+        try {
+            await docker.invoke(['exec', '-i', containerName, 'sh', '-lc', check], {
+                suppressOutput: attempt < attempts,
+            });
+            return;
+        }
+        catch (error) {
+            if (attempt === attempts)
+                throw residentStartFailure(attempts, error);
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+    }
+}
+function residentStartFailure(attempts, error) {
+    const detail = error instanceof DockerProcessError
+        ? [
+            error.message,
+            error.result.stdout.length === 0 ? '' : `stdout: ${error.result.stdout.trim()}`,
+            error.result.stderr.length === 0 ? '' : `stderr: ${error.result.stderr.trim()}`,
+        ]
+            .filter((value) => value.length > 0)
+            .join('; ')
+        : error instanceof Error
+            ? error.message
+            : String(error);
+    return new Error(`Wake resident start did not become healthy after ${String(attempts)} attempts: ${detail}`);
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}

package/package.json

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