@wrenai/genbi 0.0.4 → 0.0.5

package/dist-server/server/runtime-host/codex-conversation.d.ts

@@ -0,0 +1,109 @@
+import { type CodexAppServerBackend, type CodexLaunchPermit } from "./codex-app-server.js";
+import { type CodexEvent } from "./codex-events.js";
+import type { CodexSession } from "./codex-session.js";
+import type { RuntimeBackendReasonCode } from "./types.js";
+export type ConversationState = "opening" | "ready" | "running" | "closing" | "closed" | "failed";
+export type ConversationFailure = "unavailable" | "protocol" | "timeout" | "cancelled" | "cleanup" | "delivery";
+export declare class CodexConversationError extends Error {
+    readonly code: ConversationFailure | "attachment" | "busy" | "input" | "closed";
+    readonly backendReason?: RuntimeBackendReasonCode<"codex-app-server"> | undefined;
+    constructor(code: ConversationFailure | "attachment" | "busy" | "input" | "closed", backendReason?: RuntimeBackendReasonCode<"codex-app-server"> | undefined);
+}
+type ConversationEvent = Exclude<CodexEvent, {
+    method: "command/exec/outputDelta" | "remoteControl/status/changed" | "thread/started";
+}>;
+export type ConversationFrame = {
+    readonly type: "event";
+    readonly sequence: number;
+    readonly event: ConversationEvent;
+} | {
+    readonly type: "state";
+    readonly sequence: number;
+    readonly state: ConversationState;
+    readonly failure?: ConversationFailure;
+    readonly backendReason?: RuntimeBackendReasonCode<"codex-app-server">;
+};
+export interface ConversationReplay {
+    readonly type: "replay";
+    readonly afterSequence: number;
+    readonly throughSequence: number;
+    readonly truncated: boolean;
+    readonly retainedBytes: number;
+    readonly retentionLimitBytes: number;
+    readonly state: ConversationState;
+    readonly failure?: ConversationFailure;
+    readonly backendReason?: RuntimeBackendReasonCode<"codex-app-server">;
+}
+export interface CodexConversationAttachment {
+    submit(text: string): Promise<{
+        readonly turnId: string;
+        readonly status: "completed" | "interrupted" | "failed";
+    }>;
+    interrupt(): Promise<void>;
+    steer?(text: string, expectedTurnId: string): Promise<{
+        turnId: string;
+    }>;
+    detach(): void;
+}
+type Driver = Pick<CodexSession, "startThread" | "runTurn" | "interruptTurn" | "close" | "onFailure"> & Partial<Pick<CodexSession, "steerTurn">>;
+type OpenInput = Omit<Parameters<CodexAppServerBackend["open"]>[1], "onEvent">;
+interface Backend {
+    open(permit: CodexLaunchPermit, input: OpenInput & {
+        onEvent(event: CodexEvent): void;
+    }): Promise<Driver>;
+}
+interface Attachment {
+    readonly listener: (frame: ConversationFrame | ConversationReplay) => void;
+    readonly queue: string[];
+    queuedBytes: number;
+    draining: boolean;
+}
+/**
+ * Process-local Phase 5 bridge, not an application activation path.
+ * The host obtains the permit before durable writes and owns scope materialization.
+ * Browser code receives only attachment methods and projected frames, never a driver.
+ */
+export declare class CodexConversation {
+    private readonly onState?;
+    readonly capability: `${string}-${string}-${string}-${string}-${string}`;
+    readonly ready: Promise<void>;
+    private state;
+    private failed?;
+    private backendReason;
+    private sequence;
+    private retainedBytes;
+    private frames;
+    private owner;
+    private driver?;
+    private threadId?;
+    private readonly connection;
+    private closing?;
+    private detachFailure?;
+    private active;
+    private interrupting;
+    private turnStarted;
+    private rejectStopped;
+    private readonly stopped;
+    constructor(backend: Backend, permit: CodexLaunchPermit, input: OpenInput, onState?: ((state: ConversationState, failure?: ConversationFailure) => void) | undefined);
+    snapshot(): {
+        state: ConversationState;
+        failure?: ConversationFailure;
+        backendReason?: RuntimeBackendReasonCode<"codex-app-server">;
+        sequence: number;
+    };
+    private initialize;
+    /** Host-only identity for the official terminal adapter; never a resume grant. */
+    terminalThreadId(): string;
+    private receive;
+    private transition;
+    private record;
+    private deliveryFailed;
+    private drain;
+    attach(capability: string, listener: Attachment["listener"], afterSequence?: number): CodexConversationAttachment;
+    private submit;
+    private interrupt;
+    /** Detach retains the conversation; the Sessions lease owner decides when to close. */
+    close(): Promise<void>;
+    private finish;
+}
+export {};

