@timurproko/a1 0.2.7-dev.810 → 0.2.7-dev.828

package/dist/foundation/release/progress-palette.generated.js

@@ -1,5 +1,139 @@
 /**
- * Generated by scripts/pi/sync-progress-palette.ts from @earendil-works/pi-coding-agent 1.4.0
- * (MIT), commit 4a080252f06caf63a525d7873c5d94d3c23887e0. Do not edit directly.
+ * Generated by scripts/pi/sync-progress-palette.ts from A1's named accent projection
+ * over pinned Pi 1.4.0 (MIT), commit 4a080252f06caf63a525d7873c5d94d3c23887e0. Do not edit directly.
  */
-export const SHARED_PROGRESS_ACCENT_ANSI = "\u001b[38;2;167;152;215m";
+export const SHARED_PROGRESS_PALETTE = Object.freeze({
+    "blue": {
+        "dark": {
+            "truecolor": {
+                "accent": "\u001b[38;2;130;160;241m",
+                "border": "\u001b[38;2;116;102;197m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;111m",
+                "border": "\u001b[38;5;98m"
+            }
+        },
+        "light": {
+            "truecolor": {
+                "accent": "\u001b[38;2;63;96;226m",
+                "border": "\u001b[38;2;83;67;154m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;62m",
+                "border": "\u001b[38;5;60m"
+            }
+        }
+    },
+    "purple": {
+        "dark": {
+            "truecolor": {
+                "accent": "\u001b[38;2;167;152;215m",
+                "border": "\u001b[38;2;105;115;167m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;140m",
+                "border": "\u001b[38;5;61m"
+            }
+        },
+        "light": {
+            "truecolor": {
+                "accent": "\u001b[38;2;116;89;180m",
+                "border": "\u001b[38;2;68;77;130m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;97m",
+                "border": "\u001b[38;5;60m"
+            }
+        }
+    },
+    "cyan": {
+        "dark": {
+            "truecolor": {
+                "accent": "\u001b[38;2;93;179;186m",
+                "border": "\u001b[38;2;74;128;146m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;73m",
+                "border": "\u001b[38;5;66m"
+            }
+        },
+        "light": {
+            "truecolor": {
+                "accent": "\u001b[38;2;40;122;129m",
+                "border": "\u001b[38;2;40;89;106m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;30m",
+                "border": "\u001b[38;5;23m"
+            }
+        }
+    },
+    "green": {
+        "dark": {
+            "truecolor": {
+                "accent": "\u001b[38;2;104;183;141m",
+                "border": "\u001b[38;2;75;132;120m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;72m",
+                "border": "\u001b[38;5;66m"
+            }
+        },
+        "light": {
+            "truecolor": {
+                "accent": "\u001b[38;2;51;126;88m",
+                "border": "\u001b[38;2;41;93;82m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;65m",
+                "border": "\u001b[38;5;23m"
+            }
+        }
+    },
+    "orange": {
+        "dark": {
+            "truecolor": {
+                "accent": "\u001b[38;2;231;135;83m",
+                "border": "\u001b[38;2;178;89;79m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;173m",
+                "border": "\u001b[38;5;131m"
+            }
+        },
+        "light": {
+            "truecolor": {
+                "accent": "\u001b[38;2;174;80;16m",
+                "border": "\u001b[38;2;133;57;49m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;130m",
+                "border": "\u001b[38;5;95m"
+            }
+        }
+    },
+    "pink": {
+        "dark": {
+            "truecolor": {
+                "accent": "\u001b[38;2;223;122;199m",
+                "border": "\u001b[38;2;150;91;171m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;176m",
+                "border": "\u001b[38;5;97m"
+            }
+        },
+        "light": {
+            "truecolor": {
+                "accent": "\u001b[38;2;178;56;153m",
+                "border": "\u001b[38;2;114;61;131m"
+            },
+            "256color": {
+                "accent": "\u001b[38;5;132m",
+                "border": "\u001b[38;5;60m"
+            }
+        }
+    }
+});
+export const SHARED_PROGRESS_ACCENT_ANSI = SHARED_PROGRESS_PALETTE.blue.dark.truecolor.accent;

package/dist/foundation/release/release-gc.js

