@someonegg/codex-hub 0.0.0-stage → 0.1.0

package/dist/server/server/adapters/codex/interaction-parser.js

@@ -0,0 +1,90 @@
+import { isAbsolute } from "node:path";
+import { validProjectDirectory } from "../../domain/project-directory.js";
+import { isObject } from "./rollout-decoder.js";
+export const CODEX_INTERACTION_KEY_BINDINGS = {
+    enter: "Enter",
+    up: "Up",
+    down: "Down",
+    left: "Left",
+    right: "Right",
+    interrupt: "C-c",
+    plan: "BTab",
+};
+export function codexInteraction(projectDirectory) {
+    return {
+        transport: "tmux",
+        bindingCommand: codexBindingCommand(undefined, projectDirectory),
+        keyBindings: CODEX_INTERACTION_KEY_BINDINGS,
+    };
+}
+export function codexBindingAttemptsFrom(record) {
+    if (record.value.type !== "response_item")
+        return [];
+    const metadata = record.value.metadata;
+    if (isObject(metadata) && metadata.inherited_user_message === true)
+        return [];
+    const payload = record.value.payload;
+    if (!isObject(payload) || payload.type !== "message" || payload.role !== "user") {
+        return [];
+    }
+    const text = contentText(payload.content);
+    if (text === null || !text.includes("<user_shell_command>"))
+        return [];
+    const shellBlocks = [...text.matchAll(/<user_shell_command>([\s\S]*?)<\/user_shell_command>/g)];
+    const found = [];
+    for (const block of shellBlocks) {
+        const lines = (block[1] ?? "").split("\n").map((line) => line.replace(/\r$/, ""));
+        for (let index = 0; index < lines.length; index += 1) {
+            if (!["CODEX_HUB_TMUX_BIND_V3", "CODEX_HUB_TMUX_BIND_V4"].includes(lines[index]))
+                continue;
+            const project = lines[index] === "CODEX_HUB_TMUX_BIND_V4" ? lines[index + 4] : undefined;
+            const tmux = lines[index + 1] ?? "";
+            const paneId = lines[index + 2] ?? "";
+            const operationId = lines[index + 3] ?? "";
+            found.push(isAbsolute(tmux) && /^%\d+$/.test(paneId) && (!operationId || validOperationId(operationId))
+                ? {
+                    ordinal: record.ordinal,
+                    valid: true,
+                    socketPath: tmux,
+                    paneId,
+                    ...(operationId ? { operationId } : {}),
+                    ...(validProjectDirectory(project) ? { projectDirectory: project } : {}),
+                }
+                : { ordinal: record.ordinal, valid: false });
+        }
+    }
+    const lastOpen = text.lastIndexOf("<user_shell_command>");
+    const lastClose = text.lastIndexOf("</user_shell_command>");
+    if (lastOpen > lastClose) {
+        const incomplete = text.slice(lastOpen + "<user_shell_command>".length);
+        const incompleteLines = incomplete.replace(/\r\n?/g, "\n").split("\n");
+        for (const line of incompleteLines) {
+            if (/^CODEX_HUB_TMUX_BIND_V[34]$/.test(line))
+                found.push({ ordinal: record.ordinal, valid: false });
+        }
+    }
+    return found;
+}
+function contentText(value) {
+    if (!Array.isArray(value))
+        return null;
+    const parts = [];
+    for (const part of value) {
+        if (!isObject(part) || typeof part.text !== "string")
+            continue;
+        if (part.type === "input_text" || part.type === "text")
+            parts.push(part.text);
+    }
+    return parts.length === 0 ? null : parts.join("\n\n");
+}
+export function codexBindingCommand(operationId, projectDirectory) {
+    if (operationId !== undefined && !validOperationId(operationId))
+        throw new Error("Invalid operation ID");
+    const quote = (value) => "'" + value.replaceAll("'", "'\"'\"'") + "'";
+    const project = validProjectDirectory(projectDirectory) ? projectDirectory : "";
+    return `! printf 'CODEX_HUB_TMUX_BIND_V4\\n%s\\n%s\\n%s\\n%s\\n' "$(tmux display-message -p '#{socket_path}')" "$TMUX_PANE" ${quote(operationId ?? "")} ${quote(project)}`;
+}
+function validOperationId(id) {
+    return /^[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/i.test(id);
+}
+//# sourceMappingURL=interaction-parser.js.map

package/dist/server/server/adapters/codex/internal-event-parser.js

@@ -0,0 +1,56 @@
+import { truncateText } from "../../domain/session-text.js";
+import { MAX_INTERNAL_DETAIL_CHARS } from "./limits.js";
+import { isObject } from "./rollout-decoder.js";
+export function internalItem(ordinal, timestamp, eventType) {
+    const safeType = truncateText(eventType.replaceAll(/[^A-Za-z0-9_.:-]/g, "_"), 80).text;
+    return {
+        kind: "internal",
+        id: `internal-${ordinal}`,
+        ordinal,
+        timestamp,
+        eventType: safeType,
+    };
+}
+export function internalDetail(value) {
+    const json = JSON.stringify(value, null, 2);
+    const detail = truncateText(json, MAX_INTERNAL_DETAIL_CHARS);
+    return { json: detail.text, truncated: detail.truncated };
+}
+export function internalItemFromPayload(ordinal, timestamp, payload) {
+    const eventType = string(payload.type) ?? "event";
+    if (eventType !== "token_count") {
+        const subtype = eventType === "item_completed" && isObject(payload.item) ? string(payload.item.type) : null;
+        return internalItem(ordinal, timestamp, subtype === null ? eventType : `${eventType}.${subtype}`);
+    }
+    const info = isObject(payload.info) ? payload.info : null;
+    return {
+        kind: "token",
+        id: `token-${ordinal}`,
+        ordinal,
+        timestamp,
+        tokenUsage: {
+            total: tokenUsageCounters(info?.total_token_usage),
+            last: tokenUsageCounters(info?.last_token_usage),
+        },
+    };
+}
+function tokenUsageCounters(value) {
+    if (!isObject(value))
+        return null;
+    const counters = {
+        totalTokens: tokenCount(value.total_tokens),
+        inputTokens: tokenCount(value.input_tokens),
+        cachedInputTokens: tokenCount(value.cached_input_tokens),
+        cacheWriteInputTokens: tokenCount(value.cache_write_input_tokens),
+        outputTokens: tokenCount(value.output_tokens),
+        reasoningOutputTokens: tokenCount(value.reasoning_output_tokens),
+    };
+    return Object.values(counters).some((count) => count !== null) ? counters : null;
+}
+function tokenCount(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function string(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+//# sourceMappingURL=internal-event-parser.js.map

package/dist/server/server/adapters/codex/io-errors.js

@@ -0,0 +1,5 @@
+const EXPECTED_IO_ERRORS = new Set(["ENOENT", "EACCES", "EPERM", "ESTALE", "EISDIR", "ENOTDIR"]);
+export function isExpectedIoError(error) {
+    return error instanceof Error && "code" in error && EXPECTED_IO_ERRORS.has(String(error.code));
+}
+//# sourceMappingURL=io-errors.js.map

package/dist/server/server/adapters/codex/jsonl-catalog-source.js

@@ -0,0 +1,58 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { isExpectedIoError } from "./io-errors.js";
+export class JsonlCatalogSource {
+    policy;
+    archivedDescriptors;
+    constructor(policy, archivedDescriptors = new Map()) {
+        this.policy = policy;
+        this.archivedDescriptors = archivedDescriptors;
+    }
+    async discover() {
+        const descriptors = new Map();
+        const diagnostics = [];
+        for (const root of this.policy.roots()) {
+            await scan(root.canonicalPath, async (candidate, regularFile) => {
+                // Only reuse successfully loaded archives still enumerated as regular files
+                // under the same canonical root. New paths and symlinks retain validation.
+                const cached = root.archived && regularFile ? this.archivedDescriptors.get(candidate) : undefined;
+                const descriptor = cached ?? (await this.policy.register(candidate));
+                if (descriptor !== null)
+                    descriptors.set(descriptor.canonicalPath, descriptor);
+            }, diagnostics);
+        }
+        const entries = [...descriptors.values()]
+            .sort((left, right) => left.canonicalPath.localeCompare(right.canonicalPath))
+            .map((descriptor) => ({ descriptor }));
+        return {
+            entries,
+            diagnostics: [...this.policy.diagnostics, ...diagnostics].slice(0, 50),
+        };
+    }
+}
+async function scan(directory, visit, diagnostics) {
+    let entries;
+    try {
+        entries = await readdir(directory, { withFileTypes: true });
+    }
+    catch (error) {
+        if (!isExpectedIoError(error))
+            throw error;
+        if (diagnostics.length < 50)
+            diagnostics.push({
+                code: "session_root_unreadable",
+                severity: "warning",
+                message: "An allowlisted session directory could not be read.",
+                ordinal: null,
+            });
+        return;
+    }
+    for (const entry of entries) {
+        const path = join(directory, entry.name);
+        if (entry.isDirectory())
+            await scan(path, visit, diagnostics);
+        else if (entry.isFile() || entry.isSymbolicLink())
+            await visit(path, entry.isFile());
+    }
+}
+//# sourceMappingURL=jsonl-catalog-source.js.map

package/dist/server/server/adapters/codex/limits.js

@@ -0,0 +1,10 @@
+export const DECODER_VERSION = 4;
+export const NORMALIZER_VERSION = 6;
+export const MAX_JSONL_LINE_BYTES = 8 * 1024 * 1024;
+export const MAX_SESSION_DIAGNOSTICS = 50;
+export const MAX_MESSAGE_CHARS = 1_000_000;
+export const MAX_TOOL_DETAIL_CHARS = 256_000;
+export const MAX_DIRECTIVE_CHARS = 256_000;
+export const MAX_INLINE_DIRECTIVE_CHARS = 512;
+export const MAX_INTERNAL_DETAIL_CHARS = 256_000;
+//# sourceMappingURL=limits.js.map

package/dist/server/server/adapters/codex/message-normalizer.js

@@ -0,0 +1,121 @@
+import { MAX_PREVIEW_CHARS, truncateText } from "../../domain/session-text.js";
+import { MAX_DIRECTIVE_CHARS, MAX_INLINE_DIRECTIVE_CHARS, MAX_MESSAGE_CHARS } from "./limits.js";
+import { isObject } from "./rollout-decoder.js";
+export function responseDirective(ordinal, timestamp, payload) {
+    const role = payload.role;
+    if (role !== "user" && role !== "assistant" && role !== "developer")
+        return null;
+    const text = contentText(payload.content);
+    if (text === null)
+        return null;
+    const id = `directive-${ordinal}`;
+    if (text.length <= MAX_INLINE_DIRECTIVE_CHARS) {
+        return {
+            item: {
+                kind: "directive",
+                id,
+                ordinal,
+                timestamp,
+                text,
+                hasDetail: false,
+            },
+            detail: null,
+        };
+    }
+    const detail = truncateText(text, MAX_DIRECTIVE_CHARS);
+    return {
+        item: {
+            kind: "directive",
+            id,
+            ordinal,
+            timestamp,
+            summary: directiveSummary(text),
+            charCount: text.length,
+            hasDetail: true,
+        },
+        detail,
+    };
+}
+export function eventMessage(ordinal, timestamp, payload) {
+    const type = string(payload.type);
+    if (type === "user_message" || type === "agent_message") {
+        const markdown = string(payload.message);
+        if (markdown === null)
+            return null;
+        const role = type === "user_message" ? "user" : "assistant";
+        const phase = type === "agent_message" ? normalizePhase(payload.phase) : null;
+        return messageItem(ordinal, timestamp, role, phase, null, markdown);
+    }
+    if (type !== "item_completed" || !isObject(payload.item))
+        return null;
+    const item = payload.item;
+    const itemType = string(item.type);
+    if (itemType === "UserMessage") {
+        const markdown = itemContentText(item.content, "text");
+        return markdown === null ? null : messageItem(ordinal, timestamp, "user", null, null, markdown);
+    }
+    if (itemType === "AgentMessage") {
+        const markdown = itemContentText(item.content, "Text");
+        return markdown === null
+            ? null
+            : messageItem(ordinal, timestamp, "assistant", normalizePhase(item.phase), null, markdown);
+    }
+    if (itemType !== "Plan")
+        return null;
+    const markdown = string(item.text);
+    return markdown === null
+        ? null
+        : messageItem(ordinal, timestamp, "assistant", "final", itemType, markdown);
+}
+function messageItem(ordinal, timestamp, role, phase, itemType, markdown) {
+    return {
+        kind: "message",
+        id: `message-${ordinal}`,
+        ordinal,
+        timestamp,
+        role,
+        phase,
+        itemType: itemType === null ? null : truncateText(itemType, MAX_MESSAGE_CHARS).text,
+        markdown: truncateText(markdown, MAX_MESSAGE_CHARS).text,
+    };
+}
+function directiveSummary(value) {
+    const firstLine = value
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean);
+    return truncateText(firstLine ?? "Directive", MAX_PREVIEW_CHARS).text;
+}
+function contentText(value) {
+    if (!Array.isArray(value))
+        return null;
+    const text = value
+        .filter(isObject)
+        .filter((part) => ["input_text", "output_text", "text"].includes(string(part.type) ?? ""))
+        .map((part) => string(part.text))
+        .filter((part) => part !== null)
+        .join("\n\n");
+    return text.length === 0 ? null : text;
+}
+function itemContentText(value, acceptedType) {
+    if (!Array.isArray(value))
+        return null;
+    const text = value
+        .filter(isObject)
+        .filter((part) => part.type === acceptedType)
+        .map((part) => string(part.text))
+        .filter((part) => part !== null)
+        .join("\n\n");
+    return text.length === 0 ? null : text;
+}
+function normalizePhase(value) {
+    if (value === "commentary")
+        return "commentary";
+    if (value === "final" || value === "final_answer")
+        return "final";
+    return null;
+}
+function string(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+//# sourceMappingURL=message-normalizer.js.map

package/dist/server/server/adapters/codex/path-policy.js

@@ -0,0 +1,88 @@
+import { lstat, realpath, stat } from "node:fs/promises";
+import { basename, relative, resolve, sep } from "node:path";
+import { opaqueIdForPath } from "../../security/opaque-id.js";
+import { isExpectedIoError } from "./io-errors.js";
+const ROLLOUT_NAME = /^rollout-[A-Za-z0-9][A-Za-z0-9._-]*\.jsonl$/;
+export class PathPolicy {
+    diagnostics = [];
+    #roots;
+    constructor(roots) {
+        this.#roots = roots;
+    }
+    static async create(codexHome) {
+        const configured = [
+            { path: resolve(codexHome, "sessions"), archived: false },
+            { path: resolve(codexHome, "archived_sessions"), archived: true },
+        ];
+        const roots = [];
+        const policy = new PathPolicy(roots);
+        for (const root of configured) {
+            try {
+                const canonicalPath = await realpath(root.path);
+                const info = await stat(canonicalPath);
+                if (!info.isDirectory()) {
+                    throw Object.assign(new Error("Session root is not a directory"), { code: "ENOTDIR" });
+                }
+                roots.push({ canonicalPath, archived: root.archived });
+            }
+            catch (error) {
+                if (!isExpectedIoError(error))
+                    throw error;
+                if (error.code !== "ENOENT") {
+                    policy.unreadable("session_root_unreadable");
+                }
+                // An absent allowlisted root is normal for a new or unarchived Codex home.
+            }
+        }
+        return policy;
+    }
+    unreadable(code) {
+        if (this.diagnostics.length >= 50)
+            return;
+        this.diagnostics.push({
+            code,
+            severity: "warning",
+            message: "An allowlisted session directory or rollout could not be read.",
+            ordinal: null,
+        });
+    }
+    roots() {
+        return this.#roots;
+    }
+    async register(candidatePath) {
+        if (!ROLLOUT_NAME.test(basename(candidatePath)))
+            return null;
+        try {
+            const linkInfo = await lstat(candidatePath);
+            if (linkInfo.isSymbolicLink())
+                return null;
+            const canonicalPath = await realpath(candidatePath);
+            const root = this.#roots.find((entry) => isWithin(entry.canonicalPath, canonicalPath));
+            if (root === undefined)
+                return null;
+            const info = await stat(canonicalPath);
+            if (!info.isFile())
+                return null;
+            const relativePath = relative(root.canonicalPath, canonicalPath).split(sep).join("/");
+            return {
+                id: opaqueIdForPath(canonicalPath),
+                canonicalPath,
+                sourceRelativePath: `${root.archived ? "archived_sessions" : "sessions"}/${relativePath}`,
+                archived: root.archived,
+                size: info.size,
+                mtimeMs: info.mtimeMs,
+            };
+        }
+        catch (error) {
+            if (!isExpectedIoError(error))
+                throw error;
+            this.unreadable("rollout_unavailable");
+            return null;
+        }
+    }
+}
+function isWithin(root, candidate) {
+    const child = relative(root, candidate);
+    return (child === "" || (!child.startsWith(`..${sep}`) && child !== ".." && !child.startsWith(sep)));
+}
+//# sourceMappingURL=path-policy.js.map

package/dist/server/server/adapters/codex/project-directory-resolver.js

@@ -0,0 +1,79 @@
+import { execFile } from "node:child_process";
+import { isAbsolute } from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const CACHE_TTL_MS = 30_000;
+const MAX_CONCURRENT_QUERIES = 4;
+/** Resolves local Git relationships without interpreting rollout message contents. */
+export class ProjectDirectoryResolver {
+    query;
+    now;
+    #cache = new Map();
+    #waiting = [];
+    #active = 0;
+    constructor(query = queryProjectDirectory, now = performance.now.bind(performance)) {
+        this.query = query;
+        this.now = now;
+    }
+    async resolveAll(workingDirectories) {
+        const unique = new Set(workingDirectories);
+        for (const key of this.#cache.keys()) {
+            if (!unique.has(key))
+                this.#cache.delete(key);
+        }
+        const pairs = await Promise.all([...unique].map(async (directory) => [directory, await this.resolve(directory)]));
+        return new Map(pairs);
+    }
+    async resolve(workingDirectory) {
+        if (workingDirectory === null)
+            return null;
+        const cached = this.#cache.get(workingDirectory);
+        if (cached !== undefined && cached.expiresAt > this.now())
+            return cached.result;
+        const entry = {
+            expiresAt: Number.POSITIVE_INFINITY,
+            result: this.#query(workingDirectory),
+        };
+        this.#cache.set(workingDirectory, entry);
+        void entry.result.then(() => {
+            entry.expiresAt = this.now() + CACHE_TTL_MS;
+        });
+        return entry.result;
+    }
+    async #query(workingDirectory) {
+        if (this.#active >= MAX_CONCURRENT_QUERIES) {
+            await new Promise((resolve) => this.#waiting.push(resolve));
+        }
+        else {
+            this.#active += 1;
+        }
+        try {
+            return (await this.query(workingDirectory)) ?? workingDirectory;
+        }
+        catch {
+            return workingDirectory;
+        }
+        finally {
+            const next = this.#waiting.shift();
+            if (next !== undefined)
+                next();
+            else
+                this.#active -= 1;
+        }
+    }
+}
+async function queryProjectDirectory(workingDirectory) {
+    if (!isAbsolute(workingDirectory))
+        return null;
+    // A Git environment inherited from the hub must not override the session's repository.
+    const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith("GIT_")));
+    const { stdout } = await execFileAsync("git", ["-C", workingDirectory, "worktree", "list", "--porcelain", "-z"], { env, timeout: 2_000, maxBuffer: 1024 * 1024, encoding: "utf8" });
+    const primary = stdout.split("\0\0", 1)[0].split("\0");
+    const header = primary[0];
+    if (header === undefined || !header.startsWith("worktree ") || primary.includes("bare")) {
+        return null;
+    }
+    const directory = header.slice("worktree ".length);
+    return isAbsolute(directory) ? directory : null;
+}
+//# sourceMappingURL=project-directory-resolver.js.map

package/dist/server/server/adapters/codex/response-item-parser.js

@@ -0,0 +1,100 @@
+import { internalItem } from "./internal-event-parser.js";
+import { responseDirective } from "./message-normalizer.js";
+import { isObject } from "./rollout-decoder.js";
+import { parseUserInputQuestions } from "./user-input-normalizer.js";
+export function parseResponseItem(ordinal, timestamp, payload) {
+    const type = string(payload.type);
+    if (type === "message") {
+        const directive = responseDirective(ordinal, timestamp, payload);
+        return directive === null ? { kind: "ignored" } : { kind: "directive", value: directive };
+    }
+    if (type === "reasoning") {
+        return {
+            kind: "timeline",
+            value: internalItem(ordinal, timestamp, "reasoning"),
+        };
+    }
+    const userInput = userInputRequest(ordinal, timestamp, payload);
+    if (userInput !== null)
+        return { kind: "user_input_request", value: userInput };
+    const call = toolCall(ordinal, timestamp, payload);
+    if (call !== null)
+        return { kind: "tool_call", value: call };
+    const output = toolOutput(ordinal, timestamp, payload);
+    if (output !== null)
+        return { kind: "tool_output", value: output };
+    return {
+        kind: "timeline",
+        value: internalItem(ordinal, timestamp, type ?? "response_item"),
+    };
+}
+function userInputRequest(ordinal, timestamp, payload) {
+    if (payload.type !== "function_call" || payload.name !== "request_user_input")
+        return null;
+    const callId = string(payload.call_id);
+    if (callId === null)
+        return null;
+    const questions = parseUserInputQuestions(payload.arguments);
+    return {
+        callId,
+        ordinal,
+        timestamp,
+        questions: questions ?? [],
+        malformed: questions === null,
+    };
+}
+function toolCall(ordinal, timestamp, payload) {
+    const type = string(payload.type);
+    if (type !== "function_call" && type !== "custom_tool_call")
+        return null;
+    const callId = string(payload.call_id);
+    if (callId === null)
+        return null;
+    return {
+        callId,
+        ordinal,
+        timestamp,
+        toolName: string(payload.name) ?? (type === "custom_tool_call" ? "custom tool" : "function"),
+        input: serializeText(payload.arguments ?? payload.input),
+    };
+}
+function toolOutput(ordinal, timestamp, payload) {
+    const type = string(payload.type);
+    if (type !== "function_call_output" && type !== "custom_tool_call_output")
+        return null;
+    const callId = string(payload.call_id);
+    if (callId === null)
+        return null;
+    return {
+        callId,
+        ordinal,
+        timestamp,
+        output: toolOutputText(payload.output),
+        failed: payload.success === false || payload.status === "failed",
+    };
+}
+function serializeText(value) {
+    if (typeof value === "string")
+        return value;
+    if (value === null || value === undefined)
+        return null;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return null;
+    }
+}
+function toolOutputText(value) {
+    if (!Array.isArray(value))
+        return serializeText(value);
+    const parts = value
+        .filter(isObject)
+        .map((part) => string(part.text) ?? string(part.output_text) ?? serializeText(part))
+        .filter((part) => part !== null);
+    return parts.length === 0 ? serializeText(value) : parts.join("\n\n");
+}
+function string(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+//# sourceMappingURL=response-item-parser.js.map