package/dist-server/server/runtime-host/codex-conversation.js

@@ -0,0 +1,295 @@
+import { randomUUID, timingSafeEqual } from "node:crypto";
+import { CodexBackendError } from "./codex-app-server.js";
+import { parseCodexEvent } from "./codex-events.js";
+import { CodexRpcError } from "./codex-rpc.js";
+export class CodexConversationError extends Error {
+    code;
+    backendReason;
+    constructor(code, backendReason) {
+        super("Codex conversation: " + code);
+        this.code = code;
+        this.backendReason = backendReason;
+    }
+}
+const MAX_BYTES = 1_048_576;
+const MAX_FRAMES = 256;
+function failure(error) {
+    if (error instanceof CodexConversationError && ["protocol", "timeout", "cancelled", "cleanup", "delivery"].includes(error.code))
+        return error.code;
+    if (error instanceof CodexBackendError && error.code === "codex_app_server_cleanup_failed")
+        return "cleanup";
+    if (error instanceof CodexRpcError) {
+        if (error.reason === "cleanup" || error.reason === "timeout" || error.reason === "cancelled")
+            return error.reason;
+        return "protocol";
+    }
+    return "unavailable";
+}
+/**
+ * Process-local Phase 5 bridge, not an application activation path.
+ * The host obtains the permit before durable writes and owns scope materialization.
+ * Browser code receives only attachment methods and projected frames, never a driver.
+ */
+export class CodexConversation {
+    onState;
+    capability = randomUUID();
+    ready;
+    state = "opening";
+    failed;
+    backendReason;
+    sequence = 0;
+    retainedBytes = 0;
+    frames = [];
+    owner;
+    driver;
+    threadId;
+    connection;
+    closing;
+    detachFailure;
+    active;
+    interrupting;
+    turnStarted = false;
+    rejectStopped;
+    stopped = new Promise((_, reject) => { this.rejectStopped = reject; });
+    constructor(backend, permit, input, onState) {
+        this.onState = onState;
+        void this.stopped.catch(() => { });
+        // Defer open until ownership of both promises exists; synchronous fake peers
+        // and early events must obey the same lifecycle as the production backend.
+        this.connection = Promise.resolve().then(() => {
+            if (this.state !== "opening")
+                throw new CodexConversationError("closed");
+            permit.assertActive();
+            return backend.open(permit, { ...input, onEvent: (event) => this.receive(event) });
+        }).then((driver) => {
+            this.driver = driver;
+            this.detachFailure = driver.onFailure((error) => {
+                if (this.state !== "closing" && this.state !== "closed" && this.state !== "failed") {
+                    void this.finish(failure(error)).catch(() => { });
+                }
+            });
+            return driver;
+        }).catch((error) => {
+            if (error instanceof CodexBackendError)
+                this.backendReason = error.code;
+            permit.release();
+            throw error;
+        });
+        this.ready = this.initialize();
+        void this.ready.catch(() => { });
+    }
+    snapshot() {
+        return { state: this.state, ...(this.failed ? { failure: this.failed } : {}),
+            ...(this.backendReason ? { backendReason: this.backendReason } : {}), sequence: this.sequence };
+    }
+    async initialize() {
+        try {
+            const driver = await this.connection;
+            if (this.state !== "opening")
+                throw new CodexConversationError("closed");
+            this.threadId = await driver.startThread();
+            if (this.state !== "opening")
+                throw new CodexConversationError("closed");
+            this.transition("ready");
+            if (this.snapshot().state !== "ready")
+                throw new CodexConversationError("closed");
+        }
+        catch (error) {
+            await this.finish(failure(error));
+            throw new CodexConversationError(this.failed ?? (this.closing ? "closed" : failure(error)), this.backendReason);
+        }
+    }
+    /** Host-only identity for the official terminal adapter; never a resume grant. */
+    terminalThreadId() {
+        if (!this.threadId || !["ready", "running"].includes(this.state))
+            throw new CodexConversationError("closed");
+        return this.threadId;
+    }
+    receive(value) {
+        if (this.state === "closing" || this.state === "closed" || this.state === "failed")
+            return;
+        try {
+            const event = parseCodexEvent(value.method, value.params);
+            if (event.method === "command/exec/outputDelta" || event.method === "remoteControl/status/changed" || event.method === "thread/started") {
+                throw new CodexConversationError("protocol");
+            }
+            if (event.method === "turn/started")
+                this.turnStarted = true;
+            this.record({ type: "event", sequence: ++this.sequence, event });
+        }
+        catch {
+            void this.finish("protocol").catch(() => { });
+            throw new CodexConversationError("protocol");
+        }
+    }
+    transition(state, code) {
+        this.state = state;
+        if (code)
+            this.failed = code;
+        this.onState?.(state, this.failed);
+        this.record({ type: "state", sequence: ++this.sequence, state, ...(this.failed ? { failure: this.failed } : {}),
+            ...(this.backendReason ? { backendReason: this.backendReason } : {}) });
+    }
+    record(frame) {
+        const json = JSON.stringify(frame);
+        const bytes = Buffer.byteLength(json);
+        if (bytes > MAX_BYTES)
+            throw new CodexConversationError("protocol");
+        this.frames.push({ sequence: frame.sequence, json, bytes });
+        this.retainedBytes += bytes;
+        while (this.frames.length > MAX_FRAMES || this.retainedBytes > MAX_BYTES) {
+            this.retainedBytes -= this.frames.shift().bytes;
+        }
+        if (this.owner) {
+            if (this.owner.queue.length >= MAX_FRAMES + 1 || this.owner.queuedBytes + bytes > MAX_BYTES + 4096) {
+                this.deliveryFailed();
+                return;
+            }
+            this.owner.queue.push(json);
+            this.owner.queuedBytes += bytes;
+            this.drain(this.owner);
+        }
+    }
+    deliveryFailed() {
+        this.owner = undefined;
+        void this.finish("delivery").catch(() => { });
+    }
+    drain(owner) {
+        if (owner.draining)
+            return;
+        owner.draining = true;
+        try {
+            // Reentrant live events append behind the captured replay, never inside it.
+            let delivered = 0;
+            while (this.owner === owner && owner.queue.length) {
+                if (++delivered > MAX_FRAMES * 2 + 1) {
+                    this.deliveryFailed();
+                    break;
+                }
+                const json = owner.queue.shift();
+                owner.queuedBytes -= Buffer.byteLength(json);
+                owner.listener(JSON.parse(json));
+            }
+        }
+        catch {
+            this.deliveryFailed();
+        }
+        finally {
+            owner.draining = false;
+        }
+    }
+    attach(capability, listener, afterSequence = 0) {
+        if (typeof capability !== "string" || capability.length !== this.capability.length)
+            throw new CodexConversationError("attachment");
+        const supplied = Buffer.from(capability);
+        const expected = Buffer.from(this.capability);
+        if (supplied.length !== expected.length || !timingSafeEqual(supplied, expected) || this.owner || typeof listener !== "function")
+            throw new CodexConversationError("attachment");
+        if (!Number.isSafeInteger(afterSequence) || afterSequence < 0 || afterSequence > this.sequence)
+            throw new CodexConversationError("input");
+        const replay = { type: "replay", afterSequence, throughSequence: this.sequence,
+            truncated: afterSequence < (this.frames[0]?.sequence ?? 1) - 1,
+            retainedBytes: this.retainedBytes, retentionLimitBytes: MAX_BYTES, state: this.state,
+            ...(this.failed ? { failure: this.failed } : {}), ...(this.backendReason ? { backendReason: this.backendReason } : {}) };
+        const queue = [JSON.stringify(replay), ...this.frames.filter((frame) => frame.sequence > afterSequence).map((frame) => frame.json)];
+        const owner = { listener, queue, queuedBytes: queue.reduce((sum, json) => sum + Buffer.byteLength(json), 0), draining: false };
+        this.owner = owner;
+        const assertOwner = () => { if (this.owner !== owner)
+            throw new CodexConversationError("attachment"); };
+        const handle = Object.freeze({
+            submit: (text) => { assertOwner(); return this.submit(text); },
+            interrupt: () => { assertOwner(); return this.interrupt(); },
+            steer: (text, expectedTurnId) => {
+                assertOwner();
+                if (this.state !== "running" || !this.active || !this.turnStarted || !this.driver?.steerTurn)
+                    throw new CodexConversationError("closed");
+                return this.driver.steerTurn(text, expectedTurnId);
+            },
+            detach: () => { if (this.owner === owner)
+                this.owner = undefined; },
+        });
+        this.drain(owner);
+        return handle;
+    }
+    submit(text) {
+        if (this.active)
+            throw new CodexConversationError("busy");
+        if (this.state !== "ready" || !this.driver)
+            throw new CodexConversationError("closed");
+        if (typeof text !== "string" || !text.trim() || Buffer.byteLength(text) > 262_144)
+            throw new CodexConversationError("input");
+        const driver = this.driver;
+        this.turnStarted = false;
+        const active = Promise.resolve().then(async () => {
+            if (this.state !== "running")
+                throw new CodexConversationError("closed");
+            const result = await Promise.race([driver.runTurn(text, { timeoutMs: 300_000 }), this.stopped]);
+            if (result.status === "inProgress")
+                throw new CodexConversationError("protocol");
+            return { turnId: result.id, status: result.status };
+        }).catch(async (error) => {
+            await this.finish(failure(error));
+            throw new CodexConversationError(this.failed ?? (error instanceof CodexConversationError ? error.code : failure(error)));
+        }).finally(() => {
+            this.active = undefined;
+            this.interrupting = undefined;
+            if (this.state === "running")
+                this.transition("ready");
+        });
+        this.active = active;
+        void active.catch(() => { });
+        this.transition("running");
+        return active;
+    }
+    interrupt() {
+        if (!this.active || this.state !== "running" || !this.driver)
+            throw new CodexConversationError("closed");
+        // Before turn/start is acknowledged there is no interruptible vendor ID.
+        // Closing the owned connection cancels that early window without guessing it.
+        if (!this.turnStarted)
+            return this.finish("cancelled");
+        const active = this.active;
+        this.interrupting ??= this.driver.interruptTurn().then(async () => { await active; }).catch(async (error) => {
+            await this.finish(failure(error));
+            throw new CodexConversationError(this.failed ?? failure(error));
+        });
+        void this.interrupting.catch(() => { });
+        return this.interrupting;
+    }
+    /** Detach retains the conversation; the Sessions lease owner decides when to close. */
+    close() { return this.finish(); }
+    finish(code) {
+        if (this.closing)
+            return this.closing;
+        if (code)
+            this.failed = code;
+        this.state = "closing";
+        this.rejectStopped(new CodexConversationError(code ?? "closed"));
+        this.closing = Promise.resolve().then(async () => {
+            try {
+                let driver;
+                try {
+                    driver = await this.connection;
+                }
+                catch (error) {
+                    if (failure(error) === "cleanup")
+                        throw error;
+                }
+                await driver?.close();
+                this.detachFailure?.();
+                this.transition(this.failed ? "failed" : "closed");
+            }
+            catch {
+                this.backendReason = "codex_app_server_cleanup_failed";
+                this.detachFailure?.();
+                this.transition("failed", "cleanup");
+                throw new CodexConversationError("cleanup", this.backendReason);
+            }
+            finally {
+                this.owner = undefined;
+            }
+        });
+        void this.closing.catch(() => { });
+        return this.closing;
+    }
+}

