@timurproko/a1 0.1.8-dev.235df0e → 0.1.8-dev.259

package/dist/src/foundation/release/cohort-state.js

@@ -1,202 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { mkdir, open, readFile, rename, rm } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-import { PRODUCT_IDENTITY } from "../../product-identity.js";
-export const RELEASE_COHORT_SCHEMA = PRODUCT_IDENTITY.protocol.releaseCohortSchema;
-export class CohortStateStore {
-    path;
-    constructor(dataDir) {
-        this.path = resolve(dataDir, "release-state.json");
-    }
-    async read() {
-        try {
-            const state = JSON.parse(await readFile(this.path, "utf8"));
-            validateState(state);
-            return state;
-        }
-        catch (error) {
-            if (error instanceof Error && "code" in error && error.code === "ENOENT")
-                return emptyState();
-            throw error;
-        }
-    }
-    async update(operation) {
-        await mkdir(dirname(this.path), { recursive: true, mode: 0o700 });
-        const lockPath = `${this.path}.lock`;
-        const lock = await acquireLock(lockPath);
-        try {
-            const current = await this.read();
-            const next = operation(current);
-            validateTransition(current, next);
-            const committed = { ...next, revision: current.revision + 1 };
-            const temporary = `${this.path}.${process.pid}.${randomUUID()}.tmp`;
-            const file = await open(temporary, "wx", 0o600);
-            try {
-                await file.writeFile(JSON.stringify(committed, null, 2));
-                await file.sync();
-            }
-            finally {
-                await file.close();
-            }
-            await rename(temporary, this.path);
-            return committed;
-        }
-        finally {
-            await lock.close();
-            await rm(lockPath, { force: true });
-        }
-    }
-    async recordCandidate(release) {
-        return await this.update(current => {
-            const existing = current.releases[release.releaseId];
-            const record = existing ?? {
-                releaseId: release.releaseId,
-                releaseRoot: release.releaseRoot,
-                packageVersion: release.packageVersion,
-                contentDigest: release.contentDigest,
-                approval: "candidate",
-                materializedAt: new Date().toISOString(),
-                certifiedAt: null,
-                diagnosticsPath: null,
-            };
-            return {
-                ...current,
-                releases: { ...current.releases, [release.releaseId]: record },
-                references: {
-                    ...current.references,
-                    pending: current.references.active === release.releaseId ? current.references.pending : release.releaseId,
-                    retention: unique([...current.references.retention, release.releaseId]),
-                },
-                activation: activation("pending", "candidate awaits certification and safe activation"),
-            };
-        });
-    }
-    async approve(releaseId, diagnosticsPath) {
-        return await this.update(current => {
-            const release = requiredRelease(current, releaseId);
-            return {
-                ...current,
-                releases: { ...current.releases, [releaseId]: { ...release, approval: "approved", certifiedAt: new Date().toISOString(), diagnosticsPath } },
-                references: { ...current.references, approved: releaseId, pending: current.references.active === releaseId ? null : releaseId },
-            };
-        });
-    }
-    async activate(releaseId) {
-        return await this.update(current => {
-            const release = requiredRelease(current, releaseId);
-            if (release.approval !== "approved")
-                throw new Error(`cannot activate unverified release ${releaseId}`);
-            const prior = current.references.active;
-            return {
-                ...current,
-                references: {
-                    active: releaseId,
-                    pending: null,
-                    approved: releaseId,
-                    rollback: prior && prior !== releaseId ? prior : current.references.rollback,
-                    retention: unique([...current.references.retention, releaseId, ...(prior ? [prior] : [])]),
-                },
-                activation: activation("idle", null),
-            };
-        });
-    }
-    async blockPending(reason, blockerGenerationIds) {
-        return await this.update(current => ({ ...current, activation: { ...activation("blocked", reason), blockerGenerationIds: [...blockerGenerationIds] } }));
-    }
-    async rollback(ownershipReleased) {
-        if (!ownershipReleased)
-            throw new Error("cannot roll back before current cohort ownership is released");
-        return await this.update(current => {
-            const rollbackId = current.references.rollback;
-            if (!rollbackId)
-                throw new Error("no rollback release is recorded");
-            const rollback = requiredRelease(current, rollbackId);
-            if (rollback.approval !== "approved")
-                throw new Error(`cannot roll back to unverified release ${rollbackId}`);
-            return {
-                ...current,
-                references: {
-                    ...current.references,
-                    active: rollbackId,
-                    pending: null,
-                    approved: rollbackId,
-                    rollback: current.references.active,
-                    retention: unique([...current.references.retention, rollbackId, ...(current.references.active ? [current.references.active] : [])]),
-                },
-                activation: activation("idle", null),
-            };
-        });
-    }
-    async setRetention(releaseIds) {
-        return await this.update(current => {
-            for (const releaseId of releaseIds)
-                requiredRelease(current, releaseId);
-            return { ...current, references: { ...current.references, retention: unique(releaseIds) } };
-        });
-    }
-    async removeUnreferencedRelease(releaseId, externalReferences) {
-        return await this.update(current => {
-            requiredRelease(current, releaseId);
-            const protectedIds = new Set([
-                current.references.active,
-                current.references.pending,
-                current.references.approved,
-                current.references.rollback,
-                ...current.references.retention,
-                ...externalReferences,
-            ].filter((value) => value !== null));
-            if (protectedIds.has(releaseId))
-                throw new Error(`release ${releaseId} is still referenced and cannot be collected`);
-            const releases = { ...current.releases };
-            delete releases[releaseId];
-            return { ...current, releases };
-        });
-    }
-}
-export function emptyState() {
-    return {
-        schema: RELEASE_COHORT_SCHEMA,
-        revision: 0,
-        releases: {},
-        references: { active: null, pending: null, approved: null, rollback: null, retention: [] },
-        activation: activation("idle", null),
-    };
-}
-function activation(state, reason) {
-    return { state, reason, blockerGenerationIds: [], updatedAt: new Date().toISOString() };
-}
-function requiredRelease(state, releaseId) {
-    const release = state.releases[releaseId];
-    if (!release)
-        throw new Error(`unknown release ${releaseId}`);
-    return release;
-}
-function unique(values) { return [...new Set(values)]; }
-async function acquireLock(path) {
-    const deadline = Date.now() + 5_000;
-    while (true) {
-        try {
-            return await open(path, "wx", 0o600);
-        }
-        catch (error) {
-            if (!(error instanceof Error && "code" in error && error.code === "EEXIST") || Date.now() >= deadline)
-                throw error;
-            await new Promise(resolvePromise => setTimeout(resolvePromise, 20));
-        }
-    }
-}
-function validateState(state) {
-    if (state.schema !== RELEASE_COHORT_SCHEMA || !Number.isSafeInteger(state.revision) || state.revision < 0)
-        throw new Error("invalid release cohort state");
-    for (const reference of [state.references.active, state.references.pending, state.references.approved, state.references.rollback]) {
-        if (reference !== null && !state.releases[reference])
-            throw new Error(`release reference points to an unknown release: ${reference}`);
-    }
-}
-function validateTransition(current, next) {
-    validateState(next);
-    if (next.schema !== current.schema)
-        throw new Error("release cohort schema cannot change during a state update");
-    if (next.revision !== current.revision)
-        throw new Error("release cohort revision is controlled by the state store");
-}

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

