@timurproko/a1 0.1.8-dev.49ff83a → 0.1.8-dev.508

package/dist/src/foundation/structured-agent-runtime/reconnection.js

@@ -1,129 +0,0 @@
-import { WORKSPACE_CONTRACT_VERSION, assertRecoveryAuthority, assertStructuredAgentSnapshot, assertStructuredCapability, } from "../workspace-contracts/index.js";
-import { StructuredEventReducer } from "./state.js";
-export class StructuredReconnectionManager {
-    #capability;
-    #acceptedBoundaries = new Set();
-    constructor(capability) {
-        assertStructuredCapability(capability);
-        this.#capability = capability;
-    }
-    resume(authorityValue, proof, reducer = null) {
-        let authority;
-        try {
-            assertRecoveryAuthority(authorityValue);
-            authority = authorityValue;
-        }
-        catch (error) {
-            return rejected("invalid-authority", error);
-        }
-        if (authority.kind !== "structured")
-            return rejected("invalid-authority", new Error("structured reconnection requires structured recovery authority"));
-        if (this.#capability.resume === "none") {
-            return { kind: "terminated", reason: "non-reconnectable", diagnostic: "adapter did not negotiate reconnection; durable agent is ended after restart" };
-        }
-        if (this.#capability.resume !== authority.boundary.kind) {
-            return rejected("unsupported-resume", new Error(`persisted ${authority.boundary.kind} recovery is unavailable from negotiated ${this.#capability.resume} resume`));
-        }
-        const identityError = verifyIdentity(authority, proof);
-        if (identityError)
-            return identityError;
-        if (proof.protocolVersion !== WORKSPACE_CONTRACT_VERSION) {
-            return rejected("version-mismatch", new Error(`resume protocol ${proof.protocolVersion} does not match supported version ${WORKSPACE_CONTRACT_VERSION}`));
-        }
-        if (proof.boundary.kind !== authority.boundary.kind) {
-            return rejected("boundary-mismatch", new Error("resume proof boundary does not match the persisted recovery boundary"));
-        }
-        const boundaryKey = boundaryKeyOf(authority.boundary);
-        if (this.#acceptedBoundaries.has(boundaryKey)) {
-            return rejected("replay-detected", new Error("structured recovery boundary has already been accepted"));
-        }
-        if (authority.boundary.kind === "position") {
-            if (proof.boundary.kind !== "position")
-                return rejected("boundary-mismatch", new Error("position resume requires a position proof"));
-            if (proof.boundary.position !== authority.boundary.position) {
-                return rejected("boundary-mismatch", new Error("resume position does not match the persisted recovery boundary"));
-            }
-            if (proof.boundary.resumeToken !== authority.boundary.resumeToken) {
-                return rejected("stale-token", new Error("resume token does not match the persisted recovery boundary"));
-            }
-            let view = null;
-            if (reducer) {
-                const restored = restorePosition(reducer, authority.agentId, proof.boundary.position);
-                if (isRejected(restored))
-                    return restored;
-                view = restored;
-            }
-            this.#acceptedBoundaries.add(boundaryKey);
-            return { kind: "accepted", boundary: authority.boundary, view, diagnostic: "structured resume position verified" };
-        }
-        if (proof.boundary.kind !== "snapshot")
-            return rejected("boundary-mismatch", new Error("snapshot resume requires a snapshot proof"));
-        if (proof.boundary.snapshotId !== authority.boundary.snapshotId) {
-            return rejected("stale-token", new Error("resume snapshot identity does not match the persisted recovery boundary"));
-        }
-        if (payloadBytes(proof.boundary.snapshot.payload) > this.#capability.flow.maxSnapshotBytes) {
-            return rejected("snapshot-too-large", new Error(`resume snapshot exceeds the negotiated ${this.#capability.flow.maxSnapshotBytes} byte limit`));
-        }
-        const snapshotResult = verifySnapshot(authority.agentId, proof.boundary.snapshotId, proof.boundary.snapshot);
-        if (snapshotResult)
-            return snapshotResult;
-        if (reducer) {
-            const applied = reducer.replaceWithSnapshot(proof.boundary.snapshot);
-            if (applied.kind !== "snapshot-applied") {
-                return rejected("snapshot-recovery-failed", new Error(`snapshot recovery failed: ${applied.kind}`));
-            }
-            this.#acceptedBoundaries.add(boundaryKey);
-            return { kind: "accepted", boundary: authority.boundary, view: applied.view, diagnostic: "structured snapshot recovery verified" };
-        }
-        this.#acceptedBoundaries.add(boundaryKey);
-        return { kind: "accepted", boundary: authority.boundary, view: null, diagnostic: "structured snapshot recovery verified" };
-    }
-}
-function verifyIdentity(authority, proof) {
-    if (proof.agentId !== authority.agentId)
-        return rejected("agent-mismatch", new Error("resume proof agent does not match the durable agent identity"));
-    if (proof.adapterId !== authority.adapterId)
-        return rejected("adapter-mismatch", new Error("resume proof adapter does not match the durable adapter identity"));
-    if (proof.processIdentity !== authority.processIdentity)
-        return rejected("process-mismatch", new Error("resume proof process does not match verified process ownership"));
-    if (proof.ownershipProof !== authority.ownershipProof)
-        return rejected("proof-mismatch", new Error("resume ownership proof does not match the persisted authority"));
-    return null;
-}
-function verifySnapshot(agentId, snapshotId, snapshot) {
-    try {
-        assertStructuredAgentSnapshot(snapshot);
-    }
-    catch (error) {
-        return rejected("invalid-snapshot", error);
-    }
-    if (snapshot.snapshotId !== snapshotId)
-        return rejected("invalid-snapshot", new Error("snapshot payload identity does not match the resume boundary"));
-    if (snapshot.agentId !== agentId)
-        return rejected("agent-mismatch", new Error("snapshot payload agent does not match the durable agent identity"));
-    return null;
-}
-function restorePosition(reducer, agentId, position) {
-    if (reducer.agentId !== agentId)
-        return rejected("agent-mismatch", new Error("resume reducer agent does not match the durable agent identity"));
-    try {
-        return reducer.restoreResumeBoundary(position);
-    }
-    catch (error) {
-        return rejected("invalid-authority", error);
-    }
-}
-function boundaryKeyOf(boundary) {
-    return boundary.kind === "position"
-        ? `position:${boundary.position}:${boundary.resumeToken}`
-        : `snapshot:${boundary.snapshotId}`;
-}
-function isRejected(value) {
-    return "kind" in value && value.kind === "rejected";
-}
-function payloadBytes(payload) {
-    return new TextEncoder().encode(JSON.stringify(payload)).byteLength;
-}
-function rejected(code, error) {
-    return { kind: "rejected", code, diagnostic: error instanceof Error ? error.message : String(error) };
-}

