@astrosheep/keiyaku 2.8.4 → 2.9.0

package/build/agents/providers/codex-app-server/events.js

@@ -0,0 +1,352 @@
+import { boundActivityExcerpt, diffstatFromUnifiedPatch } from "../../harness/activity-values.js";
+import { AGENT_PLAN_ITEM_TEXT_MAX_CHARS, AGENT_PLAN_MAX_ITEMS, AGENT_THOUGHT_TEXT_MAX_CHARS, } from "../../harness/events.js";
+import { createAbortError, emitProviderEvidence, coerceString } from "../../harness/runtime.js";
+const CODEX_APP_SERVER_PROVIDER = "codex-app-server";
+const CODEX_APP_SERVER_NOTIFICATION_ACKNOWLEDGED = new Set([
+    "item/agentMessage/delta",
+    "item/commandExecution/outputDelta",
+    "item/fileChange/outputDelta",
+    "item/reasoning/summaryTextDelta",
+    "item/reasoning/summaryPartAdded",
+    "item/reasoning/textDelta",
+]);
+const CODEX_APP_SERVER_NOTIFICATION_MAPPED = new Set([
+    "item/completed",
+    "turn/started",
+    "turn/completed",
+    "error",
+]);
+export function codexAppServerNotificationDisposition(method) {
+    if (CODEX_APP_SERVER_NOTIFICATION_ACKNOWLEDGED.has(method))
+        return "acknowledged-unpersisted";
+    if (CODEX_APP_SERVER_NOTIFICATION_MAPPED.has(method))
+        return "mapped";
+    return "unknown";
+}
+export function appServerRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+const CODEX_APP_SERVER_ACTIVITY_ITEM_TYPES = [
+    "commandExecution",
+    "fileChange",
+    "webSearch",
+    "mcpToolCall",
+];
+function isCodexAppServerActivityItemType(value) {
+    return CODEX_APP_SERVER_ACTIVITY_ITEM_TYPES.includes(value);
+}
+export function appServerActivityCall(itemType, item) {
+    switch (itemType) {
+        case "commandExecution":
+            return typeof item.command === "string"
+                ? {
+                    kind: "run",
+                    command: item.command,
+                    ...(typeof item.description === "string" && item.description ? { description: item.description } : {}),
+                }
+                : { kind: "other", display: itemType };
+        case "fileChange": {
+            const changes = Array.isArray(item.changes)
+                ? item.changes.flatMap((entry) => {
+                    const change = appServerRecord(entry);
+                    if (!change || typeof change.path !== "string")
+                        return [];
+                    if (change.kind !== "add" && change.kind !== "update" && change.kind !== "delete")
+                        return [];
+                    const op = change.kind;
+                    return [{ op, path: change.path }];
+                })
+                : [];
+            if (changes.length > 0)
+                return { kind: "fileChange", changes };
+            return { kind: "other", display: typeof item.path === "string" ? `fileChange ${item.path}` : itemType };
+        }
+        case "webSearch":
+            return typeof item.query === "string" ? { kind: "search", query: item.query } : { kind: "other", display: itemType };
+        case "mcpToolCall":
+            return typeof item.server === "string" && typeof item.tool === "string"
+                ? { kind: "other", display: `${item.server}.${item.tool}` }
+                : { kind: "other", display: itemType };
+    }
+}
+export function appServerActivityResult(item) {
+    const exitCode = typeof item.exitCode === "number" && Number.isFinite(item.exitCode) ? item.exitCode : undefined;
+    const message = typeof item.aggregatedOutput === "string" && item.aggregatedOutput
+        ? boundActivityExcerpt(item.aggregatedOutput)
+        : typeof item.output === "string" && item.output
+            ? boundActivityExcerpt(item.output)
+            : typeof item.error === "string" && item.error
+                ? boundActivityExcerpt(item.error)
+                : undefined;
+    const details = item.details !== null && typeof item.details === "object" && !Array.isArray(item.details)
+        ? item.details
+        : undefined;
+    const patch = typeof details?.patch === "string" ? details.patch : undefined;
+    const diffstat = patch ? diffstatFromUnifiedPatch(patch) : undefined;
+    return {
+        status: item.status === "failed" || (exitCode !== undefined && exitCode !== 0) ? "error" : "ok",
+        ...(message ? { message } : {}),
+        ...(exitCode === undefined ? {} : { exitCode }),
+        ...(diffstat ? { diffstat } : {}),
+    };
+}
+export function extractReasoningSummary(item) {
+    const summary = item.summary;
+    const text = typeof summary === "string"
+        ? summary
+        : Array.isArray(summary)
+            ? summary.map((part) => {
+                if (typeof part === "string")
+                    return part;
+                if (!part || typeof part !== "object")
+                    return "";
+                const record = part;
+                if (record.type !== "summary_text" && record.type !== "text")
+                    return "";
+                return typeof record.text === "string" ? record.text : "";
+            }).join("\n")
+            : "";
+    return text.trim().length > 0 ? text : undefined;
+}
+export function extractPlanItems(item) {
+    if (!Array.isArray(item.items))
+        return [];
+    return item.items.slice(0, AGENT_PLAN_MAX_ITEMS).flatMap((value) => {
+        if (!value || typeof value !== "object")
+            return [];
+        const record = value;
+        if (typeof record.text !== "string" || record.text.trim().length === 0)
+            return [];
+        return [{
+                text: record.text.slice(0, AGENT_PLAN_ITEM_TEXT_MAX_CHARS),
+                done: record.completed === true || record.done === true,
+                ...(record.active === true ? { active: true } : {}),
+            }];
+    });
+}
+export function createCodexAppServerTurnState() {
+    return {
+        responseSeenTurnIds: new Set(),
+        completedBeforeResponseTurnIds: new Set(),
+        activeTurnAcceptingSteer: false,
+        lastAgentMessage: "",
+    };
+}
+export function recordActiveTurnId(state, candidate, source) {
+    const turnId = coerceString(candidate);
+    if (!turnId)
+        throw new Error(`${CODEX_APP_SERVER_PROVIDER} ${source} omitted active turn id`);
+    if (!state.activeTurnId) {
+        state.activeTurnId = turnId;
+        state.activeTurnSource = source;
+        return turnId;
+    }
+    if (state.activeTurnId !== turnId) {
+        throw new Error(`${CODEX_APP_SERVER_PROVIDER} active turn id mismatch: ${state.activeTurnSource ?? "first"}=${state.activeTurnId}, ${source}=${turnId}`);
+    }
+    return state.activeTurnId;
+}
+export function recordTurnStartResponse(state, candidate) {
+    const turnId = coerceString(candidate);
+    if (!turnId)
+        throw new Error(`${CODEX_APP_SERVER_PROVIDER} response omitted active turn id`);
+    if (state.completedBeforeResponseTurnIds.delete(turnId))
+        return turnId;
+    state.responseSeenTurnIds.add(turnId);
+    return recordActiveTurnId(state, turnId, "response");
+}
+export function createCodexAppServerTurnMonitor(options) {
+    const { server, builder, state, builderDiagnostic, onEvidence, onSyncCheckpoint, onDeliveryOpportunity, enqueue, drainPendingTells, rejectPendingTells, setFailActiveTurn, pendingTellCount, isDrainingTells, setFinishAfterTellDrain, } = options;
+    const turnCompleted = new Promise((resolve, reject) => {
+        let unsubNotifications = () => { };
+        let unsubServerRequest = () => { };
+        let settled = false;
+        const failTurn = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            rejectPendingTells(error);
+            const message = error instanceof Error ? error.message : String(error);
+            builder.emit({ type: "diagnostic", text: message });
+            builder.emit({ type: "fail", message });
+            unsubNotifications();
+            unsubServerRequest();
+            reject(error);
+        };
+        const failServerRequest = (request) => {
+            // Policy A forbids interactive server→client requests. Fail immediately with named diagnostic.
+            const message = `${CODEX_APP_SERVER_PROVIDER} unexpected server request '${request.method}' (id=${String(request.id)}); non-interactive policy forbids server→client requests`;
+            failTurn(new Error(message));
+        };
+        const requestDeliveryOpportunity = () => {
+            try {
+                onDeliveryOpportunity?.({ enqueue });
+            }
+            catch {
+                // Delivery observation cannot alter provider control flow.
+            }
+        };
+        unsubServerRequest = server.onServerRequest((request) => {
+            try {
+                builder.ingress(CODEX_APP_SERVER_PROVIDER, request.method, request, "mapped", () => {
+                    failServerRequest(request);
+                });
+            }
+            finally {
+                requestDeliveryOpportunity();
+            }
+        });
+        unsubNotifications = server.onNotification((notification) => {
+            try {
+                builder.ingress(CODEX_APP_SERVER_PROVIDER, notification.method, notification, codexAppServerNotificationDisposition(notification.method), () => {
+                    if (notification.method === "item/agentMessage/delta") {
+                        const delta = coerceString(notification.params?.delta);
+                        if (delta) {
+                            state.lastAgentMessage = `${state.lastAgentMessage}${delta}`;
+                        }
+                    }
+                    if (notification.method === "item/completed") {
+                        const item = notification.params?.item;
+                        if (!item) {
+                            throw new Error(`${CODEX_APP_SERVER_PROVIDER} item/completed lacked required item`);
+                        }
+                        const id = coerceString(item.id);
+                        const itemType = coerceString(item.type);
+                        if (!id || !itemType) {
+                            throw new Error(`${CODEX_APP_SERVER_PROVIDER} item/completed lacked required item id or type`);
+                        }
+                        if (itemType === "agentMessage") {
+                            const text = coerceString(item.text);
+                            if (text) {
+                                state.lastAgentMessage = text;
+                                builder.emit({ type: "message", id, text });
+                            }
+                        }
+                        else if (itemType === "reasoning") {
+                            const text = extractReasoningSummary(item);
+                            if (text) {
+                                const truncated = text.length > AGENT_THOUGHT_TEXT_MAX_CHARS;
+                                builder.emit({
+                                    type: "thought",
+                                    id,
+                                    text: text.slice(0, AGENT_THOUGHT_TEXT_MAX_CHARS),
+                                    final: true,
+                                    ...(truncated ? { truncated: true } : {}),
+                                });
+                            }
+                        }
+                        else if (itemType === "todo_list" || itemType === "todoList") {
+                            builder.emit({
+                                type: "plan",
+                                id,
+                                items: extractPlanItems(item),
+                            });
+                        }
+                        else if (isCodexAppServerActivityItemType(itemType)) {
+                            builder.emit({
+                                type: "activity",
+                                phase: "completed",
+                                id,
+                                tool: itemType,
+                                call: appServerActivityCall(itemType, item),
+                                result: appServerActivityResult(item),
+                            });
+                        }
+                    }
+                    if (notification.method === "turn/started") {
+                        const turn = notification.params?.turn;
+                        const turnId = recordActiveTurnId(state, turn?.id, "notification");
+                        builder.emit({ type: "turn", phase: "started" });
+                        state.activeTurnAcceptingSteer = true;
+                        const checkpoint = { fence: { kind: "turn", turnId }, consumptionEvidence: false };
+                        if (onEvidence) {
+                            emitProviderEvidence(onEvidence, {
+                                type: "checkpoint",
+                                provider: CODEX_APP_SERVER_PROVIDER,
+                                fence: checkpoint.fence,
+                                source: "notification",
+                            }, builderDiagnostic);
+                        }
+                        // turn/start may respond before the server has installed its active
+                        // turn. The native notification is the first steer-safe boundary.
+                        onSyncCheckpoint?.({ enqueue }, checkpoint);
+                        void drainPendingTells();
+                    }
+                    if (notification.method === "turn/completed") {
+                        const turn = notification.params?.turn ?? {};
+                        const status = coerceString(turn.status) ?? "unknown";
+                        // Either response or notification may mint the turn fence first;
+                        // every later native source must agree with it.
+                        const turnId = recordActiveTurnId(state, turn.id, "notification");
+                        if (!state.responseSeenTurnIds.delete(turnId)) {
+                            state.completedBeforeResponseTurnIds.add(turnId);
+                        }
+                        // Public completed only for exact native status completed.
+                        if (status === "completed") {
+                            builder.emit({ type: "turn", phase: "completed" });
+                            // This must stay in the native notification call stack: the harness
+                            // checkpoint and its observer evidence describe this exact crossing.
+                            state.activeTurnAcceptingSteer = false;
+                            state.activeTurnId = undefined;
+                            state.activeTurnSource = undefined;
+                            const checkpoint = { fence: { kind: "turn", turnId }, consumptionEvidence: true };
+                            if (onEvidence) {
+                                emitProviderEvidence(onEvidence, {
+                                    type: "checkpoint",
+                                    provider: CODEX_APP_SERVER_PROVIDER,
+                                    fence: checkpoint.fence,
+                                    source: "notification",
+                                }, builderDiagnostic);
+                            }
+                            onSyncCheckpoint?.({ enqueue }, checkpoint);
+                            void drainPendingTells();
+                            if (pendingTellCount() > 0 || isDrainingTells()) {
+                                setFinishAfterTellDrain(() => {
+                                    if (settled || state.activeTurnId !== undefined || pendingTellCount() > 0)
+                                        return;
+                                    settled = true;
+                                    unsubNotifications();
+                                    unsubServerRequest();
+                                    resolve({ status, turn });
+                                });
+                                return;
+                            }
+                        }
+                        if (settled)
+                            return;
+                        settled = true;
+                        unsubNotifications();
+                        unsubServerRequest();
+                        resolve({ status, turn });
+                    }
+                    if (notification.method === "error") {
+                        const message = coerceString(notification.params?.message) ?? `${CODEX_APP_SERVER_PROVIDER} error`;
+                        builder.emit({ type: "diagnostic", text: message });
+                    }
+                });
+            }
+            catch (error) {
+                // Notification listeners run outside the driver's await chain;
+                // convert validation failures into the controlled completion path.
+                failTurn(error);
+            }
+            finally {
+                if (notification.method !== "turn/completed") {
+                    requestDeliveryOpportunity();
+                }
+            }
+        });
+        setFailActiveTurn(failTurn);
+        builder.signal.addEventListener("abort", () => {
+            unsubNotifications();
+            unsubServerRequest();
+            failTurn(createAbortError(`${CODEX_APP_SERVER_PROVIDER} exec cancelled by client`));
+        }, { once: true });
+    });
+    // Abort can settle this before initialization reaches the await below.
+    // Attach a handler immediately while preserving the original awaited error.
+    turnCompleted.catch(() => undefined);
+    return { turnCompleted };
+}

