patchrelay 0.1.0

package/dist/codex-app-server.js

@@ -0,0 +1,353 @@
+import { EventEmitter } from "node:events";
+import { spawn } from "node:child_process";
+import { sanitizeDiagnosticText } from "./utils.js";
+export function resolveCodexAppServerLaunch(config) {
+    if (!config.sourceBashrc) {
+        return {
+            command: config.bin,
+            args: config.args,
+        };
+    }
+    return {
+        command: config.shellBin ?? "bash",
+        args: [
+            "-lc",
+            'source ~/.bashrc >/dev/null 2>&1 || true; exec "$0" "$@"',
+            config.bin,
+            ...config.args,
+        ],
+    };
+}
+export class CodexAppServerClient extends EventEmitter {
+    config;
+    logger;
+    spawnProcess;
+    child;
+    nextRequestId = 1;
+    pending = new Map();
+    stdoutBuffer = "";
+    started = false;
+    stopping = false;
+    constructor(config, logger, spawnProcess = spawn) {
+        super();
+        this.config = config;
+        this.logger = logger;
+        this.spawnProcess = spawnProcess;
+    }
+    isStarted() {
+        return this.started;
+    }
+    async start() {
+        if (this.started) {
+            return;
+        }
+        this.stopping = false;
+        const launch = resolveCodexAppServerLaunch(this.config);
+        this.logger.info({ command: launch.command, args: launch.args }, "Starting Codex app-server");
+        this.child = this.spawnProcess(launch.command, launch.args, {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.child.stderr.on("data", (chunk) => {
+            const line = chunk.toString().trim();
+            if (line) {
+                this.logger.warn({ output: sanitizeDiagnosticText(line) }, "Codex app-server stderr");
+            }
+        });
+        this.child.on("error", (error) => {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger.error({
+                error: sanitizeDiagnosticText(err.message),
+                pendingRequestCount: this.pending.size,
+            }, "Codex app-server process errored");
+            this.rejectAllPending(err);
+        });
+        this.child.on("close", (code, signal) => {
+            this.started = false;
+            const log = this.stopping ? this.logger.info.bind(this.logger) : this.logger.warn.bind(this.logger);
+            log({
+                code: code ?? 1,
+                signal: signal ?? null,
+                pendingRequestCount: this.pending.size,
+            }, this.stopping ? "Codex app-server stopped" : "Codex app-server exited");
+            this.stopping = false;
+            this.rejectAllPending(new Error(`Codex app-server exited with code ${code ?? 1}`));
+        });
+        this.child.stdout.on("data", (chunk) => {
+            this.stdoutBuffer += chunk.toString("utf8");
+            this.drainMessages();
+        });
+        const initializeResponse = await this.sendRequest("initialize", {
+            clientInfo: {
+                name: "patchrelay",
+                title: "PatchRelay",
+                version: "0.1.0",
+            },
+            capabilities: null,
+        });
+        const serverInfo = initializeResponse && typeof initializeResponse === "object" && "serverInfo" in initializeResponse
+            ? initializeResponse.serverInfo
+            : undefined;
+        this.logger.info({
+            serverName: typeof serverInfo?.name === "string" ? serverInfo.name : undefined,
+            serverVersion: typeof serverInfo?.version === "string" ? serverInfo.version : undefined,
+        }, "Connected to Codex app-server");
+        this.sendNotification("initialized");
+        this.started = true;
+    }
+    async stop() {
+        if (!this.child) {
+            return;
+        }
+        this.logger.info("Stopping Codex app-server");
+        this.stopping = true;
+        this.child.kill("SIGTERM");
+        this.child = undefined;
+        this.started = false;
+    }
+    async startThread(options) {
+        const params = {
+            cwd: options.cwd,
+            approvalPolicy: this.config.approvalPolicy,
+            sandbox: this.config.sandboxMode,
+            serviceName: this.config.serviceName ?? "patchrelay",
+            model: this.config.model ?? null,
+            modelProvider: this.config.modelProvider ?? null,
+            baseInstructions: this.config.baseInstructions ?? null,
+            developerInstructions: this.config.developerInstructions ?? null,
+            experimentalRawEvents: false,
+        };
+        if (this.config.persistExtendedHistory) {
+            this.logger.warn("persistExtendedHistory is requested but not enabled in the active app-server capability handshake; ignoring");
+        }
+        const response = (await this.sendRequest("thread/start", params));
+        return this.mapThread(response.thread);
+    }
+    async resumeThread(threadId, cwd) {
+        const params = {
+            threadId,
+            cwd: cwd ?? null,
+            approvalPolicy: this.config.approvalPolicy,
+            sandbox: this.config.sandboxMode,
+            model: this.config.model ?? null,
+            modelProvider: this.config.modelProvider ?? null,
+            baseInstructions: this.config.baseInstructions ?? null,
+            developerInstructions: this.config.developerInstructions ?? null,
+        };
+        if (this.config.persistExtendedHistory) {
+            this.logger.warn("persistExtendedHistory is requested but not enabled in the active app-server capability handshake; ignoring");
+        }
+        const response = (await this.sendRequest("thread/resume", params));
+        return this.mapThread(response.thread);
+    }
+    async forkThread(threadId, cwd) {
+        const params = {
+            threadId,
+            cwd: cwd ?? null,
+            approvalPolicy: this.config.approvalPolicy,
+            sandbox: this.config.sandboxMode,
+            model: this.config.model ?? null,
+            modelProvider: this.config.modelProvider ?? null,
+            baseInstructions: this.config.baseInstructions ?? null,
+            developerInstructions: this.config.developerInstructions ?? null,
+        };
+        if (this.config.persistExtendedHistory) {
+            this.logger.warn("persistExtendedHistory is requested but not enabled in the active app-server capability handshake; ignoring");
+        }
+        const response = (await this.sendRequest("thread/fork", params));
+        return this.mapThread(response.thread);
+    }
+    async startTurn(options) {
+        const response = (await this.sendRequest("turn/start", {
+            threadId: options.threadId,
+            cwd: options.cwd,
+            input: [
+                {
+                    type: "text",
+                    text: options.input,
+                    text_elements: [],
+                },
+            ],
+        }));
+        return {
+            threadId: options.threadId,
+            turnId: String(response.turn.id),
+            status: String(response.turn.status),
+        };
+    }
+    async readThread(threadId, includeTurns = true) {
+        const response = (await this.sendRequest("thread/read", {
+            threadId,
+            includeTurns,
+        }));
+        return this.mapThread(response.thread);
+    }
+    async listThreads() {
+        const response = (await this.sendRequest("thread/list", {}));
+        return response.data.map((thread) => this.mapThread(thread));
+    }
+    async steerTurn(options) {
+        await this.sendRequest("turn/steer", {
+            threadId: options.threadId,
+            expectedTurnId: options.turnId,
+            input: [
+                {
+                    type: "text",
+                    text: options.input,
+                    text_elements: [],
+                },
+            ],
+        });
+    }
+    sendNotification(method, params) {
+        this.writeMessage({
+            jsonrpc: "2.0",
+            method,
+            ...(params === undefined ? {} : { params }),
+        });
+    }
+    async sendRequest(method, params) {
+        if (!this.child?.stdin) {
+            throw new Error("Codex app-server is not running");
+        }
+        const id = this.nextRequestId++;
+        const promise = new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+        });
+        this.writeMessage({
+            jsonrpc: "2.0",
+            id,
+            method,
+            params,
+        });
+        return promise.catch((error) => {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger.error({
+                method,
+                requestId: id,
+                error: sanitizeDiagnosticText(err.message),
+            }, "Codex app-server request failed");
+            throw err;
+        });
+    }
+    writeMessage(message) {
+        if (!this.child?.stdin) {
+            throw new Error("Codex app-server stdin is unavailable");
+        }
+        this.child.stdin.write(`${JSON.stringify(message)}\n`);
+    }
+    drainMessages() {
+        while (true) {
+            const newlineIndex = this.stdoutBuffer.indexOf("\n");
+            if (newlineIndex === -1) {
+                return;
+            }
+            const line = this.stdoutBuffer.slice(0, newlineIndex).trim();
+            this.stdoutBuffer = this.stdoutBuffer.slice(newlineIndex + 1);
+            if (!line) {
+                continue;
+            }
+            try {
+                this.handleMessage(JSON.parse(line));
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                this.started = false;
+                this.logger.error({
+                    error: sanitizeDiagnosticText(err.message),
+                    output: sanitizeDiagnosticText(line),
+                }, "Failed to parse Codex app-server stdout message");
+                this.rejectAllPending(new Error(`Codex app-server emitted invalid JSON: ${err.message}`));
+                this.child?.kill("SIGTERM");
+                return;
+            }
+        }
+    }
+    handleMessage(message) {
+        if ("method" in message && "id" in message) {
+            void this.handleServerRequest(message);
+            return;
+        }
+        if ("method" in message) {
+            const notification = {
+                method: message.method,
+                params: (message.params ?? {}),
+            };
+            this.emit("notification", notification);
+            return;
+        }
+        const id = Number(message.id);
+        const pending = this.pending.get(id);
+        if (!pending) {
+            return;
+        }
+        this.pending.delete(id);
+        if ("error" in message) {
+            pending.reject(new Error(JSON.stringify(message.error)));
+            return;
+        }
+        pending.resolve(message.result);
+    }
+    async handleServerRequest(request) {
+        const id = request.id;
+        let result;
+        switch (request.method) {
+            case "item/commandExecution/requestApproval":
+                result = { decision: this.resolveSessionApprovalDecision() };
+                break;
+            case "item/fileChange/requestApproval":
+                result = { decision: this.resolveSessionApprovalDecision() };
+                break;
+            case "execCommandApproval":
+                result = { decision: this.resolveOneShotApprovalDecision() };
+                break;
+            case "applyPatchApproval":
+                result = { decision: this.resolveOneShotApprovalDecision() };
+                break;
+            default:
+                result = null;
+                break;
+        }
+        this.writeMessage({
+            jsonrpc: "2.0",
+            id,
+            result,
+        });
+    }
+    resolveSessionApprovalDecision() {
+        return this.config.approvalPolicy === "never" ? "acceptForSession" : "rejectForSession";
+    }
+    resolveOneShotApprovalDecision() {
+        return this.config.approvalPolicy === "never" ? "accept" : "reject";
+    }
+    rejectAllPending(error) {
+        for (const pending of this.pending.values()) {
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+    mapThread(thread) {
+        const turns = Array.isArray(thread.turns) ? thread.turns : [];
+        const rawStatus = thread.status;
+        const status = rawStatus && typeof rawStatus === "object" && "type" in rawStatus
+            ? String(rawStatus.type)
+            : String(rawStatus ?? "unknown");
+        return {
+            id: String(thread.id),
+            preview: String(thread.preview ?? ""),
+            cwd: String(thread.cwd ?? ""),
+            status,
+            ...(thread.path === null || thread.path === undefined ? {} : { path: String(thread.path) }),
+            turns: turns.map((turn) => {
+                const value = turn;
+                return {
+                    id: String(value.id),
+                    status: String(value.status),
+                    ...(value.error && typeof value.error === "object"
+                        ? { error: { message: String(value.error.message ?? "Unknown error") } }
+                        : {}),
+                    items: Array.isArray(value.items) ? value.items : [],
+                };
+            }),
+        };
+    }
+}

package/dist/codex-types.js

@@ -0,0 +1 @@
+export {};

package/dist/config-types.js

@@ -0,0 +1 @@
+export {};