@pasko70/pibo 1.16.5 → 2.0.0

package/dist/agent-runtimes/codex-native/client.js

@@ -0,0 +1,734 @@
+import { spawn } from "node:child_process";
+const DEFAULT_STARTUP_TIMEOUT_MS = 10_000;
+const DEFAULT_REQUEST_TIMEOUT_MS = 120_000;
+const DEFAULT_SHUTDOWN_TIMEOUT_MS = 2_000;
+const DEFAULT_KILL_TIMEOUT_MS = 500;
+const DEFAULT_MAX_MESSAGE_BYTES = 8 * 1024 * 1024;
+const DEFAULT_MAX_PENDING_REQUESTS = 128;
+const DEFAULT_MAX_STDERR_BYTES = 64 * 1024;
+const DEFAULT_MAX_DIAGNOSTICS = 50;
+const DEFAULT_OVERLOAD_RETRIES = 3;
+const DEFAULT_OVERLOAD_RETRY_BASE_MS = 100;
+const DEFAULT_OVERLOAD_RETRY_MAX_MS = 2_000;
+const DEFAULT_OVERLOAD_RETRY_JITTER = 0.2;
+const CODEX_APP_SERVER_OVERLOADED = -32001;
+export class CodexAppServerClientError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = "CodexAppServerClientError";
+        this.code = code;
+    }
+}
+export class CodexAppServerServerRequestCancelledError extends Error {
+    constructor(message = "Codex App Server request was resolved before the client response.") {
+        super(message);
+        this.name = "CodexAppServerServerRequestCancelledError";
+    }
+}
+export class CodexAppServerRpcResponseError extends Error {
+    rpcCode;
+    data;
+    constructor(error) {
+        super(redactCodexAppServerDiagnostic(error.message));
+        this.name = "CodexAppServerRpcResponseError";
+        this.rpcCode = error.code;
+        this.data = error.data;
+    }
+}
+function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((resolvePromise, rejectPromise) => {
+        resolve = resolvePromise;
+        reject = rejectPromise;
+    });
+    return { promise, resolve, reject };
+}
+function positiveInteger(value, fallback, name) {
+    const selected = value ?? fallback;
+    if (!Number.isSafeInteger(selected) || selected <= 0) {
+        throw new Error(`${name} must be a positive safe integer`);
+    }
+    return selected;
+}
+function nonNegativeInteger(value, fallback, name) {
+    const selected = value ?? fallback;
+    if (!Number.isSafeInteger(selected) || selected < 0) {
+        throw new Error(`${name} must be a non-negative safe integer`);
+    }
+    return selected;
+}
+function boundedRatio(value, fallback, name) {
+    const selected = value ?? fallback;
+    if (!Number.isFinite(selected) || selected < 0 || selected > 1) {
+        throw new Error(`${name} must be between 0 and 1`);
+    }
+    return selected;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isRequestId(value) {
+    return typeof value === "string" || (typeof value === "number" && Number.isSafeInteger(value));
+}
+function requestIdKey(value) {
+    return `${typeof value}:${String(value)}`;
+}
+function validateInitializeResponse(value) {
+    if (!isRecord(value))
+        throw new CodexAppServerClientError("protocol_error", "Codex initialize returned a non-object result");
+    const { codexHome, platformFamily, platformOs, userAgent } = value;
+    for (const [field, fieldValue] of Object.entries({ codexHome, platformFamily, platformOs, userAgent })) {
+        if (typeof fieldValue !== "string") {
+            throw new CodexAppServerClientError("protocol_error", `Codex initialize result is missing ${field}`);
+        }
+    }
+    return {
+        codexHome: codexHome,
+        platformFamily: platformFamily,
+        platformOs: platformOs,
+        userAgent: userAgent,
+    };
+}
+function redactCodexAppServerDiagnostic(value) {
+    return value
+        .replace(/Bearer\s+\S+/gi, "Bearer [redacted]")
+        .replace(/\b(?:sk|pk|ghp|github_pat|pibo)[-_][A-Za-z0-9_-]{8,}\b/g, "[redacted]")
+        .replace(/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g, "[redacted]")
+        .replace(/\b(access[_-]?token|refresh[_-]?token|id[_-]?token|api[_-]?key|token|secret|password)\b(\s*["']?\s*[:=]\s*["']?)([^\s"'&,}]+)/gi, "$1$2[redacted]")
+        .replace(/`(?:\/|[A-Za-z]:[\\/])[^`\r\n]+`/g, "`[redacted path]`")
+        .replace(/\bfile:\/\/\/?[^\s"'`,)]+/gi, "file://[redacted path]")
+        .slice(0, 4_000);
+}
+function validateClientOptions(options) {
+    if (!options.command.trim())
+        throw new Error("command is required");
+    if (!options.clientInfo.name.trim() || !options.clientInfo.version.trim()) {
+        throw new Error("clientInfo.name and clientInfo.version are required");
+    }
+    positiveInteger(options.startupTimeoutMs, DEFAULT_STARTUP_TIMEOUT_MS, "startupTimeoutMs");
+    positiveInteger(options.requestTimeoutMs, DEFAULT_REQUEST_TIMEOUT_MS, "requestTimeoutMs");
+    positiveInteger(options.shutdownTimeoutMs, DEFAULT_SHUTDOWN_TIMEOUT_MS, "shutdownTimeoutMs");
+    positiveInteger(options.killTimeoutMs, DEFAULT_KILL_TIMEOUT_MS, "killTimeoutMs");
+    positiveInteger(options.maxMessageBytes, DEFAULT_MAX_MESSAGE_BYTES, "maxMessageBytes");
+    positiveInteger(options.maxPendingRequests, DEFAULT_MAX_PENDING_REQUESTS, "maxPendingRequests");
+    nonNegativeInteger(options.maxStderrBytes, DEFAULT_MAX_STDERR_BYTES, "maxStderrBytes");
+    nonNegativeInteger(options.overloadRetry?.maxRetries, DEFAULT_OVERLOAD_RETRIES, "overloadRetry.maxRetries");
+    nonNegativeInteger(options.overloadRetry?.baseDelayMs, DEFAULT_OVERLOAD_RETRY_BASE_MS, "overloadRetry.baseDelayMs");
+    nonNegativeInteger(options.overloadRetry?.maxDelayMs, DEFAULT_OVERLOAD_RETRY_MAX_MS, "overloadRetry.maxDelayMs");
+    boundedRatio(options.overloadRetry?.jitterRatio, DEFAULT_OVERLOAD_RETRY_JITTER, "overloadRetry.jitterRatio");
+    if (options.fileCreationMask !== undefined
+        && (!Number.isSafeInteger(options.fileCreationMask) || options.fileCreationMask < 0 || options.fileCreationMask > 0o777)) {
+        throw new Error("fileCreationMask must be an integer between 0 and 0o777");
+    }
+}
+function serializeMessage(message, maxMessageBytes) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(message);
+    }
+    catch (error) {
+        throw new CodexAppServerClientError("serialization_error", "Codex App Server message is not JSON serializable", { cause: error });
+    }
+    if (serialized === undefined) {
+        throw new CodexAppServerClientError("serialization_error", "Codex App Server message serialized to undefined");
+    }
+    if (Buffer.byteLength(serialized, "utf8") > maxMessageBytes) {
+        throw new CodexAppServerClientError("message_too_large", `Codex App Server message exceeds ${maxMessageBytes} bytes`);
+    }
+    return `${serialized}\n`;
+}
+function timeoutError(label) {
+    return new CodexAppServerClientError("timeout", `${label} timed out`);
+}
+async function waitWithTimeout(promise, timeoutMs, label) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(timeoutError(label)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+async function sleep(delayMs, signal) {
+    if (delayMs <= 0)
+        return;
+    if (signal?.aborted)
+        throw new CodexAppServerClientError("aborted", "Codex App Server request was aborted");
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            cleanup();
+            resolve();
+        }, delayMs);
+        const onAbort = () => {
+            cleanup();
+            reject(new CodexAppServerClientError("aborted", "Codex App Server request was aborted"));
+        };
+        const cleanup = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+export class CodexAppServerClient {
+    initializeResponse;
+    process;
+    startupTimeoutMs;
+    requestTimeoutMs;
+    shutdownTimeoutMs;
+    killTimeoutMs;
+    maxMessageBytes;
+    maxPendingRequests;
+    maxStderrBytes;
+    overloadMaxRetries;
+    overloadBaseDelayMs;
+    overloadMaxDelayMs;
+    overloadJitterRatio;
+    random;
+    onDiagnostic;
+    pending = new Map();
+    notificationListeners = new Set();
+    diagnosticListeners = new Set();
+    diagnostics = [];
+    spawned = deferred();
+    processClosed = deferred();
+    stderrChunks = [];
+    stdoutBuffer = Buffer.alloc(0);
+    stderrBytes = 0;
+    stderrTruncated = false;
+    nextRequestId = 0;
+    writeTail = Promise.resolve();
+    writeBackpressureCount = 0;
+    state = "starting";
+    processCloseResult;
+    serverRequestHandler;
+    closePromise;
+    stopPromise;
+    constructor(process, options, initializeResponse) {
+        this.process = process;
+        this.initializeResponse = initializeResponse;
+        this.startupTimeoutMs = positiveInteger(options.startupTimeoutMs, DEFAULT_STARTUP_TIMEOUT_MS, "startupTimeoutMs");
+        this.requestTimeoutMs = positiveInteger(options.requestTimeoutMs, DEFAULT_REQUEST_TIMEOUT_MS, "requestTimeoutMs");
+        this.shutdownTimeoutMs = positiveInteger(options.shutdownTimeoutMs, DEFAULT_SHUTDOWN_TIMEOUT_MS, "shutdownTimeoutMs");
+        this.killTimeoutMs = positiveInteger(options.killTimeoutMs, DEFAULT_KILL_TIMEOUT_MS, "killTimeoutMs");
+        this.maxMessageBytes = positiveInteger(options.maxMessageBytes, DEFAULT_MAX_MESSAGE_BYTES, "maxMessageBytes");
+        this.maxPendingRequests = positiveInteger(options.maxPendingRequests, DEFAULT_MAX_PENDING_REQUESTS, "maxPendingRequests");
+        this.maxStderrBytes = nonNegativeInteger(options.maxStderrBytes, DEFAULT_MAX_STDERR_BYTES, "maxStderrBytes");
+        this.overloadMaxRetries = nonNegativeInteger(options.overloadRetry?.maxRetries, DEFAULT_OVERLOAD_RETRIES, "overloadRetry.maxRetries");
+        this.overloadBaseDelayMs = nonNegativeInteger(options.overloadRetry?.baseDelayMs, DEFAULT_OVERLOAD_RETRY_BASE_MS, "overloadRetry.baseDelayMs");
+        this.overloadMaxDelayMs = nonNegativeInteger(options.overloadRetry?.maxDelayMs, DEFAULT_OVERLOAD_RETRY_MAX_MS, "overloadRetry.maxDelayMs");
+        this.overloadJitterRatio = boundedRatio(options.overloadRetry?.jitterRatio, DEFAULT_OVERLOAD_RETRY_JITTER, "overloadRetry.jitterRatio");
+        this.random = options.random ?? Math.random;
+        this.onDiagnostic = options.onDiagnostic;
+    }
+    static async start(options) {
+        validateClientOptions(options);
+        let previousMask;
+        if (options.fileCreationMask !== undefined && globalThis.process.platform !== "win32") {
+            previousMask = globalThis.process.umask(options.fileCreationMask);
+        }
+        let process;
+        try {
+            process = spawn(options.command, [...(options.args ?? [])], {
+                cwd: options.cwd,
+                env: options.env ?? globalThis.process.env,
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+        }
+        finally {
+            if (previousMask !== undefined)
+                globalThis.process.umask(previousMask);
+        }
+        const placeholder = {
+            codexHome: "",
+            platformFamily: "",
+            platformOs: "",
+            userAgent: "",
+        };
+        const client = new CodexAppServerClient(process, options, placeholder);
+        client.attachProcessListeners();
+        const deadline = Date.now() + client.startupTimeoutMs;
+        try {
+            await waitWithTimeout(client.spawned.promise, client.startupTimeoutMs, "Codex App Server spawn");
+            client.state = "initializing";
+            const initializeResult = await client.requestWithRetry("initialize", {
+                clientInfo: { ...options.clientInfo },
+                capabilities: options.capabilities ? structuredClone(options.capabilities) : { experimentalApi: false },
+            }, {
+                timeoutMs: Math.max(1, deadline - Date.now()),
+                retryOverloaded: true,
+            }, true);
+            const initializeResponse = validateInitializeResponse(initializeResult);
+            Object.assign(client.initializeResponse, initializeResponse);
+            Object.freeze(client.initializeResponse);
+            await waitWithTimeout(client.writeMessage({ method: "initialized" }, true), Math.max(1, deadline - Date.now()), "Codex App Server initialized notification");
+            client.state = "ready";
+            return client;
+        }
+        catch (error) {
+            const normalized = client.normalizeStartError(error);
+            client.failAll(normalized);
+            await client.stopProcess(false).catch(() => { });
+            throw normalized;
+        }
+    }
+    get snapshot() {
+        return {
+            state: this.state,
+            ...(this.process.pid !== undefined ? { pid: this.process.pid } : {}),
+            pendingRequests: this.pending.size,
+            writeBackpressureCount: this.writeBackpressureCount,
+            stderrBytes: this.stderrBytes,
+            stderrTruncated: this.stderrTruncated,
+        };
+    }
+    getStderrDiagnostic() {
+        return redactCodexAppServerDiagnostic(Buffer.concat(this.stderrChunks).toString("utf8"));
+    }
+    getDiagnostics() {
+        return this.diagnostics.map((diagnostic) => ({ ...diagnostic }));
+    }
+    subscribeNotifications(listener) {
+        this.notificationListeners.add(listener);
+        return () => this.notificationListeners.delete(listener);
+    }
+    subscribeDiagnostics(listener) {
+        this.diagnosticListeners.add(listener);
+        return () => this.diagnosticListeners.delete(listener);
+    }
+    setServerRequestHandler(handler) {
+        this.serverRequestHandler = handler;
+    }
+    async request(method, params, options = {}) {
+        this.assertReady();
+        if (method === "initialize") {
+            throw new CodexAppServerClientError("protocol_error", "Codex App Server initialize may only be sent once during startup");
+        }
+        return await this.requestWithRetry(method, params, options, false);
+    }
+    async notify(method, params) {
+        this.assertReady();
+        if (method === "initialized") {
+            throw new CodexAppServerClientError("protocol_error", "Codex App Server initialized may only be sent once during startup");
+        }
+        await this.writeMessage({ method, ...(params === undefined ? {} : { params }) }, false);
+    }
+    async close() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closePromise = this.closeUnsafe();
+        return this.closePromise;
+    }
+    attachProcessListeners() {
+        this.process.once("spawn", () => this.spawned.resolve());
+        this.process.once("error", (error) => {
+            const wrapped = new CodexAppServerClientError("spawn_failed", "Codex App Server process failed to start", { cause: error });
+            this.spawned.reject(wrapped);
+            if (this.state !== "closing" && this.state !== "closed") {
+                this.state = "failed";
+                this.failAll(wrapped);
+                this.emitDiagnostic({ level: "error", code: "codex_process_error", message: wrapped.message });
+            }
+        });
+        this.process.once("close", (code, signal) => this.handleProcessClose(code, signal));
+        this.process.stdout.on("data", (chunk) => this.handleStdoutChunk(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+        this.process.stderr.on("data", (chunk) => this.captureStderr(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+    }
+    normalizeStartError(error) {
+        if (error instanceof Error)
+            return error;
+        return new CodexAppServerClientError("spawn_failed", "Codex App Server startup failed");
+    }
+    assertReady() {
+        if (this.state === "ready")
+            return;
+        throw new CodexAppServerClientError("closed", `Codex App Server client is ${this.state}`);
+    }
+    async requestWithRetry(method, params, options, allowBeforeReady) {
+        if (!allowBeforeReady)
+            this.assertReady();
+        const timeoutMs = positiveInteger(options.timeoutMs, this.requestTimeoutMs, "request timeoutMs");
+        const deadline = Date.now() + timeoutMs;
+        const maxRetries = options.retryOverloaded === false ? 0 : this.overloadMaxRetries;
+        let attempt = 0;
+        while (true) {
+            if (options.signal?.aborted) {
+                throw new CodexAppServerClientError("aborted", "Codex App Server request was aborted");
+            }
+            const remaining = deadline - Date.now();
+            if (remaining <= 0)
+                throw timeoutError(`Codex App Server ${method} request`);
+            try {
+                return await this.requestOnce(method, params, remaining, options.signal, allowBeforeReady);
+            }
+            catch (error) {
+                if (!(error instanceof CodexAppServerRpcResponseError) || error.rpcCode !== CODEX_APP_SERVER_OVERLOADED || attempt >= maxRetries) {
+                    throw error;
+                }
+                const delayMs = this.overloadDelay(attempt);
+                attempt += 1;
+                if (delayMs >= deadline - Date.now())
+                    throw timeoutError(`Codex App Server ${method} request`);
+                await sleep(delayMs, options.signal);
+            }
+        }
+    }
+    overloadDelay(attempt) {
+        const exponential = Math.min(this.overloadMaxDelayMs, this.overloadBaseDelayMs * 2 ** attempt);
+        const jitter = exponential * this.overloadJitterRatio * (this.random() * 2 - 1);
+        return Math.max(0, Math.round(exponential + jitter));
+    }
+    async requestOnce(method, params, timeoutMs, signal, allowBeforeReady) {
+        if (!allowBeforeReady)
+            this.assertReady();
+        if (this.state === "closing" || this.state === "closed" || this.state === "failed") {
+            throw new CodexAppServerClientError("closed", `Codex App Server client is ${this.state}`);
+        }
+        if (this.pending.size >= this.maxPendingRequests) {
+            throw new CodexAppServerClientError("pending_limit", `Codex App Server pending request limit ${this.maxPendingRequests} reached`);
+        }
+        const id = this.allocateRequestId();
+        const key = requestIdKey(id);
+        let pending;
+        const response = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.settlePending(key, undefined, timeoutError(`Codex App Server ${method} request`));
+            }, timeoutMs);
+            pending = { resolve, reject, timer, signal };
+            if (signal) {
+                pending.onAbort = () => {
+                    this.settlePending(key, undefined, new CodexAppServerClientError("aborted", "Codex App Server request was aborted"));
+                };
+                signal.addEventListener("abort", pending.onAbort, { once: true });
+            }
+        });
+        this.pending.set(key, pending);
+        void response.catch(() => { });
+        if (signal?.aborted) {
+            this.settlePending(key, undefined, new CodexAppServerClientError("aborted", "Codex App Server request was aborted"));
+            return await response;
+        }
+        try {
+            await this.writeMessage({ id, method, ...(params === undefined ? {} : { params }) }, allowBeforeReady);
+        }
+        catch (error) {
+            this.settlePending(key, undefined, error instanceof Error ? error : new CodexAppServerClientError("write_failed", "Codex App Server request write failed"));
+        }
+        return await response;
+    }
+    allocateRequestId() {
+        const id = this.nextRequestId;
+        this.nextRequestId = this.nextRequestId >= Number.MAX_SAFE_INTEGER ? 0 : this.nextRequestId + 1;
+        return id;
+    }
+    writeMessage(message, allowBeforeReady) {
+        if (!allowBeforeReady && this.state !== "ready") {
+            return Promise.reject(new CodexAppServerClientError("closed", `Codex App Server client is ${this.state}`));
+        }
+        const line = serializeMessage(message, this.maxMessageBytes);
+        const write = this.writeTail.then(() => this.writeLine(line, allowBeforeReady));
+        this.writeTail = write.catch(() => { });
+        return write;
+    }
+    async writeLine(line, allowBeforeReady) {
+        if (this.state === "closing" || this.state === "closed" || this.state === "failed") {
+            throw new CodexAppServerClientError("closed", `Codex App Server client is ${this.state}`);
+        }
+        if (!allowBeforeReady && this.state !== "ready") {
+            throw new CodexAppServerClientError("closed", `Codex App Server client is ${this.state}`);
+        }
+        if (allowBeforeReady && this.state !== "initializing" && this.state !== "ready") {
+            throw new CodexAppServerClientError("closed", `Codex App Server client is ${this.state}`);
+        }
+        if (this.process.stdin.destroyed || !this.process.stdin.writable) {
+            throw new CodexAppServerClientError("write_failed", "Codex App Server stdin is not writable");
+        }
+        let accepted;
+        try {
+            accepted = this.process.stdin.write(line, "utf8");
+        }
+        catch (error) {
+            throw new CodexAppServerClientError("write_failed", "Codex App Server stdin write failed", { cause: error });
+        }
+        if (accepted)
+            return;
+        this.writeBackpressureCount += 1;
+        await new Promise((resolve, reject) => {
+            const onDrain = () => {
+                cleanup();
+                resolve();
+            };
+            const onError = (error) => {
+                cleanup();
+                reject(new CodexAppServerClientError("write_failed", "Codex App Server stdin write failed", { cause: error }));
+            };
+            const onClose = () => {
+                cleanup();
+                reject(new CodexAppServerClientError("process_exited", "Codex App Server exited while a write was waiting for drain"));
+            };
+            const cleanup = () => {
+                this.process.stdin.removeListener("drain", onDrain);
+                this.process.stdin.removeListener("error", onError);
+                this.process.removeListener("close", onClose);
+            };
+            this.process.stdin.once("drain", onDrain);
+            this.process.stdin.once("error", onError);
+            this.process.once("close", onClose);
+        });
+    }
+    handleStdoutChunk(chunk) {
+        if (this.state === "closed")
+            return;
+        let offset = 0;
+        while (offset < chunk.length) {
+            const newline = chunk.indexOf(0x0a, offset);
+            const end = newline < 0 ? chunk.length : newline;
+            const fragment = chunk.subarray(offset, end);
+            if (this.stdoutBuffer.length + fragment.length > this.maxMessageBytes) {
+                this.protocolFailure("Codex App Server stdout message exceeded the configured byte limit", "codex_message_too_large", "message_too_large");
+                return;
+            }
+            if (fragment.length > 0)
+                this.stdoutBuffer = Buffer.concat([this.stdoutBuffer, fragment]);
+            if (newline < 0)
+                return;
+            const line = this.stdoutBuffer.length > 0 && this.stdoutBuffer.at(-1) === 0x0d
+                ? this.stdoutBuffer.subarray(0, -1)
+                : this.stdoutBuffer;
+            this.stdoutBuffer = Buffer.alloc(0);
+            if (line.length > 0)
+                this.handleStdoutLine(line);
+            if (this.state === "failed")
+                return;
+            offset = newline + 1;
+        }
+    }
+    handleStdoutLine(line) {
+        let message;
+        try {
+            message = JSON.parse(line.toString("utf8"));
+        }
+        catch {
+            this.protocolFailure("Codex App Server emitted malformed JSON", "codex_malformed_json");
+            return;
+        }
+        if (!isRecord(message)) {
+            this.protocolFailure("Codex App Server emitted a non-object JSON message", "codex_invalid_message");
+            return;
+        }
+        if (typeof message.method === "string") {
+            if (Object.hasOwn(message, "id")) {
+                if (!isRequestId(message.id)) {
+                    this.protocolFailure("Codex App Server emitted a request with an invalid id", "codex_invalid_request_id");
+                    return;
+                }
+                void this.handleServerRequest({
+                    id: message.id,
+                    method: message.method,
+                    ...(Object.hasOwn(message, "params") ? { params: message.params } : {}),
+                });
+                return;
+            }
+            this.handleNotification({
+                method: message.method,
+                ...(Object.hasOwn(message, "params") ? { params: message.params } : {}),
+            });
+            return;
+        }
+        if (!Object.hasOwn(message, "id") || !isRequestId(message.id)) {
+            this.protocolFailure("Codex App Server emitted a response without a valid id", "codex_invalid_response_id");
+            return;
+        }
+        const hasResult = Object.hasOwn(message, "result");
+        const hasError = Object.hasOwn(message, "error");
+        if (hasResult === hasError) {
+            this.protocolFailure("Codex App Server response must contain exactly one of result or error", "codex_invalid_response");
+            return;
+        }
+        const key = requestIdKey(message.id);
+        if (!this.pending.has(key)) {
+            this.emitDiagnostic({ level: "warning", code: "codex_unknown_response_id", message: "Codex App Server returned an unknown or expired request id" });
+            return;
+        }
+        if (hasError) {
+            if (!isRecord(message.error) || typeof message.error.code !== "number" || typeof message.error.message !== "string") {
+                this.protocolFailure("Codex App Server returned a malformed error response", "codex_invalid_error_response");
+                return;
+            }
+            this.settlePending(key, undefined, new CodexAppServerRpcResponseError({
+                code: message.error.code,
+                message: message.error.message,
+                ...(Object.hasOwn(message.error, "data") ? { data: message.error.data } : {}),
+            }));
+            return;
+        }
+        this.settlePending(key, message.result, undefined);
+    }
+    handleNotification(notification) {
+        for (const listener of [...this.notificationListeners]) {
+            try {
+                listener(notification);
+            }
+            catch {
+                this.emitDiagnostic({ level: "warning", code: "codex_notification_listener_failed", message: "A Codex App Server notification listener failed" });
+            }
+        }
+    }
+    async handleServerRequest(request) {
+        const handler = this.serverRequestHandler;
+        if (!handler) {
+            await this.writeMessage({
+                id: request.id,
+                error: { code: -32601, message: `Unsupported server request method: ${request.method}` },
+            }, true).catch(() => { });
+            return;
+        }
+        try {
+            const result = await handler(request);
+            await this.writeMessage({ id: request.id, result: result === undefined ? null : result }, true);
+        }
+        catch (error) {
+            if (error instanceof CodexAppServerServerRequestCancelledError)
+                return;
+            const message = redactCodexAppServerDiagnostic(error instanceof Error ? error.message : "Server request handler failed");
+            await this.writeMessage({ id: request.id, error: { code: -32000, message } }, true).catch(() => { });
+        }
+    }
+    settlePending(key, value, error) {
+        const pending = this.pending.get(key);
+        if (!pending)
+            return;
+        this.pending.delete(key);
+        clearTimeout(pending.timer);
+        if (pending.signal && pending.onAbort)
+            pending.signal.removeEventListener("abort", pending.onAbort);
+        if (error)
+            pending.reject(error);
+        else
+            pending.resolve(value);
+    }
+    failAll(error) {
+        for (const key of [...this.pending.keys()])
+            this.settlePending(key, undefined, error);
+    }
+    protocolFailure(message, diagnosticCode, errorCode = "protocol_error") {
+        if (this.state === "failed" || this.state === "closing" || this.state === "closed")
+            return;
+        this.state = "failed";
+        const error = new CodexAppServerClientError(errorCode, message);
+        this.emitDiagnostic({ level: "error", code: diagnosticCode, message });
+        this.failAll(error);
+        void this.stopProcess(false).catch(() => { });
+    }
+    captureStderr(chunk) {
+        if (this.maxStderrBytes === 0) {
+            this.stderrTruncated = this.stderrTruncated || chunk.length > 0;
+            return;
+        }
+        const remaining = this.maxStderrBytes - this.stderrBytes;
+        if (remaining <= 0) {
+            this.stderrTruncated = true;
+            return;
+        }
+        const selected = chunk.subarray(0, remaining);
+        this.stderrChunks.push(selected);
+        this.stderrBytes += selected.length;
+        if (selected.length < chunk.length)
+            this.stderrTruncated = true;
+    }
+    handleProcessClose(code, signal) {
+        if (this.processCloseResult)
+            return;
+        const result = { code, signal };
+        this.processCloseResult = result;
+        this.processClosed.resolve(result);
+        const expected = this.state === "closing" || this.state === "closed";
+        if (expected) {
+            this.state = "closed";
+            this.failAll(new CodexAppServerClientError("closed", "Codex App Server client closed"));
+            return;
+        }
+        this.state = "failed";
+        const suffix = this.getStderrDiagnostic();
+        const error = new CodexAppServerClientError("process_exited", `Codex App Server exited unexpectedly (code=${code ?? "null"}, signal=${signal ?? "null"})${suffix ? `: ${suffix}` : ""}`);
+        this.failAll(error);
+        this.emitDiagnostic({ level: "error", code: "codex_process_exited", message: error.message });
+    }
+    emitDiagnostic(diagnostic) {
+        const safe = { ...diagnostic, message: redactCodexAppServerDiagnostic(diagnostic.message) };
+        this.diagnostics.push(safe);
+        if (this.diagnostics.length > DEFAULT_MAX_DIAGNOSTICS)
+            this.diagnostics.shift();
+        try {
+            this.onDiagnostic?.(safe);
+        }
+        catch {
+            // Diagnostics must not destabilize the transport.
+        }
+        for (const listener of [...this.diagnosticListeners]) {
+            try {
+                listener(safe);
+            }
+            catch {
+                // Diagnostics must not destabilize the transport.
+            }
+        }
+    }
+    async closeUnsafe() {
+        if (this.state === "closed")
+            return;
+        this.state = "closing";
+        this.failAll(new CodexAppServerClientError("closed", "Codex App Server client is closing"));
+        await this.stopProcess(true);
+        this.state = "closed";
+    }
+    stopProcess(graceful) {
+        if (this.stopPromise)
+            return this.stopPromise;
+        this.stopPromise = this.stopProcessUnsafe(graceful);
+        return this.stopPromise;
+    }
+    async stopProcessUnsafe(graceful) {
+        if (this.processCloseResult)
+            return;
+        if (graceful) {
+            if (!this.process.stdin.destroyed)
+                this.process.stdin.end();
+            if (await this.waitForProcessClose(this.shutdownTimeoutMs))
+                return;
+        }
+        else if (!this.process.stdin.destroyed) {
+            this.process.stdin.destroy();
+        }
+        this.process.kill("SIGTERM");
+        if (await this.waitForProcessClose(this.killTimeoutMs))
+            return;
+        this.process.kill("SIGKILL");
+        await this.waitForProcessClose(this.killTimeoutMs);
+    }
+    async waitForProcessClose(timeoutMs) {
+        if (this.processCloseResult)
+            return true;
+        let timer;
+        try {
+            return await Promise.race([
+                this.processClosed.promise.then(() => true),
+                new Promise((resolve) => {
+                    timer = setTimeout(() => resolve(false), timeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+}