package/dist-server/server/runtime-host/codex-direct-tools.d.ts

@@ -0,0 +1,23 @@
+import { type NativeComponentBindings } from "../native-component-preparation.js";
+/** Host-only connection authority. Neither its identity nor credentials enter tool arguments. */
+export interface CodexSessionTools {
+    readonly accountEmail: string;
+    readonly definitions: readonly {
+        readonly name: string;
+        readonly description: string;
+        readonly inputSchema: unknown;
+    }[];
+    assertCurrent(): void;
+    call(name: string, input: unknown, callId: string, signal: AbortSignal): Promise<unknown>;
+    close(): Promise<void>;
+}
+/** Materializes only a verified host plan. No vendor config, .codex directory, or MCP endpoint. */
+export declare function prepareCodexDirectTools(options: {
+    readonly irDocument: string;
+    readonly scope: Readonly<Record<string, unknown>>;
+    readonly bindings: NativeComponentBindings;
+    readonly producerBinary: string;
+    readonly accountEmail: string;
+    readonly expiresAt: number;
+    readonly signal: AbortSignal;
+}): Promise<CodexSessionTools>;

package/dist-server/server/runtime-host/codex-direct-tools.js

@@ -0,0 +1,59 @@
+import { createHash } from "node:crypto";
+import { execFile } from "node:child_process";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { z } from "zod";
+import { planDigest, readExecutionPlan } from "../../harness/components/plan.js";
+import { prepareDirectCodexComponentHost } from "../native-component-preparation.js";
+import { NativeComponentAdmission } from "../native-components.js";
+/** Materializes only a verified host plan. No vendor config, .codex directory, or MCP endpoint. */
+export async function prepareCodexDirectTools(options) {
+    const { irDocument, accountEmail, expiresAt, signal } = options;
+    if (!accountEmail.trim() || !Number.isSafeInteger(expiresAt) || expiresAt <= Date.now())
+        throw new Error("Direct session authority expired");
+    const prepared = prepareDirectCodexComponentHost(irDocument, options.scope, options.bindings);
+    const check = () => { signal.throwIfAborted(); if (Date.now() >= expiresAt)
+        throw new Error("Direct session authority expired"); prepared.assertCurrent(); };
+    check();
+    const root = Object.keys(prepared.hostRoots)[0];
+    const hostDocument = JSON.stringify(prepared.hostRoots[root]);
+    const ir = z.object({ context_binding: z.record(z.string(), z.unknown()), components: z.array(z.object({ id: z.string() }).passthrough()) }).passthrough().parse(JSON.parse(irDocument));
+    const directory = await mkdtemp(path.join(os.tmpdir(), "genbi-direct-plan-"));
+    try {
+        await writeFile(path.join(directory, "ir.json"), irDocument, { mode: 0o600 });
+        await writeFile(path.join(directory, "host.json"), hostDocument, { mode: 0o600 });
+        check();
+        await promisify(execFile)(options.producerBinary, ["produce-session", path.join(directory, "ir.json"), "--component", root,
+            "--host-contract", path.join(directory, "host.json"), "--out", path.join(directory, "plan.json")], { cwd: directory, env: { PATH: [path.dirname(process.execPath), "/usr/bin", "/bin"].join(path.delimiter) }, timeout: 30_000, maxBuffer: 1_048_576, signal });
+        check();
+        const document = await readFile(path.join(directory, "plan.json"), "utf8");
+        const digest = z.object({ plan_sha256: z.string().regex(/^sha256:[a-f0-9]{64}$/) }).parse(JSON.parse(document)).plan_sha256;
+        const plan = readExecutionPlan(document, { digest, inputIrDigest: `sha256:${createHash("sha256").update(irDocument).digest("hex")}`,
+            contextBinding: ir.context_binding, declarations: Object.fromEntries(ir.components.map((node) => [node.id, node])), directHostDocument: hostDocument });
+        if (plan.entries.length !== 1 || plan.entries[0] !== root)
+            throw new Error("Direct session entry mismatch");
+        const name = `warble_run_${planDigest({ identity: prepared.identity, plan: plan.identity }).slice(7, 39)}`;
+        const admission = new NativeComponentAdmission({ identity: prepared.identity, digest: plan.identity, roots: { [root]: plan }, tools: { [root]: name } }, () => { check(); return prepared.identity; }, prepared.host);
+        const lifetime = new AbortController();
+        const timeout = setTimeout(() => lifetime.abort(), Math.min(expiresAt - Date.now(), 2_147_483_647));
+        timeout.unref();
+        const combined = AbortSignal.any([signal, lifetime.signal]);
+        let closing;
+        const close = () => { lifetime.abort(); clearTimeout(timeout); return closing ??= admission.close(); };
+        combined.addEventListener("abort", () => { void close().catch(() => { }); }, { once: true });
+        const current = () => { combined.throwIfAborted(); check(); };
+        const definitions = Object.freeze(admission.list().map((tool) => Object.freeze({ ...tool, inputSchema: structuredClone(tool.inputSchema) })));
+        return Object.freeze({ accountEmail, definitions, assertCurrent: current,
+            async call(tool, input, callId, parent) {
+                current();
+                const result = await admission.call(tool, input, callId, AbortSignal.any([combined, parent]));
+                current();
+                return result;
+            }, close });
+    }
+    finally {
+        await rm(directory, { recursive: true, force: true });
+    }
+}