@@ -316,14 +316,29 @@ async function residentReleaseHolds(dataDir, reader) {
     const everything = () => [...new Set(records.map(record => record.releaseId))].map(releaseId => ({ authority: "resident", releaseId }));
     if (!report.complete)
         return everything();
-    const byRoot = new Map(records.map(record => [comparablePath(record.releaseRoot), record.releaseId]));
-    const store = comparablePath(resolve(dataDir, "releases"));
+    if (report.releaseRoots.length === 0)
+        return [];
+    // Rationale: native Windows extended paths and Unix aliases must match the catalog's spelling.
+    const byRoot = new Map();
+    for (const record of records) {
+        const canonical = await realpath(record.releaseRoot).catch(() => record.releaseRoot);
+        byRoot.set(comparablePath(canonical), record.releaseId);
+    }
+    const directory = await realpath(resolve(dataDir, "releases")).catch(() => null);
+    if (directory === null)
+        return everything();
+    const store = comparablePath(directory);
     const holds = new Set();
     for (const root of report.releaseRoots) {
-        const releaseId = byRoot.get(comparablePath(root));
+        // Security: an unresolved live root may alias managed content; uncertainty must retain it.
+        const canonical = await realpath(root).catch(() => null);
+        if (canonical === null)
+            return everything();
+        const key = comparablePath(canonical);
+        const releaseId = byRoot.get(key);
         if (releaseId)
             holds.add(releaseId);
-        else if (comparablePath(root).startsWith(`${store}${sep}`))
+        else if (key.startsWith(`${store}${sep}`))
             return everything();
     }
     return [...holds].sort().map(releaseId => ({ authority: "resident", releaseId }));

package/dist/foundation/release/update-execution-lease.d.ts

@@ -0,0 +1,36 @@
+import type { UpdateChannel } from "./types.js";
+export declare const UPDATE_EXECUTION_LEASE_FILENAME = "update-execution.json";
+declare const LEASE_SCHEMA = 1;
+export type UpdateExecutionMode = "manual" | "automatic";
+export interface UpdateExecutionOwner {
+    readonly schema: typeof LEASE_SCHEMA;
+    readonly ownerId: string;
+    readonly pid: number;
+    readonly pidStartIdentity: string;
+    readonly packageRoot: string;
+    readonly channel: UpdateChannel;
+    readonly targetVersion: string;
+    readonly mode: UpdateExecutionMode;
+    readonly acquiredAt: string;
+}
+export type UpdateExecutionLeaseResult = {
+    readonly status: "acquired";
+    readonly owner: UpdateExecutionOwner;
+    release(): Promise<void>;
+} | {
+    readonly status: "busy";
+    readonly owner: UpdateExecutionOwner;
+};
+/**
+ * Serializes every package replacement for one A1 data root. A dead owner is moved aside before a
+ * new exclusive create, so concurrent recovery attempts cannot both acquire the installation.
+ */
+export declare function acquireUpdateExecutionLease(input: {
+    readonly dataDir: string;
+    readonly packageRoot: string;
+    readonly channel: UpdateChannel;
+    readonly targetVersion: string;
+    readonly mode: UpdateExecutionMode;
+}): Promise<UpdateExecutionLeaseResult>;
+export declare function readUpdateExecutionOwner(dataDir: string): Promise<UpdateExecutionOwner | null>;
+export {};

package/dist/foundation/release/update-execution-lease.js

@@ -0,0 +1,145 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, open, readFile, rename, rm } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import lockfile from "proper-lockfile";
+import { processIsAlive } from "./process-cleanup.js";
+import { UpdateTransactionStore } from "./update-transaction.js";
+export const UPDATE_EXECUTION_LEASE_FILENAME = "update-execution.json";
+const LEASE_SCHEMA = 1;
+const MAX_LEASE_BYTES = 8_192;
+/**
+ * Serializes every package replacement for one A1 data root. A dead owner is moved aside before a
+ * new exclusive create, so concurrent recovery attempts cannot both acquire the installation.
+ */
+export async function acquireUpdateExecutionLease(input) {
+    const path = resolve(input.dataDir, UPDATE_EXECUTION_LEASE_FILENAME);
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const releaseAcquisition = await lockfile.lock(path, {
+        realpath: false,
+        stale: 60_000,
+        update: 20_000,
+        retries: { retries: 20, factor: 1.2, minTimeout: 20, maxTimeout: 100, randomize: true },
+    });
+    const owner = {
+        schema: LEASE_SCHEMA,
+        ownerId: randomUUID(),
+        pid: process.pid,
+        pidStartIdentity: currentProcessStartIdentity(),
+        packageRoot: resolve(input.packageRoot),
+        channel: input.channel,
+        targetVersion: input.targetVersion,
+        mode: input.mode,
+        acquiredAt: new Date().toISOString(),
+    };
+    try {
+        for (let attempt = 0; attempt < 4; attempt += 1) {
+            try {
+                const file = await open(path, "wx", 0o600);
+                try {
+                    await file.writeFile(`${JSON.stringify(owner)}\n`);
+                    await file.sync();
+                }
+                finally {
+                    await file.close();
+                }
+                return {
+                    status: "acquired",
+                    owner,
+                    release: async () => await releaseLease(path, owner),
+                };
+            }
+            catch (error) {
+                if (!hasCode(error, "EEXIST"))
+                    throw error;
+            }
+            const existing = await readUpdateExecutionOwner(input.dataDir);
+            if (existing === null)
+                continue;
+            // Security: an uninspectable or reused pid stays conservative. A process known to be absent is
+            // reclaimed only when its durable transaction agrees with both owners.
+            if (processIsAlive(existing.pid))
+                return { status: "busy", owner: existing };
+            if (!await staleLeaseMatchesTransaction(input.dataDir, existing, input))
+                return { status: "busy", owner: existing };
+            const stale = `${path}.stale-${existing.ownerId}-${randomUUID()}`;
+            try {
+                await rename(path, stale);
+                await rm(stale, { force: true });
+            }
+            catch (error) {
+                if (!hasCode(error, "ENOENT"))
+                    throw error;
+            }
+        }
+        const existing = await readUpdateExecutionOwner(input.dataDir);
+        if (existing !== null)
+            return { status: "busy", owner: existing };
+        throw new Error("could not acquire update execution lease");
+    }
+    finally {
+        await releaseAcquisition();
+    }
+}
+export async function readUpdateExecutionOwner(dataDir) {
+    const path = resolve(dataDir, UPDATE_EXECUTION_LEASE_FILENAME);
+    let source;
+    try {
+        source = await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (hasCode(error, "ENOENT"))
+            return null;
+        throw error;
+    }
+    if (Buffer.byteLength(source, "utf8") > MAX_LEASE_BYTES)
+        throw new Error("update execution lease is oversized");
+    const value = JSON.parse(source);
+    validateOwner(value);
+    return value;
+}
+async function releaseLease(path, owner) {
+    const current = await readUpdateExecutionOwner(dirname(path));
+    if (current === null || current.ownerId !== owner.ownerId || current.pid !== owner.pid
+        || current.pidStartIdentity !== owner.pidStartIdentity)
+        return;
+    const released = `${path}.released-${owner.ownerId}-${randomUUID()}`;
+    try {
+        await rename(path, released);
+        await rm(released, { force: true });
+    }
+    catch (error) {
+        if (!hasCode(error, "ENOENT"))
+            throw error;
+    }
+}
+function validateOwner(value) {
+    if (value.schema !== LEASE_SCHEMA || typeof value.ownerId !== "string" || value.ownerId.length === 0
+        || !Number.isSafeInteger(value.pid) || value.pid <= 0 || typeof value.pidStartIdentity !== "string"
+        || typeof value.packageRoot !== "string" || !["stable", "next"].includes(value.channel)
+        || typeof value.targetVersion !== "string" || !["manual", "automatic"].includes(value.mode)
+        || typeof value.acquiredAt !== "string") {
+        throw new Error("invalid update execution lease");
+    }
+}
+async function staleLeaseMatchesTransaction(dataDir, owner, requested) {
+    const transaction = await new UpdateTransactionStore(dataDir).read();
+    if (transaction?.status !== "active")
+        return true;
+    return transaction.channel === owner.channel && transaction.targetVersion === owner.targetVersion
+        && samePath(transaction.packageRoot, owner.packageRoot)
+        && requested.channel === owner.channel && requested.targetVersion === owner.targetVersion
+        && samePath(requested.packageRoot, owner.packageRoot);
+}
+function samePath(left, right) {
+    const canonicalLeft = resolve(left);
+    const canonicalRight = resolve(right);
+    return process.platform === "win32"
+        ? canonicalLeft.toLowerCase() === canonicalRight.toLowerCase()
+        : canonicalLeft === canonicalRight;
+}
+function currentProcessStartIdentity() {
+    return `${process.pid}:${Math.floor(Date.now() - process.uptime() * 1_000)}`;
+}
+function hasCode(error, code) {
+    return error instanceof Error && "code" in error && error.code === code;
+}

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

