@atolis-hq/wake 0.4.43 → 0.4.44

package/dist/src/bootstrap/self-update-application.d.ts

@@ -16,6 +16,7 @@ export interface SourceUpdatePort {
  * non-sandbox self-updates.
  */
 export interface SelfUpdateRolloutPort {
+    prepare(tag: string): Promise<void>;
     deploy(tag: string): Promise<void>;
     rollback(tag: string): Promise<void>;
     recordFailure(tag: string, error: unknown): Promise<void>;
@@ -27,6 +28,7 @@ export interface SelfUpdateRolloutPort {
  * durably record every supplied Run's maintenance request.
  */
 export interface SelfUpdateQuiescePort {
+    read?(): Promise<UpdateMaintenanceState | null>;
     acquire(tag: string, retryFailed?: boolean): Promise<UpdateMaintenanceState>;
     exclusive?<Value>(tag: string, retryFailed: boolean, operation: (state: UpdateMaintenanceState) => Promise<Value>): Promise<Value>;
     activeRuns(): Promise<readonly {

package/dist/src/bootstrap/self-update-application.js

@@ -59,6 +59,11 @@ async function currentTag(input) {
     return (await input.source.currentTag?.()) ?? (await input.ledger.read());
 }
 async function startUpdateAttempt(input, tag, force) {
+    const existing = await input.quiesce?.read?.();
+    if (existing === null ||
+        existing === undefined ||
+        existing.phase === UpdateMaintenancePhase.Failed)
+        await prepareCandidate(input, tag);
     if (input.quiesce?.exclusive !== undefined)
         return input.quiesce.exclusive(tag, force, (lease) => updateAttempt(input, tag, force, lease));
     return updateAttempt(input, tag, force, await input.quiesce?.acquire(tag, force));
@@ -66,24 +71,30 @@ async function startUpdateAttempt(input, tag, force) {
 async function updateAttempt(input, tag, force, lease) {
     const maintenanceTag = lease?.tag ?? tag;
     const attemptId = lease?.attemptId;
-    const context = {};
+    const context = {
+        activationStarted: false,
+        rollbackSucceeded: false,
+        recoveryRequired: false,
+        recoveryVerified: false,
+    };
     try {
         return await performUpdateAttempt(input, tag, force, lease, context);
     }
     catch (error) {
-        await recordUpdateFailure(input, maintenanceTag, attemptId, context.deployError ?? error, error);
+        await recordUpdateFailure(input, maintenanceTag, attemptId, context.deployError ?? error, error, context);
         throw error;
     }
 }
 async function performUpdateAttempt(input, tag, force, lease, context) {
     if (lease !== undefined && requiresMaintenanceRecovery(lease)) {
+        context.recoveryRequired = true;
         await resumePendingMaintenance(input, lease);
         return false;
     }
     if (!isStartableMaintenanceLease(lease, tag))
         return false;
     await quiesceForUpdate(input);
-    await recoverPendingUpdate(input.ledger, input.source);
+    await recoverPendingUpdate(input.ledger, input.source, context);
     if (!force && (await input.ledger.read()) === tag) {
         await input.quiesce?.clear(lease?.attemptId);
         return false;
@@ -116,13 +127,18 @@ async function runForwardUpdate(input, tag, attemptId, context) {
             readLedger: input.ledger.read,
             writeLedger: input.ledger.write,
             update: async (nextTag) => {
-                await input.source.checkout(nextTag);
+                if (input.rollout === undefined)
+                    await input.source.checkout(nextTag);
+                context.activationStarted = true;
                 context.deployError = await deployRollout(input.rollout, nextTag);
             },
             health: async () => context.deployError === undefined && input.source.healthy(),
             rollback: async (priorTag) => {
                 await rollbackUpdate(input, priorTag, attemptId);
+                if (!(await input.source.healthy()))
+                    throw new Error(`Self-update rollback could not verify the prior tag ${priorTag}`);
                 rollbackSucceeded = true;
+                context.rollbackSucceeded = true;
             },
         });
     }
@@ -162,7 +178,18 @@ async function rollbackUpdate(input, priorTag, attemptId) {
     await input.source.checkout(priorTag);
     await input.rollout?.rollback(priorTag);
 }
-async function recordUpdateFailure(input, tag, attemptId, rolloutError, originalError) {
+async function recordUpdateFailure(input, tag, attemptId, rolloutError, originalError, context) {
+    if (context.rollbackSucceeded ||
+        (!context.activationStarted && (!context.recoveryRequired || context.recoveryVerified))) {
+        try {
+            await recordRolloutFailure(input.rollout, tag, rolloutError);
+            await input.ledger.recordBad(tag);
+        }
+        finally {
+            await input.quiesce?.clear(attemptId);
+        }
+        return;
+    }
     try {
         await input.quiesce?.fail(originalError, attemptId);
     }
@@ -184,6 +211,24 @@ async function recordRolloutFailure(rollout, tag, error) {
         // Best-effort: a failure-log write must never mask the original update failure.
     }
 }
+async function prepareCandidate(input, tag) {
+    if (!(await input.source.isClean()))
+        throw new Error('Self-update requires a clean source checkout');
+    if (input.rollout === undefined)
+        return;
+    const priorTag = await input.ledger.read();
+    try {
+        await input.source.checkout(tag);
+        await input.rollout.prepare(tag);
+    }
+    catch (error) {
+        if (priorTag !== null)
+            await input.source.checkout(priorTag);
+        await recordRolloutFailure(input.rollout, tag, error);
+        await input.ledger.recordBad(tag);
+        throw new UpdateCandidateFailure(error);
+    }
+}
 /**
  * A restart must never repeat a forward deploy. The persisted phase tells us
  * that source/rollout work may already have begun, so recover the prior
@@ -210,11 +255,13 @@ async function quiesceActiveRuns(quiesce) {
 function formatError(error) {
     return error instanceof Error ? error.message : String(error);
 }
-async function recoverPendingUpdate(ledger, source) {
+async function recoverPendingUpdate(ledger, source, context) {
     const priorTag = await ledger.recover();
     if (priorTag === null)
         return;
+    context.recoveryRequired = true;
     await source.checkout(priorTag);
     if (!(await source.healthy()))
         throw new Error(`Self-update recovery could not verify the prior tag ${priorTag}`);
+    context.recoveryVerified = true;
 }

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

@@ -400,6 +400,7 @@ async function activeExecutionRunIds(root) {
 /** The production maintenance boundary shared by the CLI update application. */
 export function createSelfUpdateQuiescePort(root) {
     return {
+        read: () => root.maintenance.read(),
         acquire: (tag, retryFailed) => root.maintenance.acquire(tag, retryFailed),
         exclusive: (tag, retryFailed, operation) => root.maintenance.runExclusive(tag, retryFailed, operation),
         activeRuns: () => activeExecutionRuns(root),
@@ -433,18 +434,20 @@ function createSandboxRuntimeApplications(root) {
     };
 }
 /**
- * Builds a running self-update on the sandbox container onto a specific
- * image tag: rebuild the image, swap the container onto it, and confirm the
- * resident `wake start` process actually came back up. Reused for both the
- * forward deploy and a same-shaped rollback to a previously-built tag.
+ * Builds a candidate image before the maintenance window. A failed build
+ * cannot affect the running sandbox.
  */
-async function deploySandboxTag(root, docker, tag, image, overrides) {
+async function buildSandboxTag(root, docker, image, overrides) {
     const port = createSandboxDockerPort(docker, sandboxDockerOptions(root, { image, ...overrides }));
-    const wakeInvocation = overrides?.development?.mode === 'source'
+    await port.build();
+}
+/** Swaps the already-built candidate image and verifies the resident host. */
+async function deploySandboxTag(root, docker, tag, image, development) {
+    const port = createSandboxDockerPort(docker, sandboxDockerOptions(root, { image, development }));
+    const wakeInvocation = development?.mode === 'source'
         ? ['node', '/app/dist/src/main.js']
         : sandboxWakeInvocation(root);
     const healthcheckRoot = `/tmp/wake-self-update-healthcheck-${tag}`;
-    await port.build();
     try {
         await port.update();
     }
@@ -541,15 +544,14 @@ function createOperationalApplications(root) {
                 ledger: createUpdateLedger(root.paths.wakeRoot),
                 source: updatePort,
                 rollout: {
-                    async deploy(deployTag) {
-                        await waitForActiveRuns({
-                            activeRunIds: () => activeExecutionRunIds(root),
-                            sleep: async (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
-                        });
-                        await deploySandboxTag(root, dockerCli, deployTag, `${imageRepository}:${deployTag}`, {
+                    async prepare(prepareTag) {
+                        await buildSandboxTag(root, dockerCli, `${imageRepository}:${prepareTag}`, {
                             development: updateDevelopment,
-                            buildVersion: deployTag,
+                            buildVersion: prepareTag,
                         });
+                    },
+                    async deploy(deployTag) {
+                        await deploySandboxTag(root, dockerCli, deployTag, `${imageRepository}:${deployTag}`, updateDevelopment);
                         // A later deploy succeeding after a prior rollback clears the stale warning.
                         await failureLog.clear();
                     },

package/dist/src/bootstrap/version.js

@@ -124,6 +124,6 @@ export function resolveWakeVersion(options = {}) {
         return `g${headHash.slice(0, 7)}`;
     return '0.1.0-dev';
 }
-export const wakeVersion = "v0.4.43";
+export const wakeVersion = "v0.4.44";
 /** The registry-installable version used by packaged sandbox images. */
 export const wakePackageVersion = packageVersion(defaultRepoRoot) ?? wakeVersion;

package/package.json

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