package/build/agents/providers/codex-app-server/session.js

@@ -0,0 +1,266 @@
+import { spawn } from "node:child_process";
+import { emitProviderEvidence, sha256Utf8 } from "../../harness/runtime.js";
+import { coerceString } from "../../harness/runtime.js";
+const CODEX_APP_SERVER_PROVIDER = "codex-app-server";
+export class CodexAppServerProcess {
+    onEvidence;
+    onEvidenceDiagnostic;
+    child;
+    pending = new Map();
+    notificationListeners = new Set();
+    serverRequestListeners = new Set();
+    exitPromise;
+    nextId = 1;
+    stdoutBuffer = "";
+    closed = false;
+    exitSettled = false;
+    gracefulClose;
+    forceClose;
+    codexHome;
+    constructor(executable, env, codexHome, onEvidence, onEvidenceDiagnostic) {
+        this.onEvidence = onEvidence;
+        this.onEvidenceDiagnostic = onEvidenceDiagnostic;
+        this.codexHome = codexHome;
+        const spawnEnv = {
+            ...env,
+            ...(codexHome ? { CODEX_HOME: codexHome } : {}),
+        };
+        this.child = spawn(executable, ["app-server", "--listen", "stdio://"], {
+            env: spawnEnv,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        if (this.onEvidence && this.child.pid)
+            emitProviderEvidence(this.onEvidence, { type: "process", provider: CODEX_APP_SERVER_PROVIDER, event: "spawn", pid: this.child.pid }, this.onEvidenceDiagnostic);
+        this.child.stdout.setEncoding("utf8");
+        this.child.stderr.setEncoding("utf8");
+        this.child.stdout.on("data", (chunk) => this.onStdout(chunk));
+        // Preserve the pre-evidence diagnostic stream exactly. Process evidence
+        // never retains stderr bytes, avoiding credential boundary ambiguity.
+        this.child.stderr.on("data", (chunk) => this.onEvidenceDiagnostic?.(chunk));
+        this.child.on("error", (error) => this.failAll(error));
+        this.exitPromise = new Promise((resolve) => {
+            this.child.once("close", (exitCode) => {
+                this.exitSettled = true;
+                this.closed = true;
+                // With no observer, retain the historical error bytes. Evidence adds
+                // structured exit facts without changing provider behavior.
+                this.failAll(new Error(`${CODEX_APP_SERVER_PROVIDER} process closed`));
+                if (this.onEvidence)
+                    emitProviderEvidence(this.onEvidence, { type: "process", provider: CODEX_APP_SERVER_PROVIDER, event: "exit", exitCode, stderrTail: "" }, this.onEvidenceDiagnostic);
+                resolve();
+            });
+        });
+    }
+    onNotification(listener) {
+        this.notificationListeners.add(listener);
+        return () => this.notificationListeners.delete(listener);
+    }
+    onServerRequest(listener) {
+        this.serverRequestListeners.add(listener);
+        return () => this.serverRequestListeners.delete(listener);
+    }
+    onStdout(chunk) {
+        this.stdoutBuffer += chunk;
+        let newline = this.stdoutBuffer.indexOf("\n");
+        while (newline >= 0) {
+            const line = this.stdoutBuffer.slice(0, newline).trim();
+            this.stdoutBuffer = this.stdoutBuffer.slice(newline + 1);
+            if (line.length > 0) {
+                this.handleLine(line);
+            }
+            newline = this.stdoutBuffer.indexOf("\n");
+        }
+    }
+    handleLine(line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (!message || typeof message !== "object")
+            return;
+        const record = message;
+        if ("id" in record && ("result" in record || "error" in record)) {
+            const id = record.id;
+            const pending = this.pending.get(id);
+            if (!pending)
+                return;
+            this.pending.delete(id);
+            if ("error" in record && record.error) {
+                const error = record.error;
+                pending.reject(new Error(error.message ?? `${CODEX_APP_SERVER_PROVIDER} RPC error`));
+                return;
+            }
+            pending.resolve(record.result);
+            return;
+        }
+        // Server→client request: method + id. Never ignore, auto-approve, or auto-deny (faye #316).
+        if (typeof record.method === "string" && "id" in record) {
+            const request = {
+                id: record.id,
+                method: record.method,
+                params: record.params ?? undefined,
+            };
+            for (const listener of this.serverRequestListeners) {
+                listener(request);
+            }
+            return;
+        }
+        if (typeof record.method === "string" && !("id" in record)) {
+            const notification = {
+                method: record.method,
+                params: record.params ?? undefined,
+            };
+            for (const listener of this.notificationListeners) {
+                listener(notification);
+            }
+        }
+    }
+    failAll(error) {
+        for (const pending of this.pending.values()) {
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+    request(method, params) {
+        if (this.closed) {
+            return Promise.reject(new Error(`${CODEX_APP_SERVER_PROVIDER} process is closed`));
+        }
+        const id = this.nextId++;
+        const payload = params === undefined ? { id, method } : { id, method, params };
+        const serialized = `${JSON.stringify(payload)}\n`;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.child.stdin.write(serialized, (error) => {
+                if (error) {
+                    this.pending.delete(id);
+                    reject(error);
+                }
+            });
+            // The write call above is the process boundary. Emitting afterward
+            // avoids evidence for a synchronous write failure while keeping the
+            // outbound fact before any asynchronous RPC acknowledgement.
+            this.emitOutbound(method, params);
+        });
+    }
+    notify(method, params) {
+        const payload = params === undefined ? { method } : { method, params };
+        this.child.stdin.write(`${JSON.stringify(payload)}\n`);
+    }
+    emitOutbound(method, params) {
+        if (!this.onEvidence)
+            return;
+        const kind = method === "thread/start" ? "thread-start" : method === "thread/resume" ? "thread-resume" : method === "turn/start" ? "turn-start" : method === "turn/steer" ? "steer" : undefined;
+        if (!kind)
+            return;
+        const text = method === "turn/steer"
+            ? coerceString((params?.input?.[0]?.text))
+            : JSON.stringify(params ?? {});
+        if (text === undefined)
+            return;
+        emitProviderEvidence(this.onEvidence, { type: "outbound", provider: CODEX_APP_SERVER_PROVIDER, direction: "request", kind, ...sha256Utf8(text) }, this.onEvidenceDiagnostic);
+        const developerInstructions = coerceString(params?.developerInstructions);
+        if ((method === "thread/start" || method === "thread/resume") && developerInstructions !== undefined) {
+            emitProviderEvidence(this.onEvidence, { type: "outbound", provider: CODEX_APP_SERVER_PROVIDER, direction: "request", kind: "system-prompt", ...sha256Utf8(developerInstructions) }, this.onEvidenceDiagnostic);
+        }
+    }
+    async close(mode = "graceful") {
+        if (this.exitSettled) {
+            this.closed = true;
+            return;
+        }
+        if (mode === "force") {
+            this.forceClose ??= this.closeForce();
+            await this.forceClose;
+            return;
+        }
+        if (this.forceClose) {
+            await this.forceClose;
+            return;
+        }
+        this.gracefulClose ??= this.closeGracefully();
+        await this.gracefulClose;
+    }
+    closePipes(propagate) {
+        const failures = [];
+        for (const close of [
+            () => this.child.stdin.end(),
+            () => this.child.stdout.destroy(),
+            () => this.child.stderr.destroy(),
+        ]) {
+            try {
+                close();
+            }
+            catch (error) {
+                if (propagate)
+                    failures.push(error);
+            }
+        }
+        return failures;
+    }
+    async closeForce() {
+        this.closed = true;
+        this.failAll(new Error(`${CODEX_APP_SERVER_PROVIDER} process closed`));
+        const failures = this.closePipes(true);
+        if (!this.exitSettled) {
+            try {
+                const killed = this.child.kill("SIGKILL");
+                if (!killed && !this.exitSettled) {
+                    failures.push(new Error(`${CODEX_APP_SERVER_PROVIDER} failed to force kill process`));
+                }
+            }
+            catch (error) {
+                failures.push(error);
+            }
+        }
+        const hardBound = new Promise((_, reject) => {
+            const timer = setTimeout(() => reject(new Error(`${CODEX_APP_SERVER_PROVIDER} forced process exit was not observed`)), 2000);
+            timer.unref?.();
+        });
+        try {
+            await Promise.race([this.exitPromise, hardBound]);
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        if (failures.length === 1)
+            throw failures[0];
+        if (failures.length > 1) {
+            throw new AggregateError(failures, `${CODEX_APP_SERVER_PROVIDER} forced close failed`);
+        }
+    }
+    async closeGracefully() {
+        this.closed = true;
+        this.failAll(new Error(`${CODEX_APP_SERVER_PROVIDER} process closed`));
+        this.closePipes(false);
+        if (!this.exitSettled && this.child.exitCode === null && this.child.signalCode === null) {
+            try {
+                this.child.kill("SIGTERM");
+            }
+            catch {
+                // Graceful cleanup is best-effort.
+            }
+        }
+        const forceKill = new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                if (!this.exitSettled) {
+                    try {
+                        this.child.kill("SIGKILL");
+                    }
+                    catch {
+                        // Graceful escalation is best-effort.
+                    }
+                }
+                resolve();
+            }, 1000);
+            timer.unref?.();
+        });
+        const hardBound = new Promise((resolve) => {
+            const timer = setTimeout(resolve, 2000);
+            timer.unref?.();
+        });
+        await Promise.race([this.exitPromise, Promise.all([forceKill, this.exitPromise]).then(() => undefined), hardBound]);
+    }
+}