u1s1-cli 0.3.0 → 0.4.0

package/dist/import/codex.js

@@ -0,0 +1,362 @@
+import { createReadStream, existsSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import { createInterface } from "node:readline";
+import { asRecord, asString, fileMtimeMs, firstMeaningfulLine, isProbablyInjection, MAX_TEXT_CHARS, MAX_TOOL_RESULT_CHARS, oneLine, parseArgsJson, parseJsonLine, parseTime, readFirstJsonObject, sessionBelongsToCwd, truncateText, uniqueExistingDirs, } from "./util.js";
+const CODEX_TOOL_MAP = {
+    exec_command: "bash",
+    shell: "bash",
+    bash: "bash",
+    local_shell: "bash",
+    apply_patch: "edit",
+    read_file: "read",
+    write_file: "write",
+    grep_files: "grep",
+    grep: "grep",
+};
+function codexHomes() {
+    return uniqueExistingDirs([process.env["CODEX_HOME"], join(homedir(), ".codex")]);
+}
+function walkJsonl(root) {
+    const out = [];
+    const stack = [root];
+    while (stack.length) {
+        const dir = stack.pop();
+        if (!dir)
+            continue;
+        let entries = [];
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const name of entries) {
+            const path = join(dir, name);
+            let st;
+            try {
+                st = statSync(path);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory())
+                stack.push(path);
+            else if (name.endsWith(".jsonl"))
+                out.push(path);
+        }
+    }
+    return out;
+}
+function sessionIdFromMeta(meta, file) {
+    const payload = asRecord(meta["payload"]) ?? meta;
+    return (asString(payload["session_id"]) ??
+        asString(payload["id"]) ??
+        basename(file, ".jsonl").replace(/^rollout-/, ""));
+}
+function cwdFromMeta(meta) {
+    const payload = asRecord(meta["payload"]) ?? meta;
+    return asString(payload["cwd"]);
+}
+function isSubagent(meta) {
+    const payload = asRecord(meta["payload"]) ?? meta;
+    const source = payload["source"];
+    if (source && typeof source === "object" && !Array.isArray(source) && "subagent" in source)
+        return true;
+    return false;
+}
+function flattenCodexContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const raw of content) {
+        if (typeof raw === "string") {
+            parts.push(raw);
+            continue;
+        }
+        const block = asRecord(raw);
+        if (!block)
+            continue;
+        const text = asString(block["text"]) ?? asString(block["input_text"]) ?? asString(block["output_text"]);
+        if (text)
+            parts.push(text);
+    }
+    return parts.join("\n");
+}
+function mapToolName(name) {
+    return CODEX_TOOL_MAP[name] ?? name;
+}
+function argsFromCall(payload) {
+    const rawArgs = payload["arguments"];
+    if (typeof rawArgs === "string")
+        return parseArgsJson(rawArgs);
+    const rec = asRecord(rawArgs);
+    if (rec)
+        return rec;
+    const input = payload["input"];
+    if (typeof input === "string")
+        return { raw: input };
+    const recInput = asRecord(input);
+    return recInput ?? {};
+}
+function remapToolArgs(name, args) {
+    const mapped = mapToolName(name);
+    if (mapped === "bash") {
+        const command = asString(args["cmd"]) ?? asString(args["command"]) ?? asString(args["script"]) ?? asString(args["raw"]);
+        return command ? { command } : args;
+    }
+    if (mapped === "read") {
+        const path = asString(args["path"]) ?? asString(args["file_path"]) ?? asString(args["file"]);
+        return path ? { path } : args;
+    }
+    if (mapped === "write") {
+        const path = asString(args["path"]) ?? asString(args["file_path"]);
+        const content = asString(args["content"]) ?? asString(args["contents"]);
+        return {
+            ...(path ? { path } : {}),
+            ...(content !== undefined ? { content } : {}),
+        };
+    }
+    if (mapped === "edit" && name === "apply_patch") {
+        const patch = asString(args["raw"]) ?? asString(args["input"]) ?? asString(args["patch"]);
+        return patch ? { patch } : args;
+    }
+    return args;
+}
+function emptyUsage() {
+    return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+}
+export async function hydrateCodexSession(session) {
+    if (session.title && session.cwd)
+        return session;
+    const stream = createReadStream(session.sourcePath, { encoding: "utf8" });
+    const rl = createInterface({ input: stream, crlfDelay: Infinity });
+    let cwd = session.cwd;
+    let title = session.title;
+    let lines = 0;
+    try {
+        for await (const line of rl) {
+            lines += 1;
+            const obj = parseJsonLine(line);
+            if (!obj)
+                continue;
+            const type = asString(obj["type"]);
+            const payload = asRecord(obj["payload"]) ?? {};
+            if (!cwd && type === "session_meta")
+                cwd = asString(payload["cwd"]) ?? cwd;
+            if (!title && type === "event_msg" && asString(payload["type"]) === "user_message") {
+                const text = (asString(payload["message"]) ?? "").trim();
+                if (text && !isProbablyInjection(text))
+                    title = oneLine(firstMeaningfulLine(text) || text);
+            }
+            if (cwd && title)
+                break;
+            if (lines > 80)
+                break;
+        }
+    }
+    finally {
+        rl.close();
+        stream.destroy();
+    }
+    return { ...session, cwd: cwd || session.cwd, title: title || session.title };
+}
+function flushAssistant(messages, pending, model, ts) {
+    if (pending.length === 0)
+        return;
+    const sawTool = pending.some((b) => b.type === "toolCall");
+    messages.push({
+        role: "assistant",
+        content: pending.splice(0),
+        provider: "openai",
+        model,
+        api: "openai-codex-responses",
+        stopReason: sawTool ? "toolUse" : "stop",
+        usage: emptyUsage(),
+        timestamp: ts,
+    });
+}
+export const codexAdapter = {
+    id: "codex",
+    label: "Codex",
+    discover(opts) {
+        const wanted = opts.cwd;
+        const seen = new Set();
+        const found = [];
+        for (const home of codexHomes()) {
+            const sessionsRoot = join(home, "sessions");
+            if (!existsSync(sessionsRoot))
+                continue;
+            for (const file of walkJsonl(sessionsRoot)) {
+                let real = file;
+                try {
+                    real = realpathSync(file);
+                }
+                catch {
+                    // keep
+                }
+                if (seen.has(real))
+                    continue;
+                seen.add(real);
+                const first = readFirstJsonObject(real);
+                if (!first)
+                    continue;
+                if (isSubagent(first))
+                    continue;
+                const cwd = cwdFromMeta(first) ?? "";
+                if (wanted && (!cwd || !sessionBelongsToCwd(cwd, wanted)))
+                    continue;
+                found.push({
+                    source: "codex",
+                    sourceId: sessionIdFromMeta(first, real),
+                    sourcePath: real,
+                    cwd,
+                    startedAt: parseTime(asRecord(first["payload"])?.["timestamp"] ?? first["timestamp"]),
+                    mtimeMs: fileMtimeMs(real),
+                });
+            }
+        }
+        return found;
+    },
+    convert(session) {
+        let text = "";
+        try {
+            text = readFileSync(session.sourcePath, "utf8");
+        }
+        catch {
+            return { cwd: session.cwd || process.cwd(), title: session.title, messages: [] };
+        }
+        // A few Codex rollouts are huge (100MB+). Keep the latest ~8MB of text so import stays usable.
+        const maxChars = 8_000_000;
+        if (text.length > maxChars) {
+            const cut = text.length - maxChars;
+            const nl = text.indexOf("\n", cut);
+            text = text.slice(nl === -1 ? cut : nl + 1);
+        }
+        const messages = [];
+        let cwd = session.cwd;
+        let title = session.title;
+        let model = "codex";
+        const pending = [];
+        const pendingTools = new Map();
+        let lastTs = session.startedAt ?? Date.now();
+        let lastUserText = "";
+        for (const line of text.split(/\r?\n/)) {
+            const obj = parseJsonLine(line);
+            if (!obj)
+                continue;
+            const type = asString(obj["type"]);
+            const payload = asRecord(obj["payload"]) ?? {};
+            const ts = parseTime(obj["timestamp"]) ?? lastTs;
+            lastTs = ts;
+            if (type === "session_meta") {
+                cwd = asString(payload["cwd"]) ?? cwd;
+                continue;
+            }
+            if (type === "turn_context") {
+                model = asString(payload["model"]) ?? model;
+                cwd = asString(payload["cwd"]) ?? cwd;
+                continue;
+            }
+            if (type === "event_msg") {
+                const et = asString(payload["type"]);
+                if (et === "user_message") {
+                    flushAssistant(messages, pending, model, ts);
+                    const userText = truncateText(asString(payload["message"]) ?? "", MAX_TEXT_CHARS).trim();
+                    if (!userText || isProbablyInjection(userText))
+                        continue;
+                    if (userText === lastUserText)
+                        continue;
+                    lastUserText = userText;
+                    if (!title)
+                        title = oneLine(firstMeaningfulLine(userText) || userText);
+                    messages.push({ role: "user", text: userText, timestamp: ts });
+                }
+                continue;
+            }
+            if (type !== "response_item")
+                continue;
+            const pt = asString(payload["type"]);
+            const role = asString(payload["role"]);
+            if (pt === "message" && role === "user") {
+                flushAssistant(messages, pending, model, ts);
+                const userText = flattenCodexContent(payload["content"]).trim();
+                if (!userText || isProbablyInjection(userText) || userText === lastUserText)
+                    continue;
+                lastUserText = userText;
+                if (!title)
+                    title = oneLine(firstMeaningfulLine(userText) || userText);
+                messages.push({ role: "user", text: userText, timestamp: ts });
+                continue;
+            }
+            if (pt === "message" && role === "assistant") {
+                const textOut = flattenCodexContent(payload["content"]).trim();
+                if (textOut)
+                    pending.push({ type: "text", text: truncateText(textOut, MAX_TEXT_CHARS) });
+                flushAssistant(messages, pending, model, ts);
+                continue;
+            }
+            if (pt === "reasoning") {
+                const summary = payload["summary"];
+                const bits = [];
+                if (Array.isArray(summary)) {
+                    for (const item of summary) {
+                        if (typeof item === "string")
+                            bits.push(item);
+                        else {
+                            const rec = asRecord(item);
+                            const t = rec ? asString(rec["text"]) : undefined;
+                            if (t)
+                                bits.push(t);
+                        }
+                    }
+                }
+                const thinking = bits.join("\n").trim();
+                if (thinking)
+                    pending.push({ type: "thinking", thinking: truncateText(thinking, MAX_TEXT_CHARS) });
+                continue;
+            }
+            if (pt === "function_call" || pt === "custom_tool_call") {
+                const id = asString(payload["call_id"]) ?? asString(payload["id"]) ?? "";
+                const name = asString(payload["name"]) ?? "unknown";
+                if (!id)
+                    continue;
+                const mapped = mapToolName(name);
+                pendingTools.set(id, mapped);
+                pending.push({
+                    type: "toolCall",
+                    id,
+                    name: mapped,
+                    arguments: remapToolArgs(name, argsFromCall(payload)),
+                });
+                continue;
+            }
+            if (pt === "function_call_output" || pt === "custom_tool_call_output") {
+                flushAssistant(messages, pending, model, ts);
+                const id = asString(payload["call_id"]) ?? asString(payload["id"]) ?? "";
+                if (!id)
+                    continue;
+                const output = payload["output"];
+                let textOut = "";
+                if (typeof output === "string")
+                    textOut = output;
+                else {
+                    const rec = asRecord(output);
+                    textOut = rec ? (asString(rec["output"]) ?? JSON.stringify(output)) : String(output ?? "");
+                }
+                messages.push({
+                    role: "toolResult",
+                    toolCallId: id,
+                    toolName: pendingTools.get(id) ?? "unknown",
+                    text: truncateText(textOut, MAX_TOOL_RESULT_CHARS),
+                    isError: false,
+                    timestamp: ts,
+                });
+            }
+        }
+        flushAssistant(messages, pending, model, lastTs);
+        return { cwd: cwd || session.cwd || process.cwd(), title, messages };
+    },
+};