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

package/dist/src/foundation/protocol/client.js

@@ -1,129 +0,0 @@
-import { EventEmitter } from "node:events";
-import { connect } from "node:net";
-import { randomUUID } from "node:crypto";
-import { CONTROL_ENVELOPE, CONTROL_ENVELOPE_REVISION, encodeFrame, LineFrameDecoder, localControlHello, negotiateControlFeatures } from "./messages.js";
-export class SupervisorClient extends EventEmitter {
-    clientId = randomUUID();
-    releaseId;
-    constructor(releaseId) {
-        super();
-        if (releaseId !== undefined)
-            this.releaseId = releaseId;
-    }
-    #socket = null;
-    #pending = new Map();
-    async connect(endpoint, timeoutMs = 5_000) {
-        if (this.#socket)
-            throw new Error("client is already connected");
-        const deadline = Date.now() + timeoutMs;
-        let lastError = null;
-        while (Date.now() < deadline) {
-            try {
-                return await this.#connectOnce(endpoint, Math.max(1, deadline - Date.now()));
-            }
-            catch (error) {
-                lastError = error instanceof Error ? error : new Error(String(error));
-                if (!isTransientEndpointError(lastError))
-                    throw lastError;
-                await new Promise(resolve => setTimeout(resolve, Math.min(40, Math.max(1, deadline - Date.now()))));
-            }
-        }
-        throw new Error(`supervisor endpoint ${endpoint} remained unavailable for ${timeoutMs}ms`, { cause: lastError ?? undefined });
-    }
-    #connectOnce(endpoint, timeoutMs) {
-        const socket = connect(endpoint);
-        this.#socket = socket;
-        socket.setNoDelay(true);
-        const decoder = new LineFrameDecoder();
-        return new Promise((resolve, reject) => {
-            let welcomed = false;
-            const timeout = setTimeout(() => {
-                const error = transientError(`supervisor connection timed out after ${timeoutMs}ms`, "ETIMEDOUT");
-                fail(error);
-                socket.destroy();
-            }, timeoutMs);
-            const fail = (error) => {
-                clearTimeout(timeout);
-                if (!welcomed)
-                    reject(error);
-            };
-            socket.once("error", fail);
-            socket.on("close", () => {
-                if (this.#socket === socket)
-                    this.#socket = null;
-                if (!welcomed) {
-                    fail(transientError("supervisor disconnected before completing its handshake", "ECONNRESET"));
-                    return;
-                }
-                for (const pending of this.#pending.values())
-                    pending.reject(new Error("supervisor disconnected"));
-                this.#pending.clear();
-                this.emit("disconnect");
-            });
-            socket.on("data", chunk => {
-                try {
-                    for (const value of decoder.push(chunk)) {
-                        const message = value;
-                        if (message.type === "server-hello" && message.snapshot) {
-                            const hello = message;
-                            if (hello.envelope !== CONTROL_ENVELOPE || hello.envelopeRevision !== CONTROL_ENVELOPE_REVISION || !Array.isArray(hello.requiredFeatures) || !Array.isArray(hello.optionalFeatures) || typeof hello.contractDigest !== "string") {
-                                fail(new Error("supervisor returned an invalid control handshake"));
-                                socket.destroy();
-                                continue;
-                            }
-                            const negotiation = negotiateControlFeatures(localControlHello(this.releaseId), hello);
-                            if (!negotiation.ok) {
-                                fail(new Error(negotiation.diagnostic));
-                                socket.destroy();
-                                continue;
-                            }
-                            welcomed = true;
-                            clearTimeout(timeout);
-                            resolve(message.snapshot);
-                        }
-                        else if (message.type === "snapshot" && message.snapshot) {
-                            this.emit("snapshot", message.snapshot);
-                        }
-                        else if (message.type === "command-result" && message.result) {
-                            const pending = this.#pending.get(message.result.requestId);
-                            if (pending) {
-                                this.#pending.delete(message.result.requestId);
-                                pending.resolve(message.result);
-                            }
-                        }
-                        else if (message.type === "stop-launch-instance" && message.instanceId && message.requestId && message.reason) {
-                            this.emit("stopIntent", message);
-                        }
-                        else if (message.type === "protocol-error") {
-                            fail(new Error(message.message ?? "protocol error"));
-                        }
-                    }
-                }
-                catch (error) {
-                    fail(error instanceof Error ? error : new Error(String(error)));
-                    socket.destroy();
-                }
-            });
-            socket.once("connect", () => socket.write(encodeFrame({ type: "client-hello", clientId: this.clientId, ...localControlHello(this.releaseId) })));
-        });
-    }
-    command(command) {
-        if (!this.#socket)
-            return Promise.reject(new Error("supervisor is not connected"));
-        return new Promise((resolve, reject) => {
-            this.#pending.set(command.requestId, { resolve, reject });
-            this.#socket?.write(encodeFrame({ type: "command", command }));
-        });
-    }
-    close() {
-        this.#socket?.end();
-        this.#socket = null;
-    }
-}
-function isTransientEndpointError(error) {
-    const code = "code" in error ? String(error.code) : "";
-    return ["ENOENT", "ECONNREFUSED", "ECONNRESET", "EPIPE", "ETIMEDOUT"].includes(code);
-}
-function transientError(message, code) {
-    return Object.assign(new Error(message), { code });
-}

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

@@ -1,2 +0,0 @@
-export * from "./client.js";
-export * from "./messages.js";

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

@@ -1,2 +0,0 @@
-export * from "./client.js";
-export * from "./messages.js";

package/dist/src/foundation/protocol/messages.d.ts

@@ -1,89 +0,0 @@
-import type { CommandResult, LaunchInstanceStopIntent, SupervisorCommand, SupervisorSnapshot } from "../lifecycle/index.js";
-export declare const CONTROL_ENVELOPE: string;
-export declare const CONTROL_ENVELOPE_REVISION: 1;
-export declare const REQUIRED_CONTROL_FEATURES: readonly ["handshake.features.v1", "snapshot.revision.v1", "commands.request-identity.v1", "generation.lifecycle.v1", "launch.instance-lifecycle.v1"];
-export declare const OPTIONAL_CONTROL_FEATURES: readonly ["messages.unknown-additive-ignore.v1", "snapshot.resynchronize.v1"];
-export type ControlFeature = string;
-export declare const GENERATED_CONTRACT_DIGEST: string;
-export declare const MAX_CONTROL_FRAME_BYTES: number;
-export interface ControlHello {
-    readonly envelope: typeof CONTROL_ENVELOPE;
-    readonly envelopeRevision: typeof CONTROL_ENVELOPE_REVISION;
-    readonly requiredFeatures: readonly ControlFeature[];
-    readonly optionalFeatures: readonly ControlFeature[];
-    readonly contractDigest: string;
-    readonly releaseId?: string;
-}
-export type ClientMessage = {
-    readonly type: "identity-probe";
-} | {
-    readonly type: "release-idle-ownership";
-    readonly bootNonce: string;
-    readonly candidateReleaseId: string;
-} | {
-    readonly type: "release-update-ownership";
-    readonly bootNonce: string;
-    readonly targetVersion: string;
-} | ({
-    readonly type: "client-hello";
-    readonly clientId: string;
-} & ControlHello) | {
-    readonly type: "command";
-    readonly command: SupervisorCommand;
-};
-export type ServerMessage = {
-    readonly type: "identity";
-    readonly supervisorId: string;
-    readonly bootNonce: string;
-    readonly pidStartIdentity: string;
-    readonly releaseId: string;
-} | {
-    readonly type: "release-ownership-result";
-    readonly released: boolean;
-    readonly reason: string;
-    readonly liveInstanceIds: readonly string[];
-} | {
-    readonly type: "release-update-result";
-    readonly accepted: boolean;
-    readonly reason: string;
-    readonly liveInstanceIds: readonly string[];
-} | ({
-    readonly type: "server-hello";
-    readonly supervisorId: string;
-    readonly bootNonce: string;
-    readonly pidStartIdentity: string;
-    readonly negotiatedFeatures: readonly string[];
-    readonly snapshot: SupervisorSnapshot;
-} & ControlHello) | {
-    readonly type: "snapshot";
-    readonly snapshot: SupervisorSnapshot;
-} | {
-    readonly type: "command-result";
-    readonly result: CommandResult;
-} | LaunchInstanceStopIntent | {
-    readonly type: "protocol-error";
-    readonly code: string;
-    readonly message: string;
-    readonly diagnostics?: unknown;
-};
-export interface ControlNegotiation {
-    readonly ok: boolean;
-    readonly negotiatedFeatures: readonly string[];
-    readonly missingFromClient: readonly string[];
-    readonly missingFromServer: readonly string[];
-    readonly diagnostic: string;
-}
-export declare function localControlHello(releaseId?: string): ControlHello;
-export declare function negotiateControlFeatures(client: ControlHello, server?: ControlHello): ControlNegotiation;
-export declare function encodeFrame(message: ClientMessage | ServerMessage | Readonly<Record<string, unknown>>): string;
-export declare class LineFrameDecoder {
-    #private;
-    push(chunk: Buffer | string): unknown[];
-}
-export declare function isControlHello(value: unknown): value is {
-    readonly type: "client-hello";
-    readonly clientId: string;
-} & ControlHello;
-export declare function isCommandMessage(value: unknown): value is Extract<ClientMessage, {
-    type: "command";
-}>;

package/dist/src/foundation/protocol/messages.js

@@ -1,99 +0,0 @@
-import { createHash } from "node:crypto";
-import { PRODUCT_IDENTITY } from "../../product-identity.js";
-export const CONTROL_ENVELOPE = PRODUCT_IDENTITY.protocol.controlEnvelope;
-export const CONTROL_ENVELOPE_REVISION = 1;
-export const REQUIRED_CONTROL_FEATURES = [
-    "handshake.features.v1",
-    "snapshot.revision.v1",
-    "commands.request-identity.v1",
-    "generation.lifecycle.v1",
-    "launch.instance-lifecycle.v1",
-];
-export const OPTIONAL_CONTROL_FEATURES = [
-    "messages.unknown-additive-ignore.v1",
-    "snapshot.resynchronize.v1",
-];
-export const GENERATED_CONTRACT_DIGEST = createHash("sha256").update(JSON.stringify({
-    envelope: CONTROL_ENVELOPE,
-    revision: CONTROL_ENVELOPE_REVISION,
-    required: [...REQUIRED_CONTROL_FEATURES].sort(),
-    optional: [...OPTIONAL_CONTROL_FEATURES].sort(),
-})).digest("hex");
-export const MAX_CONTROL_FRAME_BYTES = 4 * 1024 * 1024;
-export function localControlHello(releaseId) {
-    return {
-        envelope: CONTROL_ENVELOPE,
-        envelopeRevision: CONTROL_ENVELOPE_REVISION,
-        requiredFeatures: REQUIRED_CONTROL_FEATURES,
-        optionalFeatures: OPTIONAL_CONTROL_FEATURES,
-        contractDigest: GENERATED_CONTRACT_DIGEST,
-        ...(releaseId ? { releaseId } : {}),
-    };
-}
-export function negotiateControlFeatures(client, server = localControlHello()) {
-    if (client.envelope !== server.envelope || client.envelopeRevision !== server.envelopeRevision) {
-        return {
-            ok: false,
-            negotiatedFeatures: [],
-            missingFromClient: [],
-            missingFromServer: [],
-            diagnostic: `control envelope mismatch: client ${client.envelope}/${client.envelopeRevision}; server ${server.envelope}/${server.envelopeRevision}`,
-        };
-    }
-    const clientFeatures = new Set([...client.requiredFeatures, ...client.optionalFeatures]);
-    const serverFeatures = new Set([...server.requiredFeatures, ...server.optionalFeatures]);
-    const missingFromClient = server.requiredFeatures.filter(feature => !clientFeatures.has(feature));
-    const missingFromServer = client.requiredFeatures.filter(feature => !serverFeatures.has(feature));
-    const negotiatedFeatures = [...clientFeatures].filter(feature => serverFeatures.has(feature)).sort();
-    return {
-        ok: missingFromClient.length === 0 && missingFromServer.length === 0,
-        negotiatedFeatures,
-        missingFromClient,
-        missingFromServer,
-        diagnostic: missingFromClient.length === 0 && missingFromServer.length === 0
-            ? `control features negotiated (${negotiatedFeatures.join(", ")}); contract client=${client.contractDigest} server=${server.contractDigest}`
-            : `required control features unavailable; client missing [${missingFromClient.join(", ")}], server missing [${missingFromServer.join(", ")}]; contract client=${client.contractDigest} server=${server.contractDigest}`,
-    };
-}
-export function encodeFrame(message) {
-    return `${JSON.stringify(message)}\n`;
-}
-export class LineFrameDecoder {
-    #buffer = "";
-    push(chunk) {
-        this.#buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
-        if (Buffer.byteLength(this.#buffer, "utf8") > MAX_CONTROL_FRAME_BYTES) {
-            this.#buffer = "";
-            throw new Error("control frame exceeds maximum size");
-        }
-        const messages = [];
-        let newline = this.#buffer.indexOf("\n");
-        while (newline >= 0) {
-            const line = this.#buffer.slice(0, newline);
-            this.#buffer = this.#buffer.slice(newline + 1);
-            if (line.length > 0)
-                messages.push(JSON.parse(line));
-            newline = this.#buffer.indexOf("\n");
-        }
-        return messages;
-    }
-}
-export function isControlHello(value) {
-    if (!isRecord(value) || value.type !== "client-hello" || typeof value.clientId !== "string")
-        return false;
-    return value.envelope === CONTROL_ENVELOPE
-        && value.envelopeRevision === CONTROL_ENVELOPE_REVISION
-        && isStringArray(value.requiredFeatures)
-        && isStringArray(value.optionalFeatures)
-        && typeof value.contractDigest === "string"
-        && (value.releaseId === undefined || typeof value.releaseId === "string");
-}
-export function isCommandMessage(value) {
-    return isRecord(value) && value.type === "command" && isRecord(value.command) && typeof value.command.type === "string";
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null;
-}
-function isStringArray(value) {
-    return Array.isArray(value) && value.every(item => typeof item === "string" && item.length > 0);
-}

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

@@ -1,29 +0,0 @@
-import { type OwnershipProbe } from "./cohort-selection.js";
-import { type SupervisorEndpointMetadata } from "./cohort-state.js";
-import { type LaunchProfileId } from "../lifecycle/index.js";
-import { cleanupProvenIdleOwner } from "./process-cleanup.js";
-import { type MaterializedRelease, type VerifyMaterializedReleaseOptions } from "./release-store.js";
-export interface BootstrapOptions {
-    readonly packageRoot: string;
-    readonly launchIntent?: {
-        readonly kind: "interactive";
-        readonly profile: {
-            readonly id: LaunchProfileId;
-        };
-    };
-    readonly environment?: NodeJS.ProcessEnv;
-    readonly output?: Pick<NodeJS.WriteStream, "write">;
-}
-export declare function runBootstrap(options: BootstrapOptions): Promise<number>;
-export declare function certifyMaterializedRelease(release: MaterializedRelease, dataDir: string, verification?: VerifyMaterializedReleaseOptions): Promise<string>;
-export declare function startSupervisor(release: MaterializedRelease, environment: NodeJS.ProcessEnv): Promise<void>;
-export declare function releaseEnvironment(environment: NodeJS.ProcessEnv, release: MaterializedRelease): NodeJS.ProcessEnv;
-export declare function waitForVerifiedEndpoint(path: string, release: MaterializedRelease, timeoutMs: number): Promise<void>;
-export declare function readEndpointMetadata(path: string): Promise<SupervisorEndpointMetadata | null>;
-export declare function probeOwnership(metadata: SupervisorEndpointMetadata): Promise<OwnershipProbe>;
-export declare function releaseVerifiedIdleOwner(metadata: SupervisorEndpointMetadata, dataDir: string, operations?: {
-    readonly waitForExit?: typeof waitForProcessExit;
-    readonly cleanup?: typeof cleanupProvenIdleOwner;
-}): Promise<boolean>;
-export declare function waitForProcessExit(pid: number, timeoutMs: number): Promise<void>;
-export declare function removeEndpointArtifacts(metadataPath: string, endpoint: string): Promise<void>;