remcodex 0.1.0-beta.1

package/dist/server/src/services/codex-exec-runner.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexExecRunner = void 0;
+const node_child_process_1 = require("node:child_process");
+class CodexExecRunner {
+    command;
+    cwd;
+    process = null;
+    jsonListeners = new Set();
+    textListeners = new Set();
+    exitListeners = new Set();
+    stdoutBuffer = "";
+    stopTimer = null;
+    constructor(command, cwd) {
+        this.command = command;
+        this.cwd = cwd;
+    }
+    start(prompt, threadId, launch) {
+        const args = this.buildExecArgs(prompt, threadId, launch);
+        this.process = (0, node_child_process_1.spawn)(this.command, args, {
+            cwd: this.cwd,
+            env: process.env,
+            stdio: "pipe",
+        });
+        if (!this.process.pid) {
+            throw new Error("Failed to start codex exec process.");
+        }
+        this.process.stdout.on("data", (chunk) => {
+            this.handleStdout(chunk.toString("utf8"));
+        });
+        this.process.stderr.on("data", (chunk) => {
+            this.emitText("stderr", chunk.toString("utf8"));
+        });
+        this.process.on("close", (exitCode) => {
+            if (this.stopTimer) {
+                clearTimeout(this.stopTimer);
+                this.stopTimer = null;
+            }
+            this.flushStdoutRemainder();
+            this.process = null;
+            this.exitListeners.forEach((listener) => listener(exitCode));
+        });
+        this.process.on("error", (error) => {
+            this.emitText("stderr", `Failed to spawn Codex exec: ${error.message}`);
+        });
+        return this.process.pid;
+    }
+    stop() {
+        if (!this.process) {
+            return;
+        }
+        this.process.kill("SIGINT");
+        this.stopTimer = setTimeout(() => {
+            this.process?.kill("SIGTERM");
+        }, 1500);
+        this.stopTimer.unref();
+    }
+    respond() {
+        return false;
+    }
+    onJsonEvent(listener) {
+        this.jsonListeners.add(listener);
+        return () => {
+            this.jsonListeners.delete(listener);
+        };
+    }
+    onText(listener) {
+        this.textListeners.add(listener);
+        return () => {
+            this.textListeners.delete(listener);
+        };
+    }
+    onExit(listener) {
+        this.exitListeners.add(listener);
+        return () => {
+            this.exitListeners.delete(listener);
+        };
+    }
+    isAlive() {
+        return this.process !== null;
+    }
+    buildExecArgs(prompt, threadId, launch) {
+        const mid = [];
+        if (launch?.model) {
+            mid.push("-m", launch.model);
+        }
+        if (launch?.profile) {
+            mid.push("-p", launch.profile);
+        }
+        if (launch?.sandbox) {
+            mid.push("-s", launch.sandbox);
+        }
+        if (launch?.reasoningEffort) {
+            mid.push("-c", `model_reasoning_effort=${launch.reasoningEffort}`);
+        }
+        if (launch?.speed === "fast") {
+            mid.push("--enable", "fast_mode");
+        }
+        else if (launch?.speed === "deep") {
+            mid.push("--disable", "fast_mode");
+        }
+        for (const name of launch?.enableFeatures ?? []) {
+            mid.push("--enable", name);
+        }
+        for (const name of launch?.disableFeatures ?? []) {
+            mid.push("--disable", name);
+        }
+        if (threadId) {
+            return ["exec", "resume", "--json", ...mid, "--skip-git-repo-check", threadId, prompt];
+        }
+        return ["exec", "--json", ...mid, "--skip-git-repo-check", "--color", "never", prompt];
+    }
+    handleStdout(chunk) {
+        this.stdoutBuffer += chunk;
+        const lines = this.stdoutBuffer.split(/\r?\n/);
+        this.stdoutBuffer = lines.pop() ?? "";
+        lines.forEach((line) => this.handleJsonLine(line));
+    }
+    flushStdoutRemainder() {
+        if (!this.stdoutBuffer.trim()) {
+            this.stdoutBuffer = "";
+            return;
+        }
+        this.handleJsonLine(this.stdoutBuffer);
+        this.stdoutBuffer = "";
+    }
+    handleJsonLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            return;
+        }
+        try {
+            const event = JSON.parse(trimmed);
+            this.jsonListeners.forEach((listener) => listener(event));
+        }
+        catch {
+            this.emitText("stdout", trimmed);
+        }
+    }
+    emitText(stream, text) {
+        if (!text) {
+            return;
+        }
+        this.textListeners.forEach((listener) => listener(stream, text.trimEnd()));
+    }
+}
+exports.CodexExecRunner = CodexExecRunner;