@atolis-hq/wake 0.4.16 → 0.4.18

package/dist/src/bootstrap/config/root-schema.d.ts

@@ -140,6 +140,11 @@ declare const hostConfigSchema: z.ZodDefault<z.ZodObject<{
     selfUpdate: z.ZodDefault<z.ZodObject<{
         drainTimeoutMs: z.ZodDefault<z.ZodNumber>;
         cancellationTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        npm: z.ZodDefault<z.ZodObject<{
+            package: z.ZodDefault<z.ZodString>;
+            distTag: z.ZodDefault<z.ZodString>;
+            registry: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
 }, z.core.$strict>>;
 export declare const rootConfigSchema: z.ZodObject<{
@@ -436,6 +441,11 @@ export declare const rootConfigSchema: z.ZodObject<{
         selfUpdate: z.ZodDefault<z.ZodObject<{
             drainTimeoutMs: z.ZodDefault<z.ZodNumber>;
             cancellationTimeoutMs: z.ZodDefault<z.ZodNumber>;
+            npm: z.ZodDefault<z.ZodObject<{
+                package: z.ZodDefault<z.ZodString>;
+                distTag: z.ZodDefault<z.ZodString>;
+                registry: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;

package/dist/src/bootstrap/config/root-schema.js

@@ -92,9 +92,21 @@ const hostConfigSchema = z
         .object({
         drainTimeoutMs: z.number().int().positive().default(30_000),
         cancellationTimeoutMs: z.number().int().positive().default(30_000),
+        npm: z
+            .object({
+            package: z.string().trim().min(1).default('@atolis-hq/wake'),
+            distTag: z.string().trim().min(1).default('latest'),
+            registry: z.string().url().optional(),
+        })
+            .strict()
+            .default({ package: '@atolis-hq/wake', distTag: 'latest' }),
     })
         .strict()
-        .default({ drainTimeoutMs: 30_000, cancellationTimeoutMs: 30_000 }),
+        .default({
+        drainTimeoutMs: 30_000,
+        cancellationTimeoutMs: 30_000,
+        npm: { package: '@atolis-hq/wake', distTag: 'latest' },
+    }),
 })
     .strict()
     .default({
@@ -108,7 +120,11 @@ const hostConfigSchema = z
         extraMounts: [],
     },
     development: {},
-    selfUpdate: { drainTimeoutMs: 30_000, cancellationTimeoutMs: 30_000 },
+    selfUpdate: {
+        drainTimeoutMs: 30_000,
+        cancellationTimeoutMs: 30_000,
+        npm: { package: '@atolis-hq/wake', distTag: 'latest' },
+    },
 })
     .superRefine((value, context) => {
     if (value.development.mode === 'source' && value.development.repoRoot === undefined)

package/dist/src/bootstrap/index.d.ts

@@ -24,4 +24,5 @@ export * from './update-ledger.js';
 export * from './update-maintenance-lease.js';
 export * from './self-update-application.js';
 export * from './source-update-port.js';
+export * from './npm-update-port.js';
 export * from './version.js';

package/dist/src/bootstrap/index.js

@@ -26,4 +26,5 @@ export * from './update-ledger.js';
 export * from './update-maintenance-lease.js';
 export * from './self-update-application.js';
 export * from './source-update-port.js';
+export * from './npm-update-port.js';
 export * from './version.js';

package/dist/src/bootstrap/npm-update-port.d.ts

@@ -0,0 +1,11 @@
+import type { SourceUpdatePort } from './self-update-application.js';
+export interface NpmUpdateProcess {
+    execute(command: string, args: readonly string[]): Promise<string>;
+}
+/** Resolves immutable published package versions. Installation is performed by the rollout. */
+export declare function createNpmUpdatePort(input: {
+    readonly packageName: string;
+    readonly distTag?: string;
+    readonly registry?: string;
+    readonly execute?: NpmUpdateProcess['execute'];
+}): SourceUpdatePort;

package/dist/src/bootstrap/npm-update-port.js

@@ -0,0 +1,45 @@
+import { execFile as nodeExecFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFile = promisify(nodeExecFile);
+/** Resolves immutable published package versions. Installation is performed by the rollout. */
+export function createNpmUpdatePort(input) {
+    const execute = input.execute ?? runProcess;
+    const distTag = input.distTag ?? 'latest';
+    const registry = input.registry === undefined ? [] : [`--registry=${input.registry}`];
+    return {
+        isClean: async () => true,
+        async latestTag() {
+            const resolved = await resolveVersion();
+            if (resolved === undefined)
+                throw new Error(`No npm version is available for ${input.packageName}`);
+            return resolved;
+        },
+        async candidateTags() {
+            const resolved = await resolveVersion();
+            return resolved === undefined ? [] : [resolved];
+        },
+        // The Docker rollout installs this exact version. Keeping this side-effect-free means
+        // the updater never overwrites the CLI process which is coordinating the update.
+        checkout: async () => { },
+        healthy: async () => true,
+    };
+    async function resolveVersion() {
+        const output = await execute('npm', [
+            'view',
+            `${input.packageName}@${distTag}`,
+            'version',
+            '--json',
+            ...registry,
+        ]);
+        const parsed = JSON.parse(output);
+        const value = Array.isArray(parsed) ? parsed.at(0) : parsed;
+        if (typeof value !== 'string' ||
+            !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u.test(value))
+            throw new Error(`npm returned an invalid version for ${input.packageName}@${distTag}`);
+        return value;
+    }
+}
+async function runProcess(command, args) {
+    const result = await execFile(command, args, { encoding: 'utf8' });
+    return result.stdout;
+}

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

@@ -10,9 +10,8 @@ export function createSelfUpdateApplication(input) {
         async updateLatest(force = false) {
             const candidates = await input.source.candidateTags();
             const [latestCandidate] = candidates;
-            if (latestCandidate === undefined) {
-                throw new Error('No source version tags available');
-            }
+            if (latestCandidate === undefined)
+                throw new Error('No update versions are available');
             for (const tag of candidates) {
                 if (!force && (await input.ledger.isBad(tag))) {
                     continue;

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

@@ -12,6 +12,7 @@ import { ResourceCorrelationRole, resourceId } from '../resources/index.js';
 import { DockerProcessError, createApiDispatcher, createLoggedDockerCli, createPackagedAssetSource, createPairingGrant, createProcessLogSink, createSandboxDockerPort, createSurfaceHttpServer, drainProcessOutput, loadOrCreateCredentials, redeemPairingGrant, replaceAccessKey, runDoctor, runSandbox, runSandboxEntrypoint, runSandboxSetup, runSelfUpdateLatestLoop, runTargetSmoke, verifyResidentStart, waitForActiveRuns, waitForever, } from '../surfaces/index.js';
 import { WorkStreamKind, workItemId } from '../work/index.js';
 import { loadConfig } from './config/load-config.js';
+import { createNpmUpdatePort } from './npm-update-port.js';
 import { runtimeProjectionDefinitions } from './projection-runtime.js';
 import { createRunnerRegistry } from './runner-registry.js';
 import { createOneShotRunnerAdvance, createResidentRunnerAdvance, withFinalProjectionCatchUp, } from './runner-tick-adapter.js';
@@ -315,7 +316,7 @@ function sandboxDockerOptions(root, overrides) {
         wakeRoot: root.paths.wakeRoot,
         containerHomeRoot: root.paths.containerHomeRoot,
         image: overrides?.image ?? root.config.host.sandbox.image,
-        development: root.config.host.development,
+        development: overrides?.development ?? root.config.host.development,
         containerName: root.config.host.sandbox.containerName,
         ...(root.config.surfaces.api.enabled ? { publishedPort: root.config.surfaces.api.port } : {}),
         wakeMountPath: root.config.host.sandbox.wakeMountPath,
@@ -324,7 +325,9 @@ function sandboxDockerOptions(root, overrides) {
         startEnabled: root.config.host.sandbox.start.enabled,
         ...(process.env.WAKE_MEMORY_PROFILE === 'runner' ? { memoryProfile: 'runner' } : {}),
         inspect: createDockerInspection(root.paths.wakeRoot),
-        resolveBuildVersion: () => resolveSandboxBuildVersion(root),
+        resolveBuildVersion: async () => overrides?.buildVersion === undefined
+            ? resolveSandboxBuildVersion(root)
+            : overrides.buildVersion,
     };
 }
 function createSandboxDocker(root, overrides) {
@@ -408,23 +411,24 @@ function createSandboxRuntimeApplications(root) {
  * resident `wake start` process actually came back up. Reused for both the
  * forward deploy and a same-shaped rollback to a previously-built tag.
  */
-async function deploySandboxTag(root, docker, tag, image) {
-    const port = createSandboxDockerPort(docker, sandboxDockerOptions(root, { image }));
+async function deploySandboxTag(root, docker, tag, image, overrides) {
+    const port = createSandboxDockerPort(docker, sandboxDockerOptions(root, { image, ...overrides }));
+    const wakeInvocation = overrides?.development?.mode === 'source'
+        ? ['node', '/app/dist/src/main.js']
+        : sandboxWakeInvocation(root);
+    const healthcheckRoot = `/tmp/wake-self-update-healthcheck-${tag}`;
     await port.build();
     await port.update();
-    const wakeInvocation = sandboxWakeInvocation(root);
     await verifyResidentStart(docker, root.config.host.sandbox.containerName, [...wakeInvocation, 'start', '--wake-root', '/wake'].join(' '));
-    await port.exec([
-        ...wakeInvocation,
-        'tick',
-        '--wake-root',
-        `/tmp/wake-self-update-healthcheck-${tag}`,
-    ]);
-}
-async function rollbackSandboxTag(root, docker, image) {
+    await port.exec([...wakeInvocation, 'init', healthcheckRoot]);
+    await port.exec([...wakeInvocation, 'tick', '--wake-root', healthcheckRoot, '--no-sandbox']);
+}
+async function rollbackSandboxTag(root, docker, image, development) {
     const port = createSandboxDockerPort(docker, sandboxDockerOptions(root, { image }));
     await port.update();
-    const wakeInvocation = sandboxWakeInvocation(root);
+    const wakeInvocation = development?.mode === 'source'
+        ? ['node', '/app/dist/src/main.js']
+        : sandboxWakeInvocation(root);
     await verifyResidentStart(docker, root.config.host.sandbox.containerName, [...wakeInvocation, 'start', '--wake-root', '/wake'].join(' '));
 }
 function createOperationalApplications(root) {
@@ -450,31 +454,56 @@ function createOperationalApplications(root) {
         sandboxEntrypoint: async () => {
             await runSandboxEntrypoint(createSandboxEntrypointDependencies(root));
         },
+        // eslint-disable-next-line complexity -- update source and loop options are validated at this CLI boundary.
         selfUpdate: async (arguments_) => {
-            if (root.config.host.development.mode !== 'source')
-                throw new Error('wake self-update requires host.development.mode: source');
-            const repoRoot = root.config.host.development.repoRoot;
-            if (repoRoot === undefined)
+            const sourceRoot = optionalOperationalOption(arguments_, '--source');
+            const configuredSource = root.config.host.development.mode === 'source';
+            const repoRoot = sourceRoot ?? root.config.host.development.repoRoot;
+            if (sourceRoot !== undefined && root.config.host.development.mode === 'source')
+                throw new Error('wake self-update --source cannot override source-mode configuration');
+            if (configuredSource && repoRoot === undefined)
                 throw new Error('wake self-update requires host.development.repoRoot');
             const tag = optionalOperationalOption(arguments_, '--tag');
+            const version = optionalOperationalOption(arguments_, '--version');
+            if (tag !== undefined && version !== undefined)
+                throw new Error('wake self-update accepts only one of --tag or --version');
+            if (version !== undefined && (configuredSource || sourceRoot !== undefined))
+                throw new Error('wake self-update --version is only valid for npm updates');
+            const useSource = configuredSource || sourceRoot !== undefined;
+            const updatePort = useSource
+                ? createSourceUpdatePort({ repoRoot: repoRoot })
+                : createNpmUpdatePort({
+                    packageName: root.config.host.selfUpdate.npm.package,
+                    distTag: root.config.host.selfUpdate.npm.distTag,
+                    ...(root.config.host.selfUpdate.npm.registry === undefined
+                        ? {}
+                        : { registry: root.config.host.selfUpdate.npm.registry }),
+                });
+            const updateTag = tag ?? version;
+            const updateDevelopment = useSource
+                ? { mode: 'source', repoRoot: repoRoot }
+                : { mode: 'packaged' };
             const dockerCli = createDockerCliForRoot(root);
             const imageRepository = root.config.host.sandbox.imageRepository;
             const failureLog = createSelfUpdateFailureLog(root.paths.wakeRoot);
             const application = createSelfUpdateApplication({
                 ledger: createUpdateLedger(root.paths.wakeRoot),
-                source: createSourceUpdatePort({ repoRoot }),
+                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}`);
+                        await deploySandboxTag(root, dockerCli, deployTag, `${imageRepository}:${deployTag}`, {
+                            development: updateDevelopment,
+                            buildVersion: deployTag,
+                        });
                         // A later deploy succeeding after a prior rollback clears the stale warning.
                         await failureLog.clear();
                     },
                     async rollback(rollbackTag) {
-                        await rollbackSandboxTag(root, dockerCli, `${imageRepository}:${rollbackTag}`);
+                        await rollbackSandboxTag(root, dockerCli, `${imageRepository}:${rollbackTag}`, updateDevelopment);
                     },
                     recordFailure: (failedTag, error) => failureLog.record(failedTag, error),
                 },
@@ -485,12 +514,12 @@ function createOperationalApplications(root) {
             const force = arguments_.includes('--force');
             if (arguments_.includes('--loop')) {
                 const intervalMs = selfUpdateLoopInterval(arguments_);
-                if (tag !== undefined)
-                    return runSelfUpdateLatestLoop(async () => application.update(tag, force), () => delay(intervalMs));
+                if (updateTag !== undefined)
+                    return runSelfUpdateLatestLoop(async () => application.update(updateTag, force), () => delay(intervalMs));
                 return runSelfUpdateLatestLoop(async () => application.updateLatest(force), () => delay(intervalMs));
             }
-            if (tag !== undefined)
-                return { tag, updated: await application.update(tag, force) };
+            if (updateTag !== undefined)
+                return { tag: updateTag, updated: await application.update(updateTag, force) };
             return application.updateLatest(force);
         },
         smoke: async () => runTargetSmoke(createRunnerRegistry(root.config.execution, root.fakeScenarios), root.config.execution.defaultRunnerPool, new AbortController().signal),

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.16";
+export const wakeVersion = "v0.4.18";
 /** The registry-installable version used by packaged sandbox images. */
 export const wakePackageVersion = packageVersion(defaultRepoRoot) ?? wakeVersion;

package/dist/src/surfaces/cli/usage.js

@@ -24,7 +24,7 @@ export const usage = [
     '  wake run resolve <run-id> --failed --reason <message>',
     '  wake api                   Run the target API surface',
     '  wake sandbox-entrypoint    Run the sandbox resident entrypoint',
-    '  wake self-update           Safely update a source installation',
+    '  wake self-update           Safely update Wake from npm or a source checkout',
     '',
     'Getting started:',
     '  1. wake init ./wake-home',

package/package.json

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