@@ -1,6 +1,7 @@
 import type { UpdateChannel } from "./types.js";
 import { type UpdateActivationPhase, type UpdateMaterializationProgress } from "./update-activation.js";
 import { type UpdateRecoveryState, type UpdateTransaction, type UpdateTransactionPhase } from "./update-transaction.js";
+import { type UpdateExecutionOwner } from "./update-execution-lease.js";
 import { resolveNpmCli, type ProtectedPackageReplacementResult } from "./update-recovery.js";
 export declare const PRODUCT_PACKAGE: string;
 export type { UpdateChannel } from "./types.js";
@@ -61,6 +62,11 @@ export interface SelfUpdateOptions {
     channel?: UpdateChannel;
     /** A specific preview to install, named by its development number or full version. */
     target?: string;
+    /** Internal exact channel target selected by the automatic update probe. */
+    resolvedTarget?: string;
+    mode?: "manual" | "automatic";
+    onLeaseAcquired?: (owner: UpdateExecutionOwner) => void;
+    onLeaseBusy?: (owner: UpdateExecutionOwner) => void;
     environment?: NodeJS.ProcessEnv;
     fileSystem?: UpdateFileSystem;
     output?: UpdateOutput;
@@ -80,6 +86,7 @@ export interface SelfUpdateOptions {
 export type { UpdateActivationPhase, UpdateMaterializationProgress } from "./update-activation.js";
 export interface UpdateLifecycleCoordinator {
     targetIsActive(targetVersion: string): Promise<boolean>;
+    verifyAutomaticSafety?(): Promise<void>;
     shutdownVerifiedOwners(targetVersion: string): Promise<{
         priorActiveVersion: string | null;
     }>;
@@ -123,6 +130,7 @@ export interface UpdatePackageReplacementInput {
  * The update therefore keeps checking for this long before it calls the package locked.
  */
 export declare const PACKAGE_UNLOCK_PATIENCE_MS = 15000;
+export declare const UPDATE_ALREADY_RUNNING_EXIT_CODE = 75;
 /** Whether a rename failure means something holds the tree, as opposed to the tree being wrong. */
 export declare function isPackageLockError(error: unknown): boolean;
 /** What the user reads when the package stayed held for the whole patience window. */
@@ -131,15 +139,9 @@ export declare function lockedPackageDiagnostic(packageRoot: string, waitedMs: n
 export declare const CHILD_DIAGNOSTIC_LIMIT = 8000;
 export declare function createNpmProcessRunner(platform?: NodeJS.Platform): UpdateProcessRunner;
 export type UpdateOwnershipAction = "clean-dead-record" | "leave-running" | "end-session";
-/**
- * What an update does about the owner it found. A cohort running from retained immutable
- * content keeps its work: the installation replaces files it does not read, and it listens on
- * its own endpoint. A cohort running from the mutable installation is the one exception,
- * because that installation is exactly what is about to be replaced under it.
- */
 export declare function planUpdateOwnership(ownership: "live-verified" | "dead", runsFromRetainedRelease: boolean): UpdateOwnershipAction;
 export declare function createUpdateLifecycleCoordinator(environment?: NodeJS.ProcessEnv, fileSystem?: UpdateFileSystem, output?: UpdateOutput, patience?: UpdateUnlockPatience): UpdateLifecycleCoordinator;
 /** Renders the terminal-only update meter; the visual preview shares this exact frame. */
-export declare function renderUpdateProgressBar(percent: number): string;
+export declare function renderUpdateProgressBar(percent: number, accent?: string): string;
 export declare function runSelfUpdate(options: SelfUpdateOptions): Promise<number>;
 export declare function assertUpdatePerformanceBudget(evidence: UpdatePerformanceEvidence, maximumPostNpmDurationMs?: number): void;