super-dsh 0.1.0 → 0.1.2

package/agent-codex/dist/codex-events.js

@@ -0,0 +1,297 @@
+/** Watermark of streamed agent_message text (item id → last emitted full text). */
+const textWatermark = new Map();
+/** Items whose tool_execution_start already fired (id → true). */
+const startedTools = new Set();
+/** Reset the projection watermarks (test / new-session hygiene). */
+export function resetProjectionState() {
+    textWatermark.clear();
+    startedTools.clear();
+}
+function asRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function asText(value) {
+    return typeof value === "string" ? value : "";
+}
+function textDelta(delta) {
+    const assistantMessageEvent = { type: "text_delta", contentIndex: 0, delta };
+    return { type: "message_update", assistantMessageEvent };
+}
+/**
+ * Identity of a codex tool item on the omp tool_execution_* wire: the display
+ * `args` object (omp parity) plus `argsJson` — the RAW JSON string the model
+ * produced, which is what the DSH `tool/call` payload requires. The SDK hands
+ * `mcp_tool_call.arguments` over as an unparsed string, so that one rides
+ * through verbatim; the other item shapes expose discrete fields (command,
+ * query, changes, items), so their string is the faithful JSON rendering of
+ * exactly those fields.
+ */
+function toolIdentity(item) {
+    const json = (value) => JSON.stringify(value);
+    switch (item.type) {
+        case "command_execution": {
+            const args = { command: asText(item.command) };
+            return { toolName: "command_execution", args, argsJson: json(args) };
+        }
+        case "mcp_tool_call": {
+            const args = asRecord(item.arguments) ?? {};
+            return {
+                toolName: asText(item.tool) || "mcp_tool_call",
+                args,
+                argsJson: typeof item.arguments === "string" ? item.arguments : json(args),
+            };
+        }
+        case "file_change": {
+            const args = { changes: Array.isArray(item.changes) ? item.changes : [] };
+            return { toolName: "file_change", args, argsJson: json(args) };
+        }
+        case "web_search": {
+            const args = { query: asText(item.query) };
+            return { toolName: "web_search", args, argsJson: json(args) };
+        }
+        case "todo_list": {
+            const args = { items: Array.isArray(item.items) ? item.items : [] };
+            return { toolName: "todo_list", args, argsJson: json(args) };
+        }
+        default:
+            return { toolName: asText(item.type) || "tool", args: {}, argsJson: "{}" };
+    }
+}
+/** Render a codex tool item's outcome as omp tool_execution_end result blocks. */
+function toolResult(item) {
+    switch (item.type) {
+        case "command_execution": {
+            const output = asText(item.aggregated_output);
+            return { content: [{ type: "text", text: output }], isError: item.status === "failed" };
+        }
+        case "mcp_tool_call": {
+            const result = asRecord(item.result);
+            const content = [];
+            const rawContent = result !== null && Array.isArray(result.content) ? result.content : [];
+            for (const block of rawContent) {
+                const record = asRecord(block);
+                // Only MCP text blocks bridge (omp parity: images/unknown are dropped).
+                if (record !== null && record.type === "text" && typeof record.text === "string") {
+                    content.push({ type: "text", text: record.text });
+                }
+            }
+            if (content.length === 0) {
+                const error = asRecord(item.error);
+                if (error !== null && typeof error.message === "string")
+                    content.push({ type: "text", text: error.message });
+            }
+            return { content, isError: item.status === "failed" };
+        }
+        case "file_change": {
+            const changes = Array.isArray(item.changes) ? item.changes : [];
+            const lines = [];
+            for (const change of changes) {
+                const record = asRecord(change);
+                if (record !== null)
+                    lines.push(`${asText(record.kind) || "update"} ${asText(record.path)}`);
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }], isError: item.status === "failed" };
+        }
+        case "web_search":
+            return { content: [{ type: "text", text: asText(item.query) }], isError: false };
+        case "todo_list": {
+            const items = Array.isArray(item.items) ? item.items : [];
+            const lines = [];
+            for (const entry of items) {
+                const record = asRecord(entry);
+                if (record !== null)
+                    lines.push(`${record.completed === true ? "[x]" : "[ ]"} ${asText(record.text)}`);
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }], isError: false };
+        }
+        default:
+            return { content: [], isError: false };
+    }
+}
+/**
+ * Codex `todo_list` items → the DSH `todo/write` whole-list snapshot payload
+ * (`TodoItem { content, status }`; upstream packages/todo/tool-todo). The
+ * whole list is replaced on every write (latest-wins); a codex item only
+ * carries the binary completed flag, so non-completed entries are `pending`.
+ */
+function todoSnapshot(items) {
+    const todos = [];
+    for (const entry of items) {
+        const record = asRecord(entry);
+        if (record === null)
+            continue;
+        const text = asText(record.text);
+        if (text === "")
+            continue;
+        todos.push({ content: text, status: record.completed === true ? "completed" : "pending" });
+    }
+    return todos;
+}
+function toolStart(item) {
+    const { toolName, args, argsJson } = toolIdentity(item);
+    const start = {
+        type: "tool_execution_start",
+        toolCallId: asText(item.id),
+        toolName,
+        args,
+        argumentsJson: argsJson,
+    };
+    if (item.type === "mcp_tool_call")
+        start.server = asText(item.server);
+    return start;
+}
+/**
+ * Terminal tool event for a completed/updated tool item. Emits the start first
+ * when this item's start was never projected (minimal chains), keeping the
+ * wire's start/end pairing intact without duplicate starts.
+ */
+function toolEnd(item) {
+    const id = asText(item.id);
+    const { toolName } = toolIdentity(item);
+    const result = toolResult(item);
+    const end = { type: "tool_execution_end", toolCallId: id, toolName, result, isError: result.isError };
+    if (item.type === "command_execution") {
+        end.command = asText(item.command);
+        if (typeof item.exit_code === "number")
+            end.exit_code = item.exit_code;
+    }
+    if (!startedTools.has(id)) {
+        // start never fired for this id (fixture-style minimal chain): emit the pair.
+        startedTools.add(id);
+        return [toolStart(item), end];
+    }
+    return end;
+}
+function projectItem(item, phase) {
+    const record = asRecord(item);
+    if (record === null)
+        return null;
+    const id = asText(record.id);
+    switch (record.type) {
+        case "agent_message": {
+            const text = asText(record.text);
+            if (phase === "started") {
+                textWatermark.set(id, text);
+                const start = { type: "message_start", message: { role: "assistant", content: [] } };
+                return text === "" ? start : [start, textDelta(text)];
+            }
+            if (phase === "updated") {
+                const previous = textWatermark.get(id) ?? "";
+                if (text === previous)
+                    return null;
+                const delta = text.startsWith(previous) ? text.slice(previous.length) : text;
+                textWatermark.set(id, text);
+                return textDelta(delta);
+            }
+            textWatermark.delete(id);
+            return {
+                type: "message_end",
+                message: { role: "assistant", content: [{ type: "text", text }] },
+            };
+        }
+        case "reasoning": {
+            const text = asText(record.text);
+            if (phase === "started") {
+                return {
+                    type: "message_start",
+                    message: { role: "assistant", content: [{ type: "thinking", thinking: text }] },
+                };
+            }
+            if (phase === "updated") {
+                // Deltas fold into the final thinking block (omp folds thinking_* too).
+                return null;
+            }
+            return {
+                type: "message_end",
+                message: { role: "assistant", content: [{ type: "thinking", thinking: text }] },
+            };
+        }
+        case "command_execution":
+        case "mcp_tool_call":
+        case "file_change":
+        case "web_search":
+        case "todo_list": {
+            if (phase === "started") {
+                startedTools.add(id);
+                return toolStart(record);
+            }
+            const terminal = record.status === "completed" || record.status === "failed";
+            if (phase === "updated") {
+                return terminal ? toolEnd(record) : null; // still in_progress → nothing new
+            }
+            const events = toolEnd(record); // completed is terminal by definition (toolEnd dedups the start)
+            if (record.type !== "todo_list")
+                return events;
+            // `item.todo_list` ALSO projects the DSH `todo/write` whole-list snapshot
+            // (log-only, latest-wins) after the tool pair — the tool pair stays.
+            const todos = todoSnapshot(Array.isArray(record.items) ? record.items : []);
+            return [...(Array.isArray(events) ? events : [events]), { type: "todo_write", todos }];
+        }
+        case "error": {
+            if (phase === "completed") {
+                // Non-fatal item-level error: ride omp's stopReason "error" assistant
+                // message shape so agent.ts's ompFailure() classifies it downstream.
+                return {
+                    type: "message_end",
+                    message: {
+                        role: "assistant",
+                        content: [],
+                        stopReason: "error",
+                        errorMessage: asText(record.message),
+                    },
+                };
+            }
+            return null;
+        }
+        default:
+            return null;
+    }
+}
+/**
+ * Project one codex SDK ThreadEvent (duck-typed, never imported into dist)
+ * onto the omp wire vocabulary. Returns one event, an ordered array, or null
+ * for ignorable/malformed input. Never throws.
+ */
+export function projectThreadEvent(evt) {
+    try {
+        const record = asRecord(evt);
+        if (record === null || typeof record.type !== "string")
+            return null;
+        switch (record.type) {
+            case "thread.started": {
+                const start = { type: "agent_start" };
+                if (typeof record.thread_id === "string" && record.thread_id !== "") {
+                    start.data = { threadId: record.thread_id };
+                }
+                return start;
+            }
+            case "turn.started":
+                return { type: "turn_start" };
+            case "item.started":
+                return projectItem(record.item, "started");
+            case "item.updated":
+                return projectItem(record.item, "updated");
+            case "item.completed":
+                return projectItem(record.item, "completed");
+            case "turn.completed": {
+                const usage = asRecord(record.usage);
+                return usage === null ? { type: "turn_end" } : { type: "turn_end", data: { usage } };
+            }
+            case "turn.failed": {
+                const error = asRecord(record.error);
+                return error === null ? { type: "turn_end" } : { type: "turn_end", data: { error } };
+            }
+            case "error":
+                // Fatal stream error: the client reports it via onFailure; the wire
+                // stream stays silent (S5 ignorable-event invariant).
+                return null;
+            default:
+                return null;
+        }
+    }
+    catch {
+        return null;
+    }
+}

