@astrosheep/keiyaku 2.9.13 → 4.0.1

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

@@ -1,259 +0,0 @@
-import * as path from "node:path";
-import { z } from "zod";
-import { executableSchema, isConfigKeyForbidden, providerCommonFields, providerEnvSchema, structuredTomlValueSchema, writableRootItemSchema, } from "../../../config/settings/provider-instance-fields.js";
-import { exactKeys, optionalJsonObject, optionalString, optionalStringRecord, parseAbsoluteRootList, snapshotError, } from "../../launch-snapshot/parse-helpers.js";
-import { SUBAGENT_SESSION_VERSION, subagentSessionEnvelopeSchema, } from "../../session.js";
-import { FlowError } from "../../../flow-error.js";
-import { CODEX_APP_SERVER_PROVIDER } from "./identity.js";
-import { buildCodexAppServerWorkspaceWriteSandboxPolicy, configOwnsApprovalPolicy, configOwnsSandboxPolicy, } from "./policy.js";
-import { codexAppServerSessionSchema } from "./session-schema.js";
-const startCodexAppServer = async (prompt, cwd, options) => {
-    const { startCodexAppServer: start } = await import("./adapter.js");
-    return start(prompt, cwd, options);
-};
-const ACCESS_VALUES = new Set(["write"]);
-const NETWORK_VALUES = new Set(["disabled", "enabled"]);
-function admitResumeShape(schema, session, resumePath) {
-    const envelopeResult = subagentSessionEnvelopeSchema.safeParse(session);
-    if (!envelopeResult.success) {
-        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes an invalid session envelope.`);
-    }
-    if (session.provider !== CODEX_APP_SERVER_PROVIDER) {
-        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' was created with provider '${session.provider}', but the selected subagent resolves to '${CODEX_APP_SERVER_PROVIDER}'. Cross-provider resume is not supported.`);
-    }
-    if (session.version !== SUBAGENT_SESSION_VERSION) {
-        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' uses unsupported session version '${session.version}' for provider '${session.provider}'.`);
-    }
-    const shapeResult = schema.safeParse(session.handle);
-    if (!shapeResult.success) {
-        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes an invalid session handle for provider '${session.provider}'.`);
-    }
-    return shapeResult.data;
-}
-function parseSandboxPolicy(value) {
-    const sandbox = value;
-    if (sandbox === null || typeof sandbox !== "object" || Array.isArray(sandbox)) {
-        throw snapshotError("provider.sandboxPolicy", "must be a plain JSON object");
-    }
-    const record = sandbox;
-    exactKeys(record, ["type", "writableRoots", "networkAccess", "excludeTmpdirEnvVar", "excludeSlashTmp"], "provider.sandboxPolicy");
-    if (record.type !== "workspaceWrite")
-        throw snapshotError("provider.sandboxPolicy.type", "must equal 'workspaceWrite'");
-    const roots = parseAbsoluteRootList(record.writableRoots, "provider.sandboxPolicy.writableRoots");
-    for (const key of ["networkAccess", "excludeTmpdirEnvVar", "excludeSlashTmp"]) {
-        if (typeof record[key] !== "boolean")
-            throw snapshotError(`provider.sandboxPolicy.${key}`, "must be a boolean");
-    }
-    return Object.freeze({
-        type: "workspaceWrite",
-        writableRoots: roots,
-        networkAccess: record.networkAccess,
-        excludeTmpdirEnvVar: record.excludeTmpdirEnvVar,
-        excludeSlashTmp: record.excludeSlashTmp,
-    });
-}
-export const codexAppServerRegistration = {
-    name: CODEX_APP_SERVER_PROVIDER,
-    start: startCodexAppServer,
-    sessionSchema: codexAppServerSessionSchema,
-    rejectsGlobalWritableRoots: true,
-    effortField: "effort",
-    instanceSchema: z
-        .object({
-        kind: z.literal(CODEX_APP_SERVER_PROVIDER),
-        ...providerCommonFields,
-        executable: executableSchema.optional(),
-        profile: z.string().optional(),
-        config: structuredTomlValueSchema.optional(),
-        writableRoots: z.array(writableRootItemSchema).optional(),
-        env: providerEnvSchema,
-    })
-        .strict()
-        .superRefine((data, ctx) => {
-        if (data.config) {
-            for (const key of Object.keys(data.config)) {
-                if (isConfigKeyForbidden(key)) {
-                    ctx.addIssue({
-                        code: z.ZodIssueCode.custom,
-                        path: ["config", key],
-                        message: `"${key}" is owned by the Akuma or Keiyaku execution, not this provider instance`,
-                    });
-                }
-            }
-        }
-    }),
-    builtinInstance: {
-        name: CODEX_APP_SERVER_PROVIDER,
-        source: "builtin",
-        instance: { kind: CODEX_APP_SERVER_PROVIDER, executable: "codex" },
-    },
-    builtinAkumaProfiles: [
-        { name: "akuma-codex", description: "Default Codex app-server Akuma." },
-    ],
-    portablePolicy: {
-        access: new Set(ACCESS_VALUES),
-        network: new Set(NETWORK_VALUES),
-        webSearch: new Set(),
-    },
-    maxCaptureChars: (config) => config.codex.execMaxCaptureChars,
-    buildCallTerms: ({ snapshot, baseTerms }) => {
-        const provider = snapshot.provider;
-        return {
-            ...baseTerms,
-            provider: CODEX_APP_SERVER_PROVIDER,
-            ...(provider.model !== undefined ? { model: provider.model } : {}),
-            ...(provider.effort !== undefined ? { effort: provider.effort } : {}),
-            ...(provider.profile !== undefined ? { profile: provider.profile } : {}),
-            ...(provider.config !== undefined ? { config: provider.config } : {}),
-            ...(provider.executable !== undefined ? { executable: provider.executable } : {}),
-            ...(provider.sandboxPolicy !== undefined
-                ? { sandboxPolicy: provider.sandboxPolicy }
-                : {}),
-            ...(provider.approvalPolicy !== undefined ? { approvalPolicy: provider.approvalPolicy } : {}),
-            ...(provider.env !== undefined ? { env: provider.env } : {}),
-            developerInstructions: snapshot.akuma.body || undefined,
-            onCheckpoint() { },
-        };
-    },
-    resolveLaunchProvider: ({ common, instance, model, effort, executionCwd, projectRoot, network, }) => {
-        if (instance.kind !== CODEX_APP_SERVER_PROVIDER) {
-            throw new Error(`resolveLaunchProvider expected ${CODEX_APP_SERVER_PROVIDER}`);
-        }
-        const codexInstance = instance;
-        const roots = [
-            path.resolve(executionCwd),
-            ...(codexInstance.writableRoots ?? []).map((root) => path.resolve(projectRoot, root)),
-        ];
-        const writableRoots = [...new Set(roots)];
-        return Object.freeze({
-            ...common,
-            kind: CODEX_APP_SERVER_PROVIDER,
-            ...(codexInstance.executable !== undefined ? { executable: codexInstance.executable } : {}),
-            ...(codexInstance.profile !== undefined ? { profile: codexInstance.profile } : {}),
-            ...(codexInstance.config !== undefined ? { config: codexInstance.config } : {}),
-            ...(model !== undefined ? { model } : {}),
-            ...(effort !== undefined ? { effort } : {}),
-            ...(!configOwnsSandboxPolicy(codexInstance.config)
-                ? {
-                    sandboxPolicy: buildCodexAppServerWorkspaceWriteSandboxPolicy({
-                        writableRoots,
-                        networkAccess: network === "enabled",
-                    }),
-                }
-                : {}),
-            ...(!configOwnsApprovalPolicy(codexInstance.config) ? { approvalPolicy: "never" } : {}),
-            ...(codexInstance.env !== undefined ? { env: codexInstance.env } : {}),
-        });
-    },
-    parseLaunchProvider: (provider, common) => {
-        exactKeys(provider, ["name", "source", "kind", "executable", "profile", "config", "model", "effort", "sandboxPolicy", "approvalPolicy", "env"], "provider");
-        if ("approvalPolicy" in provider && provider.approvalPolicy !== "never") {
-            throw snapshotError("provider.approvalPolicy", "must equal 'never'");
-        }
-        const executable = optionalString(provider, "executable", "provider");
-        const profile = optionalString(provider, "profile", "provider");
-        const config = optionalJsonObject(provider, "config");
-        const model = optionalString(provider, "model", "provider");
-        const effort = optionalString(provider, "effort", "provider");
-        const sandboxPolicy = "sandboxPolicy" in provider ? parseSandboxPolicy(provider.sandboxPolicy) : undefined;
-        const env = optionalStringRecord(provider, "env");
-        return Object.freeze({
-            ...common,
-            kind: CODEX_APP_SERVER_PROVIDER,
-            ...(executable !== undefined ? { executable } : {}),
-            ...(profile !== undefined ? { profile } : {}),
-            ...(config !== undefined ? { config } : {}),
-            ...(model !== undefined ? { model } : {}),
-            ...(effort !== undefined ? { effort } : {}),
-            ...(sandboxPolicy !== undefined ? { sandboxPolicy } : {}),
-            ...(provider.approvalPolicy === "never" ? { approvalPolicy: "never" } : {}),
-            ...(env !== undefined ? { env } : {}),
-        });
-    },
-    applyEffort: (provider, effort) => Object.freeze({ ...provider, effort }),
-    providerEffortAndModel: (provider) => {
-        const resolved = provider;
-        return { model: resolved.model, effort: resolved.effort };
-    },
-    attachLoader: (terms) => terms,
-    nativePolicyOwnership: (instanceName, instance) => {
-        if (instance.kind !== CODEX_APP_SERVER_PROVIDER)
-            return null;
-        const config = instance.config;
-        if (!config) {
-            return Object.freeze({
-                access: Object.freeze([]),
-                network: Object.freeze([]),
-                webSearch: Object.freeze([]),
-            });
-        }
-        const access = [];
-        const network = [];
-        const webSearch = [];
-        const owns = (key) => Object.prototype.hasOwnProperty.call(config, key);
-        const add = (target, key) => {
-            target.push({ path: `providers.${instanceName}.config.${key}`, value: config[key] });
-        };
-        if (owns("sandbox_mode"))
-            add(access, "sandbox_mode");
-        if (owns("approval_policy"))
-            add(access, "approval_policy");
-        for (const key of Object.keys(config)) {
-            if (key !== "sandbox_workspace_write" && !key.startsWith("sandbox_workspace_write."))
-                continue;
-            add(access, key);
-            add(network, key);
-        }
-        if (owns("web_search"))
-            add(webSearch, "web_search");
-        return Object.freeze({
-            access: Object.freeze(access),
-            network: Object.freeze(network),
-            webSearch: Object.freeze(webSearch),
-        });
-    },
-    tellReceiptCapabilities: { seen: "exact", consumed: "fence" },
-    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onDeliveryOpportunity, onSessionAdmission, onIngress, launchTellIds, observer, }) => {
-        if (terms.provider !== CODEX_APP_SERVER_PROVIDER) {
-            throw new Error(`startLive expected ${CODEX_APP_SERVER_PROVIDER}`);
-        }
-        const codexTerms = terms;
-        const options = {
-            model: codexTerms.model,
-            effort: codexTerms.effort,
-            profile: codexTerms.profile,
-            config: codexTerms.config,
-            sandboxPolicy: codexTerms.sandboxPolicy,
-            approvalPolicy: codexTerms.approvalPolicy,
-            executable: codexTerms.executable,
-            env: codexTerms.env,
-            signal,
-            developerInstructions: codexTerms.developerInstructions,
-            onSyncCheckpoint,
-            onDeliveryOpportunity,
-            onTellReceipt: observer ? (receipt) => {
-                try {
-                    observer.onTellReceipt(receipt);
-                }
-                catch { /* Receipt persistence cannot alter provider control. */ }
-            } : undefined,
-            launchTellIds,
-            onLaunchAdmission: observer ? (admission) => observer.onLaunchAdmission(admission) : undefined,
-            listLaunchAdmissions: observer ? () => observer.listLaunchAdmissions() : undefined,
-            onEvidence: codexTerms.onEvidence,
-            onSessionAdmission,
-            onIngress,
-            initialTurn: codexTerms.initialTurn,
-        };
-        const { startCodexAppServer: start } = await import("./adapter.js");
-        if (reviveTerms) {
-            const session = admitResumeShape(codexAppServerSessionSchema, reviveTerms.session, reviveTerms.resumePath);
-            return start(codexTerms.prompt, codexTerms.workdir, {
-                ...options,
-                threadId: session.threadId,
-                codexHome: session.codexHome,
-            });
-        }
-        return start(codexTerms.prompt, codexTerms.workdir, options);
-    },
-};

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

@@ -1,6 +0,0 @@
-import { z } from "zod";
-/** Session handle for codex-app-server: thread id plus optional CODEX_HOME for cross-process resume. */
-export const codexAppServerSessionSchema = z.object({
-    threadId: z.string().trim().min(1),
-    codexHome: z.string().trim().min(1).optional(),
-});

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

@@ -1,273 +0,0 @@
-import { spawn } from "node:child_process";
-import { emitProviderEvidence, sha256Utf8 } from "../../harness/runtime.js";
-import { coerceString } from "../../harness/runtime.js";
-import { CODEX_APP_SERVER_PROVIDER } from "./identity.js";
-export class CodexAppServerProcess {
-    child;
-    pending = new Map();
-    notificationListeners = new Set();
-    serverRequestListeners = new Set();
-    exitPromise;
-    nextId = 1;
-    stdoutBuffer = "";
-    closed = false;
-    exitSettled = false;
-    gracefulClose;
-    forceClose;
-    codexHome;
-    onEvidence;
-    onEvidenceDiagnostic;
-    constructor(executable, env, options) {
-        this.codexHome = options.codexHome;
-        this.onEvidence = options.onEvidence;
-        this.onEvidenceDiagnostic = options.onEvidenceDiagnostic;
-        const spawnEnv = {
-            ...env,
-            ...(options.codexHome ? { CODEX_HOME: options.codexHome } : {}),
-        };
-        this.child = spawn(executable, ["app-server", "--listen", "stdio://"], {
-            cwd: options.cwd,
-            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 = setTimeout(() => {
-            if (!this.exitSettled) {
-                try {
-                    this.child.kill("SIGKILL");
-                }
-                catch {
-                    // The hard bound below reports the missing exit proof.
-                }
-            }
-        }, 1000);
-        forceKill.unref?.();
-        let hardBoundTimer;
-        const hardBound = new Promise((_, reject) => {
-            hardBoundTimer = setTimeout(() => reject(new Error(`${CODEX_APP_SERVER_PROVIDER} process exit was not observed`)), 2000);
-            const timer = hardBoundTimer;
-            timer.unref?.();
-        });
-        try {
-            await Promise.race([this.exitPromise, hardBound]);
-        }
-        finally {
-            clearTimeout(forceKill);
-            if (hardBoundTimer)
-                clearTimeout(hardBoundTimer);
-        }
-    }
-}

package/build/agents/providers/event-type-tail.js

@@ -1,16 +0,0 @@
-export const MAX_RECORDED_EVENT_TYPES = 100;
-export function appendEventType(recordedTypes, eventType) {
-    if (recordedTypes.length === MAX_RECORDED_EVENT_TYPES) {
-        recordedTypes.shift();
-    }
-    recordedTypes.push(eventType);
-}
-export function renderEventTypeSummary(eventTypes, totalEventCount) {
-    if (eventTypes.length === 0)
-        return "(no streamed events)";
-    const startIndex = Math.max(totalEventCount - eventTypes.length, 0);
-    const summary = eventTypes.map((eventType, index) => `${startIndex + index + 1}. ${eventType}`).join("\n");
-    if (totalEventCount <= eventTypes.length)
-        return summary;
-    return `...[showing last ${eventTypes.length} of ${totalEventCount} events]...\n${summary}`;
-}