@someonegg/codex-hub 0.0.0-stage → 0.1.1

package/dist/server/server/adapters/codex/rollout-decoder.js

@@ -0,0 +1,286 @@
+import { createHash } from "node:crypto";
+import { open } from "node:fs/promises";
+import { DECODER_VERSION, MAX_JSONL_LINE_BYTES, MAX_SESSION_DIAGNOSTICS } from "./limits.js";
+const PROBE_BYTES = 4 * 1024;
+export class CheckpointedRolloutDecoder {
+    async decode(descriptor, checkpoint) {
+        const handle = await open(descriptor.canonicalPath, "r");
+        try {
+            const observedEof = (await handle.stat()).size;
+            let probeBytes = 0;
+            let appendCheckpoint = null;
+            let validatedWindows = [];
+            if (isCompatibleCheckpoint(checkpoint, observedEof)) {
+                const validation = await validateProbes(handle, checkpoint);
+                probeBytes += validation.bytesRead;
+                if (validation.matches) {
+                    appendCheckpoint = checkpoint;
+                    validatedWindows = validation.windows;
+                }
+            }
+            const start = appendCheckpoint?.committedOffset ?? 0;
+            const baseOrdinal = appendCheckpoint?.physicalLineCount ?? 0;
+            const priorDiagnostics = appendCheckpoint?.diagnostics ?? [];
+            const decoded = await decodeRange(handle, start, observedEof, baseOrdinal, priorDiagnostics);
+            const probes = createProbes(observedEof, [
+                ...validatedWindows,
+                { offset: start, contents: decoded.headBytes },
+                { offset: decoded.tailOffset, contents: decoded.tailBytes },
+            ]);
+            const checkpointDiagnostics = decoded.diagnostics.map(cloneDiagnostic);
+            const nextCheckpoint = {
+                decoderVersion: DECODER_VERSION,
+                observedEof,
+                committedOffset: decoded.committedOffset,
+                physicalLineCount: decoded.physicalLineCount,
+                diagnostics: checkpointDiagnostics,
+                headProbe: probes.head,
+                tailProbe: probes.tail,
+            };
+            return {
+                descriptor,
+                records: decoded.records,
+                diagnostics: checkpointDiagnostics.map(cloneDiagnostic),
+                batchDiagnostics: decoded.batchDiagnostics.map(cloneDiagnostic),
+                mode: appendCheckpoint === null ? "full" : "append",
+                checkpoint: nextCheckpoint,
+                telemetry: {
+                    probeBytes,
+                    decodeBytes: decoded.bytesRead,
+                    totalBytes: probeBytes + decoded.bytesRead,
+                },
+            };
+        }
+        finally {
+            await handle.close();
+        }
+    }
+}
+async function decodeRange(handle, start, observedEof, baseOrdinal, priorDiagnostics) {
+    const records = [];
+    const diagnostics = priorDiagnostics.slice(0, MAX_SESSION_DIAGNOSTICS).map(cloneDiagnostic);
+    const batchDiagnostics = [];
+    const lineChunks = [];
+    let lineBytes = 0;
+    let ordinal = baseOrdinal;
+    let committedOffset = start;
+    let bytesRead = 0;
+    let droppingOversizedLine = false;
+    const headParts = [];
+    let headLength = 0;
+    let tailBytes = Buffer.alloc(0);
+    if (start < observedEof) {
+        const stream = handle.createReadStream({
+            autoClose: false,
+            start,
+            end: observedEof - 1,
+        });
+        for await (const rawChunk of stream) {
+            const chunk = rawChunk;
+            bytesRead += chunk.length;
+            if (headLength < PROBE_BYTES) {
+                const part = chunk.subarray(0, PROBE_BYTES - headLength);
+                headParts.push(part);
+                headLength += part.length;
+            }
+            tailBytes = tailWindow(tailBytes, chunk);
+            let cursor = 0;
+            while (cursor < chunk.length) {
+                const newline = chunk.indexOf(0x0a, cursor);
+                const end = newline < 0 ? chunk.length : newline;
+                if (!droppingOversizedLine && end > cursor) {
+                    const part = chunk.subarray(cursor, end);
+                    lineBytes += part.length;
+                    // Keep one possible trailing CR until the newline decides whether it
+                    // is part of a CRLF terminator. decodeLine applies the final limit
+                    // after stripping that CR.
+                    if (lineBytes > MAX_JSONL_LINE_BYTES + 1) {
+                        lineChunks.length = 0;
+                        droppingOversizedLine = true;
+                    }
+                    else {
+                        lineChunks.push(part);
+                    }
+                }
+                if (newline < 0)
+                    break;
+                ordinal += 1;
+                committedOffset = start + bytesRead - (chunk.length - newline - 1);
+                if (droppingOversizedLine) {
+                    retainDiagnostic(diagnostics, batchDiagnostics, lineTooLargeDiagnostic(ordinal));
+                }
+                else {
+                    decodeLine(lineBuffer(lineChunks, lineBytes), ordinal, records, diagnostics, batchDiagnostics);
+                }
+                lineChunks.length = 0;
+                lineBytes = 0;
+                droppingOversizedLine = false;
+                cursor = newline + 1;
+            }
+        }
+    }
+    return {
+        records,
+        diagnostics,
+        batchDiagnostics,
+        committedOffset,
+        physicalLineCount: ordinal,
+        bytesRead,
+        headBytes: Buffer.concat(headParts, headLength),
+        tailBytes,
+        tailOffset: observedEof - tailBytes.length,
+    };
+}
+function lineBuffer(chunks, length) {
+    if (chunks.length === 0)
+        return Buffer.alloc(0);
+    if (chunks.length === 1)
+        return chunks[0];
+    return Buffer.concat(chunks, length);
+}
+function decodeLine(rawLine, ordinal, records, diagnostics, batchDiagnostics) {
+    const line = rawLine.at(-1) === 0x0d ? rawLine.subarray(0, -1) : rawLine;
+    if (line.length === 0)
+        return;
+    if (line.length > MAX_JSONL_LINE_BYTES) {
+        retainDiagnostic(diagnostics, batchDiagnostics, lineTooLargeDiagnostic(ordinal));
+        return;
+    }
+    try {
+        const value = JSON.parse(line.toString("utf8"));
+        if (!isObject(value)) {
+            retainDiagnostic(diagnostics, batchDiagnostics, {
+                code: "invalid_record",
+                severity: "warning",
+                message: "A rollout line was not a JSON object and was skipped.",
+                ordinal,
+            });
+            return;
+        }
+        records.push({ ordinal, value });
+    }
+    catch {
+        retainDiagnostic(diagnostics, batchDiagnostics, {
+            code: "malformed_json",
+            severity: "warning",
+            message: "A malformed rollout line was skipped.",
+            ordinal,
+        });
+    }
+}
+function lineTooLargeDiagnostic(ordinal) {
+    return {
+        code: "line_too_large",
+        severity: "warning",
+        message: "A rollout record exceeded the decode limit and was skipped.",
+        ordinal,
+    };
+}
+function retainDiagnostic(diagnostics, batchDiagnostics, diagnostic) {
+    if (diagnostics.length < MAX_SESSION_DIAGNOSTICS) {
+        diagnostics.push(cloneDiagnostic(diagnostic));
+        batchDiagnostics.push(cloneDiagnostic(diagnostic));
+    }
+}
+function isCompatibleCheckpoint(checkpoint, observedEof) {
+    return (checkpoint !== undefined &&
+        checkpoint.decoderVersion === DECODER_VERSION &&
+        Number.isSafeInteger(checkpoint.observedEof) &&
+        Number.isSafeInteger(checkpoint.committedOffset) &&
+        Number.isSafeInteger(checkpoint.physicalLineCount) &&
+        checkpoint.observedEof >= checkpoint.committedOffset &&
+        checkpoint.committedOffset >= 0 &&
+        checkpoint.physicalLineCount >= 0 &&
+        checkpoint.diagnostics.length <= MAX_SESSION_DIAGNOSTICS &&
+        validProbeGeometry(checkpoint) &&
+        observedEof > checkpoint.observedEof);
+}
+function validProbeGeometry(checkpoint) {
+    const headLength = Math.min(PROBE_BYTES, checkpoint.observedEof);
+    const tailOffset = Math.max(0, checkpoint.observedEof - PROBE_BYTES);
+    return (checkpoint.headProbe.offset === 0 &&
+        checkpoint.headProbe.length === headLength &&
+        checkpoint.tailProbe.offset === tailOffset &&
+        checkpoint.tailProbe.length === checkpoint.observedEof - tailOffset);
+}
+async function validateProbes(handle, checkpoint) {
+    const head = await readProbe(handle, checkpoint.headProbe);
+    const tail = await readProbe(handle, checkpoint.tailProbe);
+    return {
+        matches: head.matches && tail.matches,
+        bytesRead: head.bytesRead + tail.bytesRead,
+        windows: [
+            { offset: checkpoint.headProbe.offset, contents: head.contents },
+            { offset: checkpoint.tailProbe.offset, contents: tail.contents },
+        ],
+    };
+}
+function createProbes(observedEof, windows) {
+    const headLength = Math.min(PROBE_BYTES, observedEof);
+    const tailOffset = Math.max(0, observedEof - PROBE_BYTES);
+    return {
+        head: probeFromWindows(0, headLength, windows),
+        tail: probeFromWindows(tailOffset, observedEof - tailOffset, windows),
+    };
+}
+async function probeAt(handle, offset, length) {
+    const buffer = Buffer.alloc(length);
+    let bytesRead = 0;
+    if (length > 0) {
+        ({ bytesRead } = await handle.read(buffer, 0, length, offset));
+    }
+    const contents = buffer.subarray(0, bytesRead);
+    return {
+        probe: {
+            offset,
+            length: bytesRead,
+            sha256: sha256(contents),
+        },
+        bytesRead,
+        contents,
+    };
+}
+async function readProbe(handle, expected) {
+    if (!Number.isSafeInteger(expected.offset) ||
+        expected.offset < 0 ||
+        !Number.isSafeInteger(expected.length) ||
+        expected.length < 0)
+        return { matches: false, bytesRead: 0, contents: Buffer.alloc(0) };
+    const actual = await probeAt(handle, expected.offset, expected.length);
+    const contents = actual.contents;
+    return {
+        matches: actual.probe.length === expected.length && actual.probe.sha256 === expected.sha256,
+        bytesRead: actual.bytesRead,
+        contents,
+    };
+}
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function tailWindow(previous, chunk) {
+    if (chunk.length >= PROBE_BYTES)
+        return chunk.subarray(chunk.length - PROBE_BYTES);
+    const keep = Math.min(previous.length, PROBE_BYTES - chunk.length);
+    return Buffer.concat([previous.subarray(previous.length - keep), chunk], keep + chunk.length);
+}
+function probeFromWindows(offset, length, windows) {
+    const contents = Buffer.alloc(length);
+    let cursor = offset;
+    while (cursor < offset + length) {
+        const window = windows.find(({ offset: windowOffset, contents: value }) => cursor >= windowOffset && cursor < windowOffset + value.length);
+        if (window === undefined) {
+            throw new Error("Decoder probe bytes were not retained");
+        }
+        const sourceStart = cursor - window.offset;
+        const copied = window.contents.copy(contents, cursor - offset, sourceStart, Math.min(window.contents.length, sourceStart + offset + length - cursor));
+        cursor += copied;
+    }
+    return { offset, length, sha256: sha256(contents) };
+}
+function cloneDiagnostic(value) {
+    return { ...value };
+}
+export function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=rollout-decoder.js.map