package/agent-codex/dist/codex-store.js

@@ -0,0 +1,190 @@
+/**
+ * Codex home resolution + the rollout-HEAD metadata reader.
+ *
+ * The listing/replay scanner that used to live here is GONE (2026-09-16): the
+ * DSH session log is now the session authority (upstream `sessionPersistence`
+ * owns list/read/replay), so the adapter no longer derives session ids or
+ * transcripts from Codex's rollout store. What remains is:
+ *
+ *  - home resolution (`<DSH home>/agents/codex`, spec S7) with the prod-home
+ *  - home resolution (native `~/.codex`, never redirected) with the prod-home
+ *  - {@link readRolloutHead}: a bounded, memoized reader of ONE rollout's
+ *    FIRST line (`session_meta`), used only to recover the Codex system
+ *    prompt (`payload.base_instructions`) and the recorded cwd. It never
+ *    parses the transcript and never throws.
+ *
+ * Single-direction valve (spec S7): this module NEVER writes under the codex
+ * home; the rollout stays Codex's transcript of record.
+ */
+import { closeSync, openSync, readdirSync, readSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+/** Prod homes that must never be resolved into (repo red line). */
+const PROD_HOMES = [join(homedir(), ".dsh"), join(homedir(), ".superd")];
+export function assertNotProdHome(path, label) {
+    if (PROD_HOMES.includes(path) || PROD_HOMES.some((p) => path.startsWith(`${p}/`))) {
+        throw new Error(`codex-store: refusing prod home as ${label}: ${path}`);
+    }
+}
+/**
+ * Resolve the Codex CLI's app-data home — the NATIVE `~/.codex` (user ruling
+ * 2026-09-17, pi precedent): the installed app keeps its own home, so the
+ * adapter never redirects it when spawning the SDK/CLI and never seeds config
+ * into it. Precedence: `CODEX_HOME` (tests / operator override), then the
+ * native default.
+ *
+ * The world's DSH home (`<dshHome>/agents/codex`) is NOT an input here anymore
+ * — it anchors adapter-owned DSH state only (session-map.ts). A home without
+ * `config.toml` would make the CLI fall back to OpenAI's own endpoint
+ * (region-blocked here), but that is the operator's native home: provisioning
+ * it is the operator's business (test helper: scripts/setup-codex-home.mjs).
+ */
+export function resolveCodexHome() {
+    if (process.env.CODEX_HOME !== undefined) {
+        const env = resolve(process.env.CODEX_HOME);
+        assertNotProdHome(env, "codex home");
+        return env;
+    }
+    const native = join(homedir(), ".codex");
+    assertNotProdHome(native, "codex home");
+    return native;
+}
+/**
+ * Take an explicit codex home as-is (prod-guarded) — for callers that already
+ * hold the final path (models.ts, the spike); distinct from
+ * {@link resolveCodexHome}, which resolves the native default.
+ */
+export function useCodexHome(path) {
+    const resolved = resolve(path);
+    assertNotProdHome(resolved, "codex home");
+    return resolved;
+}
+/** Bounded read budget: `session_meta` is the FIRST line, so this is generous. */
+const HEAD_BYTES = 64 * 1024;
+/** Memoized heads by thread id — the head line is immutable once written. */
+const headCache = new Map();
+/**
+ * Locate one thread's rollout file under `<codexHome>/sessions/<Y>/<M>/<D>/`.
+ * The rollout file name embeds the thread id, so presence is the match test;
+ * a miss is retried (a thread's rollout may not exist yet at first call).
+ */
+function findRolloutFile(codexHome, threadId) {
+    const root = join(codexHome, "sessions");
+    try {
+        for (const year of readdirSync(root, { withFileTypes: true })) {
+            if (!year.isDirectory())
+                continue;
+            for (const month of readdirSync(join(root, year.name), { withFileTypes: true })) {
+                if (!month.isDirectory())
+                    continue;
+                for (const day of readdirSync(join(root, year.name, month.name), { withFileTypes: true })) {
+                    if (!day.isDirectory())
+                        continue;
+                    const dir = join(root, year.name, month.name, day.name);
+                    for (const file of readdirSync(dir)) {
+                        if (file.endsWith(".jsonl") && file.includes(threadId))
+                            return join(dir, file);
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+/** Read (at most) the first line of a file; fail-soft. */
+function readFirstLine(path) {
+    let fd;
+    try {
+        fd = openSync(path, "r");
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const chunk = Buffer.allocUnsafe(HEAD_BYTES);
+        const read = readSync(fd, chunk, 0, chunk.length, 0);
+        if (read <= 0)
+            return undefined;
+        const text = chunk.subarray(0, read).toString("utf8");
+        const end = text.indexOf("\n");
+        return end === -1 ? text : text.slice(0, end);
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/**
+ * Read the `session_meta` head of the rollout belonging to `threadId`:
+ * the Codex system prompt and the recorded cwd. Memoized per thread id (the
+ * head line never changes); fail-soft — an unknown thread, an unwritten
+ * rollout, or a malformed head all yield `undefined`.
+ */
+/**
+ * Codex writes `payload.base_instructions` either as a plain string or as an
+ * object `{ text }` (observed 2026-09-16 on the SDK line: the object form is
+ * what the vendored binary emits today). Accept both; anything else is absent.
+ */
+function baseInstructionsText(value) {
+    if (typeof value === "string")
+        return value.trim() === "" ? undefined : value;
+    if (value !== null && typeof value === "object") {
+        const text = value["text"];
+        if (typeof text === "string" && text.trim() !== "")
+            return text;
+    }
+    return undefined;
+}
+export function readRolloutHead(codexHome, threadId) {
+    const cached = headCache.get(threadId);
+    if (cached !== undefined)
+        return cached;
+    const file = findRolloutFile(codexHome, threadId);
+    if (file === undefined)
+        return undefined;
+    // Cheap existence/size gate before paying for a read.
+    try {
+        if (!statSync(file).isFile())
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    const line = readFirstLine(file);
+    if (line === undefined)
+        return undefined;
+    let record;
+    try {
+        record = JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+    if (record === null || typeof record !== "object")
+        return undefined;
+    const rec = record;
+    if (rec["type"] !== "session_meta")
+        return undefined;
+    const payload = rec["payload"];
+    if (payload === null || typeof payload !== "object")
+        return undefined;
+    const meta = payload;
+    const head = {
+        ...(typeof meta["id"] === "string" && meta["id"] !== "" ? { threadId: meta["id"] } : {}),
+        ...(typeof meta["cwd"] === "string" && meta["cwd"] !== "" ? { cwd: meta["cwd"] } : {}),
+        ...(baseInstructionsText(meta["base_instructions"]) === undefined
+            ? {}
+            : { baseInstructions: baseInstructionsText(meta["base_instructions"]) }),
+    };
+    headCache.set(threadId, head);
+    return head;
+}
+/** Test hygiene: drop memoized heads. */
+export function clearRolloutHeadCache() {
+    headCache.clear();
+}

package/agent-codex/dist/inbox.js

@@ -0,0 +1,53 @@
+export class Inbox {
+    #nextTurn = [];
+    #nextStep = [];
+    get nextTurn() {
+        return this.#nextTurn;
+    }
+    get nextStep() {
+        return this.#nextStep;
+    }
+    clear() {
+        this.#nextTurn = [];
+        this.#nextStep = [];
+    }
+    append(target, message) {
+        this.#list(target).push(message);
+    }
+    prepend(target, message) {
+        this.#list(target).unshift(message);
+    }
+    replace(messageId, newMessage) {
+        const list = this.#find(messageId);
+        if (list === undefined)
+            return false;
+        const index = list.findIndex((message) => message.id === messageId);
+        if (index < 0)
+            return false;
+        list.splice(index, 1, newMessage);
+        return true;
+    }
+    remove(messageId) {
+        const list = this.#find(messageId);
+        if (list === undefined)
+            return false;
+        const index = list.findIndex((message) => message.id === messageId);
+        if (index < 0)
+            return false;
+        list.splice(index, 1);
+        return true;
+    }
+    splice(target, start, deleteCount, inserted) {
+        return this.#list(target).splice(start, deleteCount, ...inserted);
+    }
+    #list(target) {
+        return target === "next-turn" ? this.#nextTurn : this.#nextStep;
+    }
+    #find(messageId) {
+        if (this.#nextTurn.some((message) => message.id === messageId))
+            return this.#nextTurn;
+        if (this.#nextStep.some((message) => message.id === messageId))
+            return this.#nextStep;
+        return undefined;
+    }
+}