@@ -1,5 +0,0 @@
-import { CohortStateStore } from "./cohort-state.js";
-/** Remove only a release that has no active, pending, approval, rollback,
- * retention, process, agent, or migration reference. State is detached first;
- * a filesystem failure can leave a safe orphan but never a dangling selector. */
-export declare function collectRelease(store: CohortStateStore, dataDir: string, releaseId: string, externalReferences: readonly string[]): Promise<void>;

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

@@ -1,16 +0,0 @@
-import { rm } from "node:fs/promises";
-import { resolve } from "node:path";
-import { CohortStateStore } from "./cohort-state.js";
-import { verifyMaterializedRelease } from "./release-store.js";
-/** Remove only a release that has no active, pending, approval, rollback,
- * retention, process, agent, or migration reference. State is detached first;
- * a filesystem failure can leave a safe orphan but never a dangling selector. */
-export async function collectRelease(store, dataDir, releaseId, externalReferences) {
-    const state = await store.read();
-    const release = state.releases[releaseId];
-    if (!release)
-        throw new Error(`unknown release ${releaseId}`);
-    await verifyMaterializedRelease(release.releaseRoot, undefined, resolve(dataDir, "releases"));
-    await store.removeUnreferencedRelease(releaseId, externalReferences);
-    await rm(release.releaseRoot, { recursive: true, force: false });
-}