package/dist/server/server/adapters/codex/session-index-reader.js

@@ -0,0 +1,101 @@
+import { open } from "node:fs/promises";
+import { join } from "node:path";
+import { normalizeSessionTitle } from "../../domain/session-text.js";
+import { MAX_JSONL_LINE_BYTES } from "./limits.js";
+export class SessionIndexReader {
+    #path;
+    #fingerprint = null;
+    #threadNames = new Map();
+    constructor(codexHome) {
+        this.#path = join(codexHome, "session_index.jsonl");
+    }
+    async refresh() {
+        let handle;
+        try {
+            handle = await open(this.#path, "r");
+            const info = await handle.stat();
+            const fingerprint = { size: info.size, mtimeMs: info.mtimeMs };
+            if (sameFingerprint(this.#fingerprint, fingerprint))
+                return;
+            const threadNames = info.size === 0
+                ? new Map()
+                : await readCompleteRecords(handle.createReadStream({ start: 0, end: info.size - 1, autoClose: false }));
+            this.#threadNames = threadNames;
+            this.#fingerprint = fingerprint;
+        }
+        catch {
+            this.#threadNames = new Map();
+            this.#fingerprint = null;
+        }
+        finally {
+            await handle?.close().catch(() => undefined);
+        }
+    }
+    threadName(id) {
+        return this.#threadNames.get(id) ?? null;
+    }
+}
+async function readCompleteRecords(stream) {
+    const threadNames = new Map();
+    let parts = [];
+    let bytes = 0;
+    let droppingOversizedLine = false;
+    for await (const rawChunk of stream) {
+        const chunk = typeof rawChunk === "string" ? Buffer.from(rawChunk) : rawChunk;
+        let cursor = 0;
+        while (cursor < chunk.length) {
+            const newline = chunk.indexOf(0x0a, cursor);
+            const end = newline === -1 ? chunk.length : newline;
+            const part = chunk.subarray(cursor, end);
+            if (!droppingOversizedLine) {
+                if (bytes + part.length <= MAX_JSONL_LINE_BYTES) {
+                    if (part.length > 0)
+                        parts.push(part);
+                    bytes += part.length;
+                }
+                else {
+                    parts = [];
+                    bytes = 0;
+                    droppingOversizedLine = true;
+                }
+            }
+            if (newline === -1)
+                break;
+            if (!droppingOversizedLine)
+                consumeLine(Buffer.concat(parts, bytes), threadNames);
+            parts = [];
+            bytes = 0;
+            droppingOversizedLine = false;
+            cursor = newline + 1;
+        }
+    }
+    // An unterminated tail may still be in flight, so it is deliberately ignored.
+    return threadNames;
+}
+function consumeLine(line, threadNames) {
+    try {
+        const value = JSON.parse(line.toString("utf8"));
+        if (!isObject(value))
+            return;
+        const id = nonEmptyString(value.id);
+        const threadName = nonEmptyString(value.thread_name);
+        if (id === null || threadName === null)
+            return;
+        const normalized = normalizeSessionTitle(threadName);
+        if (normalized !== null)
+            threadNames.set(id, normalized);
+    }
+    catch {
+        // session_index.jsonl is advisory; malformed records do not affect sessions.
+    }
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sameFingerprint(left, right) {
+    return left !== null && left.size === right.size && left.mtimeMs === right.mtimeMs;
+}
+//# sourceMappingURL=session-index-reader.js.map

package/dist/server/server/adapters/codex/session-manager.js

@@ -0,0 +1,65 @@
+import { execFile } from "node:child_process";
+import { realpath, stat } from "node:fs/promises";
+import { promisify } from "node:util";
+import { validProjectDirectory } from "../../domain/project-directory.js";
+import { TmuxLauncher } from "../../interaction/tmux-launcher.js";
+import { codexBindingCommand } from "./interaction-parser.js";
+const execute = promisify(execFile);
+export class CodexSessionManager {
+    home;
+    tmux;
+    constructor(home, tmux = new TmuxLauncher()) {
+        this.home = home;
+        this.tmux = tmux;
+    }
+    async resolveDirectory(input) {
+        if (!validProjectDirectory(input))
+            throw new Error("Directory must be an absolute local path");
+        const directory = await realpath(input);
+        if (!(await stat(directory)).isDirectory())
+            throw Object.assign(new Error("Path is not a directory"), { code: "ENOTDIR" });
+        return { directory };
+    }
+    isValidNativeId(nativeId) {
+        return /^[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/i.test(nativeId);
+    }
+    launch({ operationId, directory, worktree, yolo, resumeNativeId, projectDirectory, }) {
+        if (resumeNativeId !== undefined && !this.isValidNativeId(resumeNativeId))
+            throw new Error("Invalid resume identity");
+        return this.tmux.launch(operationId, directory, [
+            "env",
+            `CODEX_HOME=${this.home}`,
+            "codex",
+            ...(resumeNativeId ? ["resume", resumeNativeId] : []),
+            "--no-daemon",
+            "--no-alt-screen",
+            ...(worktree ? ["--worktree"] : []),
+            ...(yolo ? ["--yolo"] : []),
+            codexBindingCommand(operationId, projectDirectory),
+        ]);
+    }
+    exitSteps() {
+        return [
+            { keys: ["C-c"], delayMs: 0 },
+            { keys: ["C-c"], delayMs: 1_000 },
+            { keys: ["C-c"], delayMs: 1_000 },
+        ];
+    }
+    async archive(nativeId) {
+        await this.#command(["archive", nativeId]);
+    }
+    async delete(nativeId) {
+        await this.#command(["delete", nativeId, "--force"]);
+    }
+    async #command(args) {
+        if (!this.isValidNativeId(args[1]))
+            throw new Error("Session has no valid native UUID");
+        await execute("codex", args, {
+            env: { ...process.env, CODEX_HOME: this.home },
+            timeout: 25_000,
+            maxBuffer: 64 * 1024,
+        });
+    }
+}
+export const createCodexSessionManager = (home, socket) => new CodexSessionManager(home, new TmuxLauncher(socket));
+//# sourceMappingURL=session-manager.js.map