package/dist/src/foundation/structured-agent-runtime/state.d.ts

@@ -1,56 +0,0 @@
-import { type StructuredAgentSnapshot, type StructuredCapabilityContract, type WorkspaceEvent } from "../workspace-contracts/index.js";
-export type StructuredAgentEvent = Extract<WorkspaceEvent, {
-    readonly type: "structured-event";
-}>;
-export interface StructuredRuntimeView {
-    readonly agentId: string;
-    readonly revision: number;
-    readonly lastAppliedPosition: number | null;
-    readonly nextEventPosition: number;
-    readonly appliedEventCount: number;
-    readonly lastEventType: string | null;
-    readonly lastEventPayload: unknown;
-    readonly snapshotId: string | null;
-    readonly snapshotPayload: unknown;
-}
-export type StructuredEventApplyResult = {
-    readonly kind: "applied";
-    readonly view: StructuredRuntimeView;
-} | {
-    readonly kind: "duplicate";
-    readonly view: StructuredRuntimeView;
-    readonly duplicatePosition: number;
-} | {
-    readonly kind: "resynchronization-required";
-    readonly view: StructuredRuntimeView;
-    readonly expectedPosition: number;
-    readonly receivedPosition: number;
-    readonly recovery: "snapshot" | "none";
-} | {
-    readonly kind: "rejected";
-    readonly code: string;
-    readonly diagnostic: string;
-};
-export type StructuredSnapshotApplyResult = {
-    readonly kind: "snapshot-applied";
-    readonly view: StructuredRuntimeView;
-} | {
-    readonly kind: "snapshot-stale";
-    readonly view: StructuredRuntimeView;
-    readonly currentPosition: number;
-    readonly snapshotPosition: number;
-} | {
-    readonly kind: "rejected";
-    readonly code: string;
-    readonly diagnostic: string;
-};
-export declare class StructuredEventReducer {
-    #private;
-    readonly agentId: string;
-    constructor(agentId: string, capability: StructuredCapabilityContract);
-    applyEvent(event: StructuredAgentEvent): StructuredEventApplyResult;
-    replaceWithSnapshot(snapshot: StructuredAgentSnapshot): StructuredSnapshotApplyResult;
-    restoreResumeBoundary(position: number): StructuredRuntimeView;
-    nextEventPosition(): number;
-    view(): StructuredRuntimeView;
-}