package/dist/src/foundation/supervision/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./main.js";
-export * from "./server.js";
-export { resolveProductPaths, type ProductPaths } from "../lifecycle/index.js";

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

@@ -1,3 +0,0 @@
-export * from "./main.js";
-export * from "./server.js";
-export { resolveProductPaths } from "../lifecycle/index.js";

package/dist/src/foundation/supervision/main.d.ts

@@ -1 +0,0 @@
-export declare function runSupervisor(): Promise<void>;

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

@@ -1,41 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { appendFileSync, mkdirSync } from "node:fs";
-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";
-import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
-export async function runSupervisor() {
-    const paths = resolveProductPaths();
-    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];
-    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 readCertifiedReleaseManifest({ releaseRoot, releaseId, contentDigest }, resolve(paths.dataDir, "releases"));
-    await assertImmutableExecutionRoot(release, paths.dataDir);
-    const bootNonce = randomUUID();
-    const store = new ControlStore(paths.databasePath, bootNonce);
-    const server = new SupervisorServer(store, paths, release, bootNonce);
-    await server.listen();
-    log(`supervisor ${server.id} listening at ${paths.endpoint} (pid ${process.pid})`);
-    let closing = false;
-    const close = async (signal) => {
-        if (closing)
-            return;
-        closing = true;
-        log(`received ${signal}; stopping supervised process tree`);
-        await server.close(true);
-        process.exitCode = 0;
-    };
-    process.on("SIGINT", () => void close("SIGINT"));
-    process.on("SIGTERM", () => void close("SIGTERM"));
-    process.on("uncaughtException", error => {
-        log(`uncaught exception: ${error.stack ?? error.message}`);
-        process.exitCode = 1;
-    });
-    process.on("unhandledRejection", error => log(`unhandled rejection: ${String(error)}`));
-}

package/dist/src/foundation/supervision/paths.d.ts

@@ -1 +0,0 @@
-export { resolveProductPaths, type ProductPaths } from "../lifecycle/index.js";

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

@@ -1 +0,0 @@
-export { resolveProductPaths } from "../lifecycle/index.js";

package/dist/src/foundation/ui-components/spans.d.ts

@@ -1,7 +0,0 @@
-/**
- * Replaces the visible columns `[from, to)` of `line` with `span`, preserving
- * the styling before it and re-asserting whatever was still open afterwards, so
- * the tail keeps the colour it had. A wide character straddling either edge is
- * replaced by spaces rather than split.
- */
-export declare function overlaySpan(line: string, from: number, to: number, span: string): string;

package/dist/src/foundation/ui-components/spans.js

@@ -1,59 +0,0 @@
-import { displayWidth } from "./text.js";
-/**
- * Ported from the A1 UI reference implementation (`core/presentation/spans.ts`).
- * Writing over part of a rendered row is not string slicing: the row carries
- * styling and hyperlink sequences, and cutting through them either loses the
- * styling of the tail or leaks the span's own reset into it.
- */
-const ANSI_SEQUENCE = "\\u001b(?:\\[[0-?]*[ -/]*[@-~]|[\\]_][^\\u0007\\u001b]*(?:\\u0007|\\u001b\\\\|$))";
-const ANSI_SPLIT = new RegExp(`(${ANSI_SEQUENCE})`);
-const HYPERLINK = /^\]8;;([^]*)(?:|\\)?$/;
-const HYPERLINK_OFF = "]8;;\\";
-const GRAPHEMES = new Intl.Segmenter(undefined, { granularity: "grapheme" });
-/**
- * Replaces the visible columns `[from, to)` of `line` with `span`, preserving
- * the styling before it and re-asserting whatever was still open afterwards, so
- * the tail keeps the colour it had. A wide character straddling either edge is
- * replaced by spaces rather than split.
- */
-export function overlaySpan(line, from, to, span) {
-    let head = "";
-    let replay = "";
-    let tail = "";
-    let column = 0;
-    let hyperlinkOpen = false;
-    for (const token of line.split(ANSI_SPLIT)) {
-        if (!token)
-            continue;
-        if (token.startsWith("")) {
-            if (column >= to) {
-                tail += token;
-                continue;
-            }
-            if (column < from) {
-                head += token;
-                const link = HYPERLINK.exec(token);
-                if (link)
-                    hyperlinkOpen = (link[1] ?? "").length > 0;
-            }
-            // Re-assert everything still active: the span's own reset clobbers the tail.
-            replay += token;
-            continue;
-        }
-        for (const { segment } of GRAPHEMES.segment(token)) {
-            const width = displayWidth(segment);
-            if (column + width <= from)
-                head += segment;
-            else if (column >= to)
-                tail += segment;
-            else if (column < from)
-                head += " ".repeat(from - column);
-            else if (column + width > to)
-                tail += " ".repeat(column + width - to);
-            column += width;
-        }
-    }
-    if (column < from)
-        head += " ".repeat(from - column);
-    return head + (hyperlinkOpen ? HYPERLINK_OFF : "") + span + replay + tail;
-}

