@timurproko/a1 0.1.1-dev.1 → 0.1.1-dev.2

package/dist/src/foundation/release/bootstrap.js

@@ -8,7 +8,7 @@ import { CohortStateStore } from "./cohort-state.js";
 import { assertLaunchProfileId, resolveProductPaths } from "../lifecycle/index.js";
 import { encodeFrame, LineFrameDecoder } from "../protocol/index.js";
 import { cleanupProvenIdleOwner, processIsAlive } from "./process-cleanup.js";
-import { materializeRelease, readMaterializedRelease, resolveReleaseEntryPoint, verifyMaterializedRelease } from "./release-store.js";
+import { materializeRelease, readCertifiedReleaseManifest, readMaterializedRelease, resolveReleaseEntryPoint, verifyMaterializedRelease } from "./release-store.js";
 import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
 export async function runBootstrap(options) {
     const environment = { ...(options.environment ?? process.env) };
@@ -18,18 +18,43 @@ export async function runBootstrap(options) {
     const output = options.output ?? process.stderr;
     const paths = resolveProductPaths(environment);
     await mkdir(paths.runtimeDir, { recursive: true, mode: 0o700 });
-    const candidate = await materializeRelease(options.packageRoot, paths.dataDir);
     const stateStore = new CohortStateStore(paths.dataDir);
-    await stateStore.recordCandidate(candidate);
     let state = await stateStore.read();
+    let endpoint = await readEndpointMetadata(paths.endpointMetadataPath);
+    let probe = endpoint ? await probeOwnership(endpoint) : "dead";
+    const installedVersion = await readInstalledVersion(options.packageRoot);
+    const activeId = state.references.active;
+    const active = activeId === null ? undefined : state.releases[activeId];
+    if (active?.approval === "approved" && active.packageVersion === installedVersion) {
+        const endpointMatches = endpoint?.releaseId === active.releaseId
+            && endpoint.releaseRoot === active.releaseRoot
+            && endpoint.contentDigest === active.contentDigest;
+        if (endpointMatches && probe === "live-verified") {
+            const retained = await readCertifiedReleaseManifest(active, resolve(paths.dataDir, "releases"));
+            return await launchUi(retained, environment);
+        }
+        if (endpoint === null || probe === "dead") {
+            if (endpoint)
+                await removeEndpointArtifacts(paths.endpointMetadataPath, paths.endpoint);
+            const retained = await readMaterializedRelease(active.releaseRoot);
+            await startSupervisor(retained, environment);
+            await waitForVerifiedEndpoint(paths.endpointMetadataPath, retained, 8_000);
+            return await launchUi(retained, environment);
+        }
+    }
+    const candidate = await materializeRelease(options.packageRoot, paths.dataDir, {
+        onProgress: progress => output.write(`${PRODUCT_TEXT.diagnostic(`preparing ${progress.fileCount} installed release files; first launch may take a moment.`)}\n`),
+    });
+    await stateStore.recordCandidate(candidate);
+    state = await stateStore.read();
     if (!state.references.active) {
         const diagnosticsPath = await certifyMaterializedRelease(candidate, paths.dataDir);
         await stateStore.approve(candidate.releaseId, diagnosticsPath);
         await stateStore.activate(candidate.releaseId);
         state = await stateStore.read();
     }
-    const endpoint = await readEndpointMetadata(paths.endpointMetadataPath);
-    const probe = endpoint ? await probeOwnership(endpoint) : "dead";
+    endpoint = await readEndpointMetadata(paths.endpointMetadataPath);
+    probe = endpoint ? await probeOwnership(endpoint) : "dead";
     let decision = selectCohortLaunch(candidate, state, endpoint, probe);
     if (decision.action === "blocked") {
         await stateStore.blockPending(decision.reason, endpoint?.ownership.liveGenerationIds ?? []);
@@ -93,6 +118,13 @@ export async function runBootstrap(options) {
     await waitForVerifiedEndpoint(paths.endpointMetadataPath, selected, 8_000);
     return await launchUi(selected, environment);
 }
+async function readInstalledVersion(packageRoot) {
+    const manifest = JSON.parse(await readFile(resolve(packageRoot, "package.json"), "utf8"));
+    if (typeof manifest.version !== "string" || manifest.version.length === 0) {
+        throw new Error(PRODUCT_TEXT.diagnostic("package metadata has no version"));
+    }
+    return manifest.version;
+}
 export async function certifyMaterializedRelease(release, dataDir) {
     await verifyMaterializedRelease(release.releaseRoot, release, resolve(dataDir, "releases"));
     const path = resolve(dataDir, `certification-${release.releaseId}.json`);

package/dist/src/foundation/release/concurrency.d.ts

@@ -0,0 +1 @@
+export declare function mapWithConcurrency<Value, Result>(values: readonly Value[], concurrency: number, operation: (value: Value, index: number) => Promise<Result>): Promise<Result[]>;

package/dist/src/foundation/release/concurrency.js

@@ -0,0 +1,17 @@
+export async function mapWithConcurrency(values, concurrency, operation) {
+    if (!Number.isSafeInteger(concurrency) || concurrency < 1)
+        throw new RangeError("concurrency must be a positive safe integer");
+    const results = new Array(values.length);
+    let nextIndex = 0;
+    const worker = async () => {
+        while (true) {
+            const index = nextIndex;
+            nextIndex += 1;
+            if (index >= values.length)
+                return;
+            results[index] = await operation(values[index], index);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, values.length) }, worker));
+    return results;
+}

package/dist/src/foundation/release/release-store.d.ts

@@ -3,8 +3,27 @@ export declare const RELEASE_MANIFEST_FILENAME: string;
 export interface MaterializedRelease extends ReleaseIdentity {
     readonly releaseRoot: string;
 }
-export declare function materializeRelease(packageRoot: string, dataDir: string): Promise<MaterializedRelease>;
+export interface MaterializeReleaseOptions {
+    readonly onProgress?: (progress: {
+        readonly phase: "copying";
+        readonly fileCount: number;
+    }) => void;
+}
+export interface CertifiedReleaseRecord {
+    readonly releaseId: string;
+    readonly releaseRoot: string;
+    readonly packageVersion?: string;
+    readonly contentDigest: string;
+}
+export declare function materializeRelease(packageRoot: string, dataDir: string, options?: MaterializeReleaseOptions): Promise<MaterializedRelease>;
 export declare function readMaterializedRelease(releaseRoot: string): Promise<MaterializedRelease>;
+/**
+ * Load metadata for a release whose bytes were already certified by the
+ * current parent process or an authenticated live supervisor. Callers must
+ * establish one of those preconditions; untrusted releases require full
+ * verification.
+ */
+export declare function readCertifiedReleaseManifest(record: CertifiedReleaseRecord, selectedStoreRoot: string): Promise<MaterializedRelease>;
 export declare function verifyMaterializedRelease(releaseRoot: string, expected?: ReleaseIdentity, selectedStoreRoot?: string): Promise<MaterializedRelease>;
 export declare function assertImmutableExecutionRoot(release: MaterializedRelease, dataDir: string): Promise<void>;
 export declare function resolveReleaseEntryPoint(release: MaterializedRelease, entryPoint: string): Promise<string>;

package/dist/src/foundation/release/release-store.js

@@ -3,8 +3,10 @@ import { chmod, copyFile, lstat, mkdir, readFile, realpath, rename, rm, writeFil
 import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { PRODUCT_PACKAGE_NAME, deriveReleaseIdentity, resolveWithin } from "./release.js";
 import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
+import { mapWithConcurrency } from "./concurrency.js";
+const RELEASE_FILE_IO_CONCURRENCY = 32;
 export const RELEASE_MANIFEST_FILENAME = PRODUCT_IDENTITY.manifest.releaseFilename;
-export async function materializeRelease(packageRoot, dataDir) {
+export async function materializeRelease(packageRoot, dataDir, options = {}) {
     const identity = await deriveReleaseIdentity(packageRoot);
     const storeRoot = resolve(dataDir, "releases");
     await mkdir(storeRoot, { recursive: true, mode: 0o700 });
@@ -12,20 +14,31 @@ export async function materializeRelease(packageRoot, dataDir) {
     const existing = await lstat(releaseRoot).catch(() => null);
     if (existing)
         return await verifyMaterializedRelease(releaseRoot, identity);
+    options.onProgress?.({ phase: "copying", fileCount: identity.files.length });
     const candidate = resolveWithin(storeRoot, `.candidate-${identity.releaseId}-${randomUUID()}`);
     await mkdir(candidate, { recursive: false, mode: 0o700 });
     try {
-        for (const file of identity.files) {
+        const directories = [...new Set(identity.files.map(file => dirname(resolveWithin(candidate, file.path))))];
+        await mapWithConcurrency(directories, RELEASE_FILE_IO_CONCURRENCY, async (directory) => {
+            await mkdir(directory, { recursive: true, mode: 0o700 });
+        });
+        await mapWithConcurrency(identity.files, RELEASE_FILE_IO_CONCURRENCY, async (file) => {
             const source = resolveWithin(identity.packageRoot, file.path);
             const destination = resolveWithin(candidate, file.path);
-            await mkdir(dirname(destination), { recursive: true, mode: 0o700 });
             await copyFile(source, destination);
             await chmod(destination, file.executable ? 0o500 : 0o400);
-        }
+        });
         await writeFile(resolve(candidate, RELEASE_MANIFEST_FILENAME), JSON.stringify(identity, null, 2), { mode: 0o400, flag: "wx" });
-        await verifyMaterializedRelease(candidate, identity);
-        await rename(candidate, releaseRoot);
-        return await verifyMaterializedRelease(releaseRoot, identity);
+        try {
+            await rename(candidate, releaseRoot);
+        }
+        catch (error) {
+            if (!await lstat(releaseRoot).catch(() => null))
+                throw error;
+            await rm(candidate, { recursive: true, force: true });
+            return await verifyMaterializedRelease(releaseRoot, identity);
+        }
+        return { ...identity, releaseRoot: await realpath(releaseRoot) };
     }
     catch (error) {
         await rm(candidate, { recursive: true, force: true });
@@ -37,6 +50,25 @@ export async function readMaterializedRelease(releaseRoot) {
     const manifest = JSON.parse(await readFile(resolve(canonical, RELEASE_MANIFEST_FILENAME), "utf8"));
     return await verifyMaterializedRelease(canonical, manifest);
 }
+/**
+ * Load metadata for a release whose bytes were already certified by the
+ * current parent process or an authenticated live supervisor. Callers must
+ * establish one of those preconditions; untrusted releases require full
+ * verification.
+ */
+export async function readCertifiedReleaseManifest(record, selectedStoreRoot) {
+    const canonical = await realpath(record.releaseRoot);
+    assertContained(await realpath(selectedStoreRoot), canonical, "release root is outside the selected release store");
+    const manifest = JSON.parse(await readFile(resolveWithin(canonical, RELEASE_MANIFEST_FILENAME), "utf8"));
+    validateManifest(manifest);
+    if (manifest.releaseId !== record.releaseId || manifest.contentDigest !== record.contentDigest
+        || (record.packageVersion !== undefined && manifest.packageVersion !== record.packageVersion)) {
+        throw new Error(`certified release record differs from manifest for ${canonical}`);
+    }
+    if (canonical.split(sep).at(-1) !== manifest.releaseId)
+        throw new Error(`release directory does not match identity ${manifest.releaseId}`);
+    return { ...manifest, releaseRoot: canonical };
+}
 export async function verifyMaterializedRelease(releaseRoot, expected, selectedStoreRoot) {
     const canonical = await realpath(releaseRoot);
     if (selectedStoreRoot)
@@ -50,15 +82,17 @@ export async function verifyMaterializedRelease(releaseRoot, expected, selectedS
     if (canonical.split(sep).at(-1) !== manifest.releaseId && !canonical.split(sep).at(-1)?.startsWith(`.candidate-${manifest.releaseId}-`)) {
         throw new Error(`release directory does not match identity ${manifest.releaseId}`);
     }
-    for (const file of manifest.files)
+    await mapWithConcurrency(manifest.files, RELEASE_FILE_IO_CONCURRENCY, async (file) => {
         await verifyFile(canonical, file);
+    });
     const recomputed = digestManifestFiles(manifest.files);
     if (recomputed !== manifest.contentDigest)
         throw new Error(`release content digest mismatch for ${manifest.releaseId}`);
     return { ...manifest, releaseRoot: canonical };
 }
 export async function assertImmutableExecutionRoot(release, dataDir) {
-    await verifyMaterializedRelease(release.releaseRoot, release, resolve(dataDir, "releases"));
+    const storeRoot = await realpath(resolve(dataDir, "releases"));
+    assertContained(storeRoot, release.releaseRoot, "release root is outside the selected release store");
     const selectedRoot = process.env[PRODUCT_IDENTITY.environment.releaseRoot];
     if (!selectedRoot)
         throw new Error(PRODUCT_TEXT.diagnostic("persistent process has no immutable release root"));

package/dist/src/foundation/release/release.js

@@ -2,6 +2,8 @@ import { createHash } from "node:crypto";
 import { lstat, readFile, readdir, realpath } from "node:fs/promises";
 import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
+import { mapWithConcurrency } from "./concurrency.js";
+const RELEASE_FILE_IO_CONCURRENCY = 32;
 export const PRODUCT_PACKAGE_NAME = PRODUCT_IDENTITY.packageName;
 /**
  * Derive release execution identity only from installed distribution metadata and
@@ -23,20 +25,20 @@ export async function deriveReleaseIdentity(packageRoot) {
         await collectFiles(canonicalRoot, absolute, paths);
     }
     await collectDependencyClosure(canonicalRoot, canonicalRoot, manifest, paths, new Set());
-    const files = [];
-    for (const path of [...paths].sort()) {
+    const sortedPaths = [...paths].sort();
+    const files = await mapWithConcurrency(sortedPaths, RELEASE_FILE_IO_CONCURRENCY, async (path) => {
         const absolute = resolveWithin(canonicalRoot, path);
         const metadata = await lstat(absolute);
         if (!metadata.isFile())
             throw new Error(`release payload is not a regular file: ${path}`);
         const bytes = await readFile(absolute);
-        files.push({
+        return {
             path: normalizeRelative(path),
             bytes: bytes.length,
             sha256: createHash("sha256").update(bytes).digest("hex"),
             executable: (metadata.mode & 0o111) !== 0,
-        });
-    }
+        };
+    });
     const digest = createHash("sha256");
     for (const file of files)
         digest.update(`${file.path}\0${file.bytes}\0${file.sha256}\0${file.executable ? 1 : 0}\n`);

package/dist/src/foundation/release/update.d.ts

@@ -50,5 +50,5 @@ export interface UpdateTransactionJournal {
     clearCompleted(): Promise<void>;
 }
 export declare function createNpmProcessRunner(platform?: NodeJS.Platform): UpdateProcessRunner;
-export declare function createUpdateLifecycleCoordinator(environment?: NodeJS.ProcessEnv, fileSystem?: UpdateFileSystem): UpdateLifecycleCoordinator;
+export declare function createUpdateLifecycleCoordinator(environment?: NodeJS.ProcessEnv, fileSystem?: UpdateFileSystem, output?: UpdateOutput): UpdateLifecycleCoordinator;
 export declare function runSelfUpdate(options: SelfUpdateOptions): Promise<number>;

package/dist/src/foundation/release/update.js

@@ -40,7 +40,7 @@ export function createNpmProcessRunner(platform = process.platform) {
         } });
     });
 }
-export function createUpdateLifecycleCoordinator(environment = process.env, fileSystem = defaultFileSystem) {
+export function createUpdateLifecycleCoordinator(environment = process.env, fileSystem = defaultFileSystem, output = defaultOutput) {
     const paths = resolveProductPaths(environment);
     const stateStore = new CohortStateStore(paths.dataDir);
     return {
@@ -106,7 +106,9 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
             }
         },
         async activateInstalled(packageRoot, targetVersion, phase) {
-            const candidate = await materializeRelease(packageRoot, paths.dataDir);
+            const candidate = await materializeRelease(packageRoot, paths.dataDir, {
+                onProgress: progress => output.stdout(`${PRODUCT_TEXT.diagnostic(`preparing ${progress.fileCount} installed release files; this one-time activation may take a moment.`)}\n`),
+            });
             if (candidate.packageVersion !== targetVersion)
                 throw new Error(`installed ${PRODUCT_TEXT.displayName} version ${candidate.packageVersion} does not match target ${targetVersion}`);
             await stateStore.recordCandidate(candidate);
@@ -170,7 +172,7 @@ export async function runSelfUpdate(options) {
     }
     const environment = options.environment ?? process.env;
     const paths = resolveProductPaths(environment);
-    const lifecycle = options.lifecycle ?? createUpdateLifecycleCoordinator(environment, fileSystem);
+    const lifecycle = options.lifecycle ?? createUpdateLifecycleCoordinator(environment, fileSystem, output);
     const transactionStore = options.transactionStore ?? new UpdateTransactionStore(paths.dataDir);
     let transaction = await transactionStore.read();
     try {

package/dist/src/foundation/supervision/main.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { appendFileSync, mkdirSync } from "node:fs";
-import { assertImmutableExecutionRoot, readMaterializedRelease } from "../release/index.js";
+import { resolve } from "node:path";
+import { assertImmutableExecutionRoot, readCertifiedReleaseManifest } from "../release/index.js";
 import { ControlStore } from "../storage/index.js";
 import { resolveProductPaths } from "./paths.js";
 import { SupervisorServer } from "./server.js";
@@ -10,11 +11,11 @@ export async function runSupervisor() {
     mkdirSync(paths.runtimeDir, { recursive: true, mode: 0o700 });
     const log = (message) => appendFileSync(paths.supervisorLogPath, `${new Date().toISOString()} ${message}\n`);
     const releaseRoot = process.env[PRODUCT_IDENTITY.environment.releaseRoot];
-    if (!releaseRoot)
+    const releaseId = process.env[PRODUCT_IDENTITY.environment.releaseId];
+    const contentDigest = process.env[PRODUCT_IDENTITY.environment.releaseDigest];
+    if (!releaseRoot || !releaseId || !contentDigest)
         throw new Error(PRODUCT_TEXT.diagnostic("supervisor must be launched from a verified immutable release"));
-    const release = await readMaterializedRelease(releaseRoot);
-    if (process.env[PRODUCT_IDENTITY.environment.releaseId] !== release.releaseId)
-        throw new Error(PRODUCT_TEXT.diagnostic("selected release identity does not match its verified manifest"));
+    const release = await readCertifiedReleaseManifest({ releaseRoot, releaseId, contentDigest }, resolve(paths.dataDir, "releases"));
     await assertImmutableExecutionRoot(release, paths.dataDir);
     const bootNonce = randomUUID();
     const store = new ControlStore(paths.databasePath, bootNonce);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.1.1-dev.1",
+  "version": "0.1.1-dev.2",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "packageManager": "npm@11.13.0",