package/dist/src/foundation/structured-agent-runtime/state.js

@@ -1,118 +0,0 @@
-import { assertStructuredAgentSnapshot, assertStructuredCapability, assertWorkspaceEvent, } from "../workspace-contracts/index.js";
-export class StructuredEventReducer {
-    agentId;
-    #capability;
-    #lastAppliedPosition = null;
-    #appliedEventCount = 0;
-    #revision = 0;
-    #lastEventType = null;
-    #lastEventPayload = null;
-    #snapshotId = null;
-    #snapshotPayload = null;
-    constructor(agentId, capability) {
-        this.agentId = agentId;
-        assertStructuredCapability(capability);
-        if (!agentId || agentId.includes("\0"))
-            throw new TypeError("structured reducer agent id is invalid");
-        this.#capability = capability;
-    }
-    applyEvent(event) {
-        try {
-            assertWorkspaceEvent(event);
-        }
-        catch (error) {
-            return rejected("malformed-event", error);
-        }
-        if (event.agentId !== this.agentId) {
-            return rejected("agent-mismatch", new Error("structured event agent does not match the reducer identity"));
-        }
-        if (!this.#capability.eventTypes.includes(event.eventType)) {
-            return rejected("unsupported-event-type", new Error(`structured event type is not negotiated: ${event.eventType}`));
-        }
-        if (payloadBytes(event.payload) > this.#capability.flow.maxEventBytes) {
-            return rejected("event-too-large", new Error(`structured event exceeds the negotiated ${this.#capability.flow.maxEventBytes} byte limit`));
-        }
-        const nextPosition = this.nextEventPosition();
-        if (event.position < nextPosition) {
-            return { kind: "duplicate", view: this.view(), duplicatePosition: event.position };
-        }
-        if (event.position > nextPosition) {
-            return {
-                kind: "resynchronization-required",
-                view: this.view(),
-                expectedPosition: nextPosition,
-                receivedPosition: event.position,
-                recovery: this.#capability.snapshots === "authoritative" ? "snapshot" : "none",
-            };
-        }
-        this.#lastAppliedPosition = event.position;
-        this.#appliedEventCount += 1;
-        this.#lastEventType = event.eventType;
-        this.#lastEventPayload = event.payload;
-        this.#revision += 1;
-        return { kind: "applied", view: this.view() };
-    }
-    replaceWithSnapshot(snapshot) {
-        if (this.#capability.snapshots !== "authoritative") {
-            return rejected("snapshots-unsupported", new Error("the negotiated adapter capability does not provide authoritative snapshots"));
-        }
-        try {
-            assertStructuredAgentSnapshot(snapshot);
-        }
-        catch (error) {
-            return rejected("malformed-snapshot", error);
-        }
-        if (snapshot.agentId !== this.agentId) {
-            return rejected("agent-mismatch", new Error("structured snapshot agent does not match the reducer identity"));
-        }
-        if (payloadBytes(snapshot.payload) > this.#capability.flow.maxSnapshotBytes) {
-            return rejected("snapshot-too-large", new Error(`structured snapshot exceeds the negotiated ${this.#capability.flow.maxSnapshotBytes} byte limit`));
-        }
-        const currentPosition = this.#lastAppliedPosition;
-        if (currentPosition !== null && snapshot.position < currentPosition) {
-            return { kind: "snapshot-stale", view: this.view(), currentPosition, snapshotPosition: snapshot.position };
-        }
-        this.#lastAppliedPosition = snapshot.position;
-        this.#appliedEventCount = 0;
-        this.#lastEventType = null;
-        this.#lastEventPayload = null;
-        this.#snapshotId = snapshot.snapshotId;
-        this.#snapshotPayload = snapshot.payload;
-        this.#revision += 1;
-        return { kind: "snapshot-applied", view: this.view() };
-    }
-    restoreResumeBoundary(position) {
-        if (!Number.isSafeInteger(position) || position < 0)
-            throw new RangeError("structured resume position must be a non-negative safe integer");
-        this.#lastAppliedPosition = position;
-        this.#appliedEventCount = 0;
-        this.#lastEventType = null;
-        this.#lastEventPayload = null;
-        this.#snapshotId = null;
-        this.#snapshotPayload = null;
-        this.#revision += 1;
-        return this.view();
-    }
-    nextEventPosition() {
-        return this.#lastAppliedPosition === null ? 0 : this.#lastAppliedPosition + 1;
-    }
-    view() {
-        return Object.freeze({
-            agentId: this.agentId,
-            revision: this.#revision,
-            lastAppliedPosition: this.#lastAppliedPosition,
-            nextEventPosition: this.nextEventPosition(),
-            appliedEventCount: this.#appliedEventCount,
-            lastEventType: this.#lastEventType,
-            lastEventPayload: this.#lastEventPayload,
-            snapshotId: this.#snapshotId,
-            snapshotPayload: this.#snapshotPayload,
-        });
-    }
-}
-function rejected(code, error) {
-    return { kind: "rejected", code, diagnostic: error instanceof Error ? error.message : String(error) };
-}
-function payloadBytes(payload) {
-    return new TextEncoder().encode(JSON.stringify(payload)).byteLength;
-}

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/supervision/server.d.ts

@@ -1,22 +0,0 @@
-import { type SupervisorSnapshot } from "../lifecycle/index.js";
-import { type MaterializedRelease } from "../release/index.js";
-import { ControlStore } from "../storage/index.js";
-import { type ProductPaths } from "./paths.js";
-export declare class SupervisorServer {
-    #private;
-    readonly store: ControlStore;
-    readonly release: MaterializedRelease;
-    readonly terminateProcess: (code: number) => void;
-    readonly reconciliationDeadlineMs: number;
-    readonly shutdownDeadlineMs: number;
-    readonly id: `${string}-${string}-${string}-${string}-${string}`;
-    readonly bootNonce: string;
-    readonly pidStartIdentity: string;
-    readonly startedAt: string;
-    readonly paths: ProductPaths;
-    constructor(store: ControlStore, paths: ProductPaths | undefined, release: MaterializedRelease, bootNonce?: string, terminateProcess?: (code: number) => void, reconciliationDeadlineMs?: number, shutdownDeadlineMs?: number);
-    snapshot(): SupervisorSnapshot;
-    listen(): Promise<void>;
-    close(stopAgents?: boolean): Promise<void>;
-    closeForReleaseReplacement(stopAgents: boolean): Promise<void>;
-}