package/docs/manual-transparent-checkpoint.md

@@ -1,53 +0,0 @@
-# Manual owned-UI and transparent fallback checkpoint
-
-This checkpoint is user-controlled. Tests and coding agents must not launch or focus a terminal, inject desktop input, resize windows, close applications, or clean up workstation processes.
-
-## Prepare an exact candidate
-
-From the candidate checkout, pack once and install that tarball into a disposable prefix:
-
-```powershell
-npm ci
-npm run build
-npm pack --ignore-scripts --pack-destination artifacts/manual-transparent
-npm install --prefix artifacts/manual-transparent/install --ignore-scripts artifacts/manual-transparent/<exact-tarball>.tgz
-```
-
-Use isolated A1 control state:
-
-```powershell
-$manualRoot = (Resolve-Path "artifacts/manual-transparent").Path
-$env:A1_CONFIG_DIR = "$manualRoot\state\config"
-$env:A1_DATA_DIR = "$manualRoot\state\data"
-$env:A1_RUNTIME_DIR = "$manualRoot\state\runtime"
-$env:A1_DATABASE_PATH = "$manualRoot\state\data\control.sqlite3"
-```
-
-Run the installed candidate yourself:
-
-```powershell
-& "artifacts/manual-transparent/install/node_modules/.bin/a1.cmd"
-```
-
-Test each installed launch form separately: bare `a1` (the owned UI), `a1 pi` (the untouched comparison oracle), and `a1 sandbox` (the unchanged isolated vanilla profile). Confirm that files created through `/settings`, `/login`, sessions, and resource directories remain under the selected profile root. Generic transparent-fallback testing may set `A1_TERMINAL_EXECUTABLE` and a JSON array in `A1_TERMINAL_ARGUMENTS_JSON`.
-
-Physical automation is not part of this repository baseline. Future certification tooling may run only on dedicated disposable workers or VMs with exclusive test desktops, never on this workstation.
-
-## Compare bare A1 with `a1 pi`
-
-Use the same terminal, working directory, dimensions, environment, and equivalent profile resources. Bare A1 and the untouched oracle intentionally use separate profile roots.
-
-- [ ] Startup resources, logo, notices, spacing, editor, and footer match.
-- [ ] Text, Unicode, emoji, styles, cursor, and layout match.
-- [ ] Rapid typing has no visible A1 delay or dropped/duplicated characters.
-- [ ] Ctrl+C, Ctrl+P, arrows, paste, focus, dialogs, mouse, and wheel match.
-- [ ] Selection, copy, clipboard, scrollback, and resize match.
-- [ ] Normal and error exits preserve child output and return a usable parent prompt.
-- [ ] Parent typing, cursor movement, Backspace, Delete, and submission work after exit.
-- [ ] A missing executable reports a concise spawn failure without affecting other applications.
-
-Report failures with direct-versus-A1 behavior, platform/terminal versions, exact command, reproducibility, and optional manually captured evidence.
-
-For recovery, use `a1 pi`; do not use the removed `a1 ui` command. `a1 sandbox` remains profile isolation rather than a security boundary.
-
-Manual acceptance can authorize an exact uncertified npm `next` preview after non-desktop gates pass. It does not certify stable terminal parity or platform support.