@infomity/remogent 0.0.0-stage → 0.2.1

package/dist/adapters/codex.js

@@ -0,0 +1,510 @@
+import { homedir } from "node:os";
+import { RpcError, RpcPeer } from "./rpc.js";
+import { findOnPath, killTree, spawnCli } from "./util.js";
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const str = (v) => (typeof v === "string" && v.length > 0 ? v : undefined);
+/** Cap on tool output stored in a transcript event. */
+const MAX_OUTPUT = 64 * 1024;
+const cap = (s) => (s.length > MAX_OUTPUT ? s.slice(0, MAX_OUTPUT) : s);
+/** If Codex has not reported the end of an interrupted turn after this long, end it ourselves so the app unlocks. */
+const INTERRUPT_GRACE_MS = 15_000;
+/**
+ * Remogent permission mode -> Codex approval policy + sandbox.
+ * ask: everything except known read-only commands needs approval; plan: read-only and never ask (it cannot change
+ * anything); auto_edit: edits inside the workspace run, anything outside the sandbox asks; auto: no sandbox, no prompts.
+ */
+const POLICIES = {
+    ask: { approvalPolicy: "untrusted", sandbox: "workspace-write" },
+    plan: { approvalPolicy: "never", sandbox: "read-only" },
+    auto_edit: { approvalPolicy: "on-request", sandbox: "workspace-write" },
+    auto: { approvalPolicy: "never", sandbox: "danger-full-access" },
+};
+/** Path of the `codex` executable if it is installed on this host. */
+export function findCodex() {
+    return findOnPath("codex");
+}
+const stripAnsi = (s) => s.replace(/\u001b\[[0-9;]*m/g, "");
+function lastLine(s) {
+    const lines = stripAnsi(s).trim().split(/\r?\n/);
+    return lines[lines.length - 1] ?? "";
+}
+// ---- app-server -> Remogent mapping ----
+function actionRisk(actions) {
+    if (!Array.isArray(actions) || actions.length === 0)
+        return "shell";
+    const readOnly = actions.every((a) => isObj(a) && (a["type"] === "read" || a["type"] === "listFiles" || a["type"] === "search"));
+    return readOnly ? "read" : "shell";
+}
+function commandTitle(item) {
+    const acts = Array.isArray(item["commandActions"]) ? item["commandActions"] : [];
+    const cmds = acts.map((a) => (isObj(a) ? str(a["command"]) : undefined)).filter((c) => !!c);
+    const t = cmds.length ? cmds.join(" ; ") : (str(item["command"]) ?? "command");
+    return t.length > 200 ? t.slice(0, 200) + "..." : t;
+}
+function changePaths(changes) {
+    if (!Array.isArray(changes))
+        return [];
+    return changes.map((c) => (isObj(c) ? str(c["path"]) : undefined)).filter((p) => !!p);
+}
+function changesDiff(changes) {
+    if (!Array.isArray(changes))
+        return undefined;
+    const parts = [];
+    for (const c of changes) {
+        if (!isObj(c))
+            continue;
+        const path = str(c["path"]);
+        if (!path)
+            continue;
+        const kind = isObj(c["kind"]) ? str(c["kind"]["type"]) : undefined;
+        const diff = typeof c["diff"] === "string" ? c["diff"] : "";
+        parts.push(`${kind ?? "change"} ${path}\n${diff}`.trimEnd());
+    }
+    return parts.length ? cap(parts.join("\n\n")) : undefined;
+}
+function toolStart(item) {
+    const toolCallId = str(item["id"]);
+    if (!toolCallId)
+        return undefined;
+    const titled = (title) => (title ? { title } : {});
+    switch (item["type"]) {
+        case "commandExecution":
+            return {
+                kind: "tool_call",
+                toolCallId,
+                name: "shell",
+                title: commandTitle(item),
+                risk: actionRisk(item["commandActions"]),
+                input: { command: item["command"], cwd: item["cwd"] },
+            };
+        case "fileChange": {
+            const paths = changePaths(item["changes"]);
+            return { kind: "tool_call", toolCallId, name: "edit", title: paths.length ? `Edit ${paths.join(", ")}` : "Edit files", risk: "edit", input: { files: paths } };
+        }
+        case "mcpToolCall": {
+            const name = [str(item["server"]), str(item["tool"])].filter(Boolean).join(".");
+            return { kind: "tool_call", toolCallId, name: name || "mcp", risk: "other", input: item["arguments"] ?? {} };
+        }
+        case "webSearch":
+            return { kind: "tool_call", toolCallId, name: "web_search", ...titled(str(item["query"])), risk: "network", input: { query: item["query"] } };
+        case "dynamicToolCall":
+            return { kind: "tool_call", toolCallId, name: str(item["tool"]) ?? "tool", risk: "other", input: item["arguments"] ?? {} };
+        default:
+            return undefined; // userMessage, agentMessage, reasoning, plan, ...
+    }
+}
+function toolEnd(item) {
+    const toolCallId = str(item["id"]);
+    if (!toolCallId)
+        return undefined;
+    const type = item["type"];
+    if (type !== "commandExecution" && type !== "fileChange" && type !== "mcpToolCall" && type !== "webSearch" && type !== "dynamicToolCall") {
+        return undefined;
+    }
+    const s = str(item["status"]);
+    const declined = s === "declined";
+    const status = s === "completed" ? "completed" : s === "failed" || declined ? "failed" : "running";
+    let output;
+    let diff;
+    if (type === "commandExecution")
+        output = str(item["aggregatedOutput"]);
+    else if (type === "fileChange")
+        diff = changesDiff(item["changes"]);
+    else if (type === "mcpToolCall") {
+        const r = item["error"] ?? item["result"];
+        if (r !== undefined && r !== null)
+            output = cap(typeof r === "string" ? r : JSON.stringify(r));
+    }
+    if (!output && declined)
+        output = "Declined.";
+    return {
+        kind: "tool_call_update",
+        toolCallId,
+        status: type === "webSearch" && status === "running" ? "completed" : status,
+        ...(output ? { output: cap(output) } : {}),
+        ...(diff ? { diff } : {}),
+    };
+}
+/**
+ * Reads the `data[]` of `model/list` (verified on codex-cli 0.169.0): `{ id, model, displayName, description, hidden, isDefault,
+ * supportedReasoningEfforts: [{ reasoningEffort }] }`. `model` is what `thread/start` / `turn/start` take; hidden models are skipped.
+ */
+function parseCodexModels(data) {
+    if (!Array.isArray(data))
+        return [];
+    return data.filter(isObj).flatMap((x) => {
+        if (x["hidden"] === true)
+            return [];
+        const id = str(x["model"]) ?? str(x["id"]);
+        if (!id)
+            return [];
+        const description = str(x["description"]);
+        const efforts = Array.isArray(x["supportedReasoningEfforts"])
+            ? x["supportedReasoningEfforts"].map((e) => (isObj(e) ? str(e["reasoningEffort"]) : str(e))).filter((e) => !!e)
+            : [];
+        return [
+            {
+                id,
+                name: str(x["displayName"]) ?? id,
+                ...(description ? { description } : {}),
+                ...(x["isDefault"] === true ? { isDefault: true } : {}),
+                ...(efforts.length ? { efforts } : {}),
+            },
+        ];
+    });
+}
+/** Asks a short-lived `codex app-server` for its model list (`model/list`; no model call is made). */
+async function queryCodexModels(binary) {
+    const child = spawnCli(binary, ["app-server"], homedir());
+    const rpc = new RpcPeer(child, { jsonrpcField: false });
+    let stderrTail = "";
+    child.stderr.on("data", (d) => {
+        stderrTail = (stderrTail + d.toString()).slice(-2000);
+    });
+    child.on("error", (e) => rpc.failAll(new Error(`codex failed to start: ${e.message}`)));
+    child.on("exit", (code) => rpc.failAll(new Error(stderrTail ? `codex exited (code ${code}): ${lastLine(stderrTail)}` : `codex exited (code ${code})`)));
+    rpc.onRequest = async (method) => {
+        throw new RpcError(-32601, `unsupported method: ${method}`);
+    };
+    let timer;
+    try {
+        const work = (async () => {
+            await rpc.request("initialize", { clientInfo: { name: "remogent", title: "Remogent", version: process.env["npm_package_version"] ?? "dev" } });
+            rpc.notify("initialized");
+            const out = [];
+            let cursor;
+            for (let page = 0; page < 5; page++) {
+                const res = await rpc.request("model/list", cursor ? { cursor } : {});
+                out.push(...parseCodexModels(isObj(res) ? res["data"] : undefined));
+                cursor = isObj(res) ? str(res["nextCursor"]) : undefined;
+                if (!cursor)
+                    break;
+            }
+            return out;
+        })();
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error("codex did not answer in time")), 20_000);
+        });
+        return await Promise.race([work, timeout]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        killTree(child);
+    }
+}
+export function createCodexAdapter(binary) {
+    return {
+        engine: "codex",
+        resumable: true,
+        listModels: () => queryCodexModels(binary),
+        async start({ cwd, permissionMode, resumeId, model }, sink) {
+            const policy = POLICIES[permissionMode];
+            let threadId = resumeId;
+            let curModel = model; // sent with thread/start|resume and every turn/start (a switch is just a new value)
+            let conn;
+            let ready;
+            let closed = false; // intentionally closed by the host
+            let turn;
+            let textInTurn = false;
+            let lastMsgItem;
+            const deltaItems = new Set();
+            const fileChanges = new Map(); // itemId -> changes, for approval diffs
+            const finishTurn = (t, status, errorMessage) => {
+                if (turn !== t)
+                    return;
+                turn = undefined;
+                if (status === "failed" && errorMessage && t.lastError !== errorMessage)
+                    sink.emit({ kind: "error", message: errorMessage });
+                sink.emit({
+                    kind: "turn_end",
+                    stopReason: status === "interrupted" ? "cancelled" : status === "failed" ? "error" : "end_turn",
+                    ...(t.usage !== undefined ? { usage: t.usage } : {}),
+                });
+                t.resolve();
+            };
+            const handleNotification = (method, params) => {
+                if (!isObj(params))
+                    return;
+                const tid = str(params["threadId"]);
+                if (tid && threadId && tid !== threadId)
+                    return; // another (sub-agent) thread
+                switch (method) {
+                    case "item/agentMessage/delta": {
+                        const delta = typeof params["delta"] === "string" ? params["delta"] : "";
+                        const itemId = str(params["itemId"]);
+                        if (!delta)
+                            return;
+                        // Each agent message item is its own paragraph (commentary before tools, then the final answer).
+                        if (itemId && itemId !== lastMsgItem && textInTurn)
+                            sink.emit({ kind: "agent_text_delta", text: "\n\n" });
+                        if (itemId) {
+                            lastMsgItem = itemId;
+                            deltaItems.add(itemId);
+                        }
+                        textInTurn = true;
+                        sink.emit({ kind: "agent_text_delta", text: delta });
+                        return;
+                    }
+                    case "item/reasoning/summaryTextDelta":
+                    case "item/reasoning/textDelta": {
+                        const delta = typeof params["delta"] === "string" ? params["delta"] : "";
+                        if (delta)
+                            sink.emit({ kind: "agent_thought_delta", text: delta });
+                        return;
+                    }
+                    case "item/started": {
+                        const item = params["item"];
+                        if (!isObj(item))
+                            return;
+                        if (item["type"] === "fileChange")
+                            fileChanges.set(String(item["id"]), item["changes"]);
+                        const ev = toolStart(item);
+                        if (ev)
+                            sink.emit(ev);
+                        return;
+                    }
+                    case "item/fileChange/patchUpdated": {
+                        const itemId = str(params["itemId"]);
+                        if (itemId)
+                            fileChanges.set(itemId, params["changes"]);
+                        return;
+                    }
+                    case "item/completed": {
+                        const item = params["item"];
+                        if (!isObj(item))
+                            return;
+                        if (item["type"] === "agentMessage") {
+                            // Whole message without streamed deltas (some items arrive complete): show it now.
+                            const id = str(item["id"]);
+                            const text = str(item["text"]);
+                            if (text && (!id || !deltaItems.has(id))) {
+                                if (textInTurn)
+                                    sink.emit({ kind: "agent_text_delta", text: "\n\n" });
+                                textInTurn = true;
+                                if (id)
+                                    lastMsgItem = id;
+                                sink.emit({ kind: "agent_text_delta", text });
+                            }
+                            return;
+                        }
+                        const ev = toolEnd(item);
+                        if (ev)
+                            sink.emit(ev);
+                        return;
+                    }
+                    case "thread/tokenUsage/updated": {
+                        if (turn && params["tokenUsage"] !== undefined)
+                            turn.usage = params["tokenUsage"];
+                        return;
+                    }
+                    case "error": {
+                        const err = isObj(params["error"]) ? params["error"] : {};
+                        const message = str(err["message"]);
+                        if (params["willRetry"] === true || !message)
+                            return;
+                        if (turn)
+                            turn.lastError = message;
+                        sink.emit({ kind: "error", message });
+                        return;
+                    }
+                    case "turn/completed": {
+                        const t = turn;
+                        const tn = isObj(params["turn"]) ? params["turn"] : {};
+                        if (!t)
+                            return;
+                        if (t.id && str(tn["id"]) && t.id !== tn["id"])
+                            return;
+                        const err = isObj(tn["error"]) ? str(tn["error"]["message"]) : undefined;
+                        finishTurn(t, str(tn["status"]) ?? "completed", err ?? "the turn failed");
+                        return;
+                    }
+                    default:
+                        return; // thread/*, mcpServer/*, account/*, rate limits, warnings, ...
+                }
+            };
+            const decide = (d) => (d === "deny" ? "decline" : "accept");
+            const handleRequest = async (method, params) => {
+                const p = isObj(params) ? params : {};
+                switch (method) {
+                    case "item/commandExecution/requestApproval": {
+                        const itemId = str(p["itemId"]);
+                        const decision = await sink.requestPermission({
+                            ...(itemId ? { toolCallId: itemId } : {}),
+                            tool: "shell",
+                            risk: p["networkApprovalContext"] ? "network" : actionRisk(p["commandActions"]),
+                            summary: str(p["reason"]) ?? commandTitle(p),
+                            input: { command: p["command"], cwd: p["cwd"], reason: p["reason"] },
+                        });
+                        // allow_session is tracked by the host; toward Codex it is a one-time accept, so Codex never persists an
+                        // exec-policy rule on disk.
+                        return { decision: decide(decision) };
+                    }
+                    case "item/fileChange/requestApproval": {
+                        const itemId = str(p["itemId"]);
+                        const changes = itemId ? fileChanges.get(itemId) : undefined;
+                        const paths = changePaths(changes);
+                        const diff = changesDiff(changes);
+                        const decision = await sink.requestPermission({
+                            ...(itemId ? { toolCallId: itemId } : {}),
+                            tool: "edit",
+                            risk: "edit",
+                            summary: str(p["reason"]) ?? (paths.length ? `Edit ${paths.join(", ")}` : "Apply file changes"),
+                            input: { files: paths, ...(p["grantRoot"] ? { grantRoot: p["grantRoot"] } : {}) },
+                            ...(diff ? { diff } : {}),
+                        });
+                        return { decision: decide(decision) };
+                    }
+                    case "item/permissions/requestApproval": {
+                        const itemId = str(p["itemId"]);
+                        const wanted = isObj(p["permissions"]) ? p["permissions"] : {};
+                        const decision = await sink.requestPermission({
+                            ...(itemId ? { toolCallId: itemId } : {}),
+                            tool: "permissions",
+                            risk: wanted["network"] ? "network" : "edit",
+                            summary: str(p["reason"]) ?? "Codex asks for extra permissions",
+                            input: wanted,
+                        });
+                        return { permissions: decision === "deny" ? {} : wanted, scope: "turn" };
+                    }
+                    case "mcpServer/elicitation/request":
+                        return { action: "decline" };
+                    case "item/tool/requestUserInput":
+                        return { answers: {} };
+                    case "applyPatchApproval":
+                    case "execCommandApproval":
+                        return { decision: "denied" }; // legacy (v1) approvals: never used by this adapter's threads
+                    default:
+                        throw new RpcError(-32601, `unsupported method: ${method}`);
+                }
+            };
+            const boot = async () => {
+                const child = spawnCli(binary, ["app-server"], cwd);
+                const rpc = new RpcPeer(child, { jsonrpcField: false });
+                const c = { child, rpc, alive: true };
+                let stderrTail = "";
+                child.stderr.on("data", (d) => {
+                    stderrTail = (stderrTail + d.toString()).slice(-2000); // kept only for exit diagnostics; never logged
+                });
+                const died = (why) => {
+                    if (!c.alive)
+                        return;
+                    c.alive = false;
+                    const err = new Error(stderrTail ? `${why}: ${lastLine(stderrTail)}` : why);
+                    rpc.failAll(err);
+                    const t = turn;
+                    if (closed || !t)
+                        return;
+                    turn = undefined;
+                    t.reject(err); // the prompt rejection reports the death; the next prompt respawns and resumes the thread
+                };
+                child.on("exit", (code) => died(`codex exited (code ${code})`));
+                child.on("error", (e) => died(`codex failed to start: ${e.message}`));
+                rpc.onNotification = handleNotification;
+                rpc.onRequest = handleRequest;
+                try {
+                    await rpc.request("initialize", {
+                        clientInfo: { name: "remogent", title: "Remogent", version: process.env["npm_package_version"] ?? "dev" },
+                    });
+                    rpc.notify("initialized");
+                    const settings = { cwd, approvalPolicy: policy.approvalPolicy, sandbox: policy.sandbox, ...(curModel ? { model: curModel } : {}) };
+                    if (threadId) {
+                        await rpc.request("thread/resume", { threadId, excludeTurns: true, ...settings });
+                    }
+                    else {
+                        const res = await rpc.request("thread/start", settings);
+                        const thread = isObj(res) ? res["thread"] : undefined;
+                        threadId = isObj(thread) ? str(thread["id"]) : undefined;
+                        if (!threadId)
+                            throw new Error("codex did not return a thread id");
+                    }
+                }
+                catch (e) {
+                    c.alive = false;
+                    killTree(child);
+                    const msg = e instanceof Error ? e.message : String(e);
+                    throw new Error(/auth|login|sign.?in|unauthor/i.test(msg) ? `${msg} (run \`codex login\` once on the host to sign in)` : msg);
+                }
+                return c;
+            };
+            const ensure = () => {
+                if (conn?.alive)
+                    return Promise.resolve(conn);
+                ready ??= boot()
+                    .then((c) => (conn = c))
+                    .finally(() => {
+                    ready = undefined;
+                });
+                return ready;
+            };
+            // A new chat starts the CLI now (so a missing login shows up immediately); a restored chat waits for its next prompt.
+            if (!resumeId)
+                await ensure();
+            return {
+                async prompt(text) {
+                    if (closed)
+                        throw new Error("codex session is closed");
+                    const c = await ensure();
+                    const t = { cancelled: false, resolve: () => { }, reject: () => { } };
+                    const done = new Promise((resolve, reject) => {
+                        t.resolve = resolve;
+                        t.reject = reject;
+                    });
+                    turn = t;
+                    textInTurn = false;
+                    lastMsgItem = undefined;
+                    deltaItems.clear();
+                    try {
+                        const res = await c.rpc.request("turn/start", {
+                            threadId,
+                            input: [{ type: "text", text, text_elements: [] }],
+                            ...(curModel ? { model: curModel } : {}),
+                        });
+                        const tn = isObj(res) ? res["turn"] : undefined;
+                        const id = isObj(tn) ? str(tn["id"]) : undefined;
+                        if (turn === t && id) {
+                            t.id = id;
+                            if (t.cancelled)
+                                void c.rpc.request("turn/interrupt", { threadId, turnId: id }).catch(() => { });
+                        }
+                    }
+                    catch (e) {
+                        if (turn === t)
+                            turn = undefined;
+                        throw e;
+                    }
+                    await done;
+                },
+                async setModel(next) {
+                    if (closed)
+                        throw new Error("codex session is closed");
+                    if (turn)
+                        throw new Error("a turn is already running");
+                    curModel = next; // applied by the next turn/start (and by thread/resume after a respawn)
+                },
+                cancel() {
+                    const t = turn;
+                    const c = conn;
+                    if (!t || !c?.alive || t.cancelled)
+                        return;
+                    t.cancelled = true;
+                    if (t.id)
+                        void c.rpc.request("turn/interrupt", { threadId, turnId: t.id }).catch(() => { });
+                    setTimeout(() => finishTurn(t, "interrupted"), INTERRUPT_GRACE_MS).unref();
+                },
+                close() {
+                    closed = true;
+                    const t = turn;
+                    turn = undefined;
+                    t?.resolve();
+                    if (conn) {
+                        conn.alive = false;
+                        killTree(conn.child);
+                    }
+                },
+                engineSessionId: () => threadId,
+            };
+        },
+    };
+}
+//# sourceMappingURL=codex.js.map