@otto-code/server 0.5.0

package/dist/server/server/agent/providers/codex/rewind.js

@@ -0,0 +1,46 @@
+import { parseCodexThreadForkResponse, parseCodexThreadRollbackResponse, } from "./app-server-transport.js";
+async function forkCodexThread(client, params) {
+    if (client.forkThread) {
+        return client.forkThread(params);
+    }
+    return parseCodexThreadForkResponse(await client.request("thread/fork", params));
+}
+async function rollbackCodexThread(client, params) {
+    if (client.rollbackThread) {
+        return client.rollbackThread(params);
+    }
+    return parseCodexThreadRollbackResponse(await client.request("thread/rollback", params));
+}
+export async function revertCodexConversation(input) {
+    if (!input.threadId) {
+        throw new Error("Codex thread is not ready for rewind");
+    }
+    const targetTurnIndex = input.userMessageTurns.resolve(input.messageId);
+    if (targetTurnIndex === null) {
+        throw new Error(`Codex could not find user message ${input.messageId} in the current thread`);
+    }
+    const currentUserTurnCount = input.userMessageTurns.count();
+    const numTurns = currentUserTurnCount - targetTurnIndex;
+    if (numTurns < 0) {
+        throw new Error(`Codex user message ${input.messageId} is outside the current thread`);
+    }
+    // Fork is non-destructive: the old thread file stays on disk and remains
+    // recoverable with `codex resume <old-uuid>` if the rewind target was wrong.
+    const forked = await forkCodexThread(input.client, {
+        threadId: input.threadId,
+        cwd: input.cwd ?? null,
+        model: input.model ?? null,
+        serviceTier: input.serviceTier ?? null,
+        excludeTurns: false,
+        persistExtendedHistory: true,
+    });
+    const forkedThreadId = forked.thread.id;
+    // Codex rollback is chat-only by design. File edits from rewound turns stay
+    // on disk; a future file primitive would be a separate capability.
+    const rolledBack = await rollbackCodexThread(input.client, {
+        threadId: forkedThreadId,
+        numTurns,
+    });
+    await input.setThreadId(rolledBack.thread.id);
+}
+//# sourceMappingURL=rewind.js.map

package/dist/server/server/agent/providers/codex/test-utils/fake-app-server.d.ts

@@ -0,0 +1,36 @@
+import type { ChildProcessWithoutNullStreams } from "node:child_process";
+import { PassThrough } from "node:stream";
+import type { AgentSession, AgentStreamEvent } from "../../../agent-sdk-types.js";
+type JsonObject = Record<string, unknown>;
+type FakeCodexAppServerHandler = (params: unknown) => unknown;
+type CodexAppServerChildProcess = ChildProcessWithoutNullStreams & {
+    stdin: PassThrough;
+    stdout: PassThrough;
+    stderr: PassThrough;
+};
+export interface FakeCodexAppServer {
+    readonly child: CodexAppServerChildProcess;
+    readonly recordedRollbacks: JsonObject[];
+    assertNoErrors(): void;
+    waitForTurnStart(): Promise<JsonObject>;
+    nextResponse(): Promise<string>;
+    completeTurn(params?: {
+        threadId?: string;
+    }): void;
+    requestCommandApproval(params: {
+        itemId: string;
+        threadId: string;
+        turnId: string;
+        command: string;
+        cwd: string;
+        reason: string;
+    }): void;
+    waitForCommandApprovalDecision(itemId: string): Promise<unknown>;
+}
+export declare function createCodexAppServerChildProcess(): CodexAppServerChildProcess;
+export declare function createFakeCodexAppServer(handlers?: Record<string, FakeCodexAppServerHandler>): FakeCodexAppServer;
+export declare function waitForNextPermission(session: AgentSession): Promise<Extract<AgentStreamEvent, {
+    type: "permission_requested";
+}>>;
+export {};
+//# sourceMappingURL=fake-app-server.d.ts.map

package/dist/server/server/agent/providers/codex/test-utils/fake-app-server.js

@@ -0,0 +1,217 @@
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+export function createCodexAppServerChildProcess() {
+    const child = Object.assign(new EventEmitter(), {
+        stdin: new PassThrough(),
+        stdout: new PassThrough(),
+        stderr: new PassThrough(),
+        exitCode: null,
+        signalCode: null,
+    });
+    child.kill = ((signal) => {
+        queueMicrotask(() => child.emit("exit", null, signal ?? null));
+        return true;
+    });
+    return child;
+}
+export function createFakeCodexAppServer(handlers = {}) {
+    const child = createCodexAppServerChildProcess();
+    const recordedRollbacks = [];
+    const responseHandlers = {
+        initialize: () => ({}),
+        "collaborationMode/list": () => ({ data: [] }),
+        "config/read": () => ({ config: {} }),
+        getUserSavedConfig: () => ({ config: {} }),
+        "model/list": () => ({
+            data: [
+                {
+                    id: "gpt-5.4",
+                    isDefault: true,
+                    defaultReasoningEffort: "medium",
+                },
+            ],
+        }),
+        "skills/list": () => ({ data: [] }),
+        "thread/start": () => ({ thread: { id: "thread-1" } }),
+        "thread/loaded/list": () => ({ data: [] }),
+        "thread/resume": () => ({}),
+        "turn/start": () => ({}),
+        "thread/fork": (params) => ({
+            thread: {
+                id: "forked-thread",
+                sessionId: "forked-session",
+                forkedFromId: toJsonObject(params).threadId,
+                turns: [],
+            },
+            model: "gpt-5.4",
+            modelProvider: "openai",
+            serviceTier: null,
+            cwd: "/workspace/project",
+            runtimeWorkspaceRoots: [],
+            instructionSources: [],
+            approvalPolicy: "on-request",
+            approvalsReviewer: null,
+            sandbox: { type: "workspaceWrite", networkAccess: false },
+            activePermissionProfile: null,
+            reasoningEffort: null,
+        }),
+        "thread/rollback": (params) => {
+            const rollback = toJsonObject(params);
+            recordedRollbacks.push(rollback);
+            return {
+                thread: {
+                    id: typeof rollback.threadId === "string" ? rollback.threadId : "forked-thread",
+                    sessionId: "forked-session",
+                    forkedFromId: "thread-1",
+                    turns: [],
+                },
+            };
+        },
+        "thread/read": () => ({ thread: { turns: [] } }),
+        ...handlers,
+    };
+    const messages = [];
+    const errors = [];
+    const approvalRequestIds = new Map();
+    const waiters = new Set();
+    let buffer = "";
+    let nextServerRequestId = 1;
+    function processMessage(message) {
+        messages.push(message);
+        for (const waiter of Array.from(waiters)) {
+            if (waiter.predicate(message)) {
+                waiters.delete(waiter);
+                waiter.resolve(message);
+            }
+        }
+        if (typeof message.id !== "number" || typeof message.method !== "string") {
+            return;
+        }
+        const handler = responseHandlers[message.method];
+        if (!handler) {
+            errors.push(new Error(`Unexpected Codex app-server request: ${message.method}`));
+            return;
+        }
+        Promise.resolve(handler(message.params))
+            .then((result) => {
+            child.stdout.write(`${JSON.stringify({ id: message.id, result })}\n`);
+            return undefined;
+        })
+            .catch((error) => {
+            child.stdout.write(`${JSON.stringify({
+                id: message.id,
+                error: { message: error instanceof Error ? error.message : String(error) },
+            })}\n`);
+            return undefined;
+        });
+    }
+    child.stdin.on("data", (chunk) => {
+        buffer += chunk.toString();
+        for (;;) {
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex === -1) {
+                break;
+            }
+            const line = buffer.slice(0, newlineIndex).trim();
+            buffer = buffer.slice(newlineIndex + 1);
+            if (!line) {
+                continue;
+            }
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                    processMessage(parsed);
+                }
+            }
+            catch (error) {
+                errors.push(error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+    });
+    function waitForMessage(predicate, label) {
+        const existing = messages.find(predicate);
+        if (existing) {
+            return Promise.resolve(existing);
+        }
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                waiters.delete(waiter);
+                reject(new Error(`Timed out waiting for ${label}`));
+            }, 1000);
+            const waiter = {
+                predicate,
+                resolve: (message) => {
+                    clearTimeout(timeout);
+                    resolve(message);
+                },
+            };
+            waiters.add(waiter);
+        });
+    }
+    return {
+        child,
+        recordedRollbacks,
+        assertNoErrors() {
+            if (errors.length > 0) {
+                throw errors[0];
+            }
+        },
+        async waitForTurnStart() {
+            const message = await waitForMessage((candidate) => candidate.method === "turn/start", "turn start request");
+            return toJsonObject(message.params);
+        },
+        nextResponse() {
+            return new Promise((resolve) => {
+                child.stdin.once("data", (chunk) => resolve(chunk.toString()));
+            });
+        },
+        completeTurn(params = {}) {
+            child.stdout.write(`${JSON.stringify({
+                method: "turn/completed",
+                params: { threadId: params.threadId ?? "thread-1", turn: { status: "completed" } },
+            })}\n`);
+        },
+        requestCommandApproval(params) {
+            const requestId = nextServerRequestId;
+            nextServerRequestId += 1;
+            approvalRequestIds.set(params.itemId, requestId);
+            child.stdout.write(`${JSON.stringify({
+                jsonrpc: "2.0",
+                id: requestId,
+                method: "item/commandExecution/requestApproval",
+                params,
+            })}\n`);
+        },
+        async waitForCommandApprovalDecision(itemId) {
+            const requestId = approvalRequestIds.get(itemId);
+            if (requestId === undefined) {
+                throw new Error(`No pending fake Codex app-server approval for ${itemId}`);
+            }
+            const message = await waitForMessage((candidate) => candidate.id === requestId && !("method" in candidate) && "result" in candidate, "command approval response");
+            return message.result;
+        },
+    };
+}
+function toJsonObject(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+}
+export function waitForNextPermission(session) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            unsubscribe();
+            reject(new Error("Timed out waiting for permission_requested"));
+        }, 1000);
+        const unsubscribe = session.subscribe((event) => {
+            if (event.type !== "permission_requested") {
+                return;
+            }
+            clearTimeout(timeout);
+            unsubscribe();
+            resolve(event);
+        });
+    });
+}
+//# sourceMappingURL=fake-app-server.js.map

package/dist/server/server/agent/providers/codex/tool-call-detail-parser.d.ts

@@ -0,0 +1,12 @@
+import type { ToolCallDetail } from "../../agent-sdk-types.js";
+export interface CodexToolDetailContext {
+    cwd?: string | null;
+}
+export declare function normalizeCodexFilePath(filePath: string, cwd: string | null | undefined): string | undefined;
+export declare function deriveCodexToolDetail(params: {
+    name: string;
+    input: unknown;
+    output: unknown;
+    cwd?: string | null;
+}): ToolCallDetail;
+//# sourceMappingURL=tool-call-detail-parser.d.ts.map

package/dist/server/server/agent/providers/codex/tool-call-detail-parser.js

@@ -0,0 +1,104 @@
+import { z } from "zod";
+import { stripCwdPrefix } from "@otto-code/protocol/path-utils";
+import { ToolEditInputSchema, ToolEditOutputSchema, ToolReadInputSchema, ToolReadOutputWithPathSchema, ToolSearchInputSchema, ToolShellInputSchema, ToolShellOutputSchema, ToolWriteInputSchema, ToolWriteOutputSchema, toEditToolDetail, toReadToolDetail, toSearchToolDetail, toShellToolDetail, toWriteToolDetail, toolDetailBranchByNameWithCwd, } from "../tool-call-detail-primitives.js";
+const CodexToolEnvelopeSchema = z
+    .object({
+    name: z.string().min(1),
+    input: z.unknown().nullable(),
+    output: z.unknown().nullable(),
+    cwd: z.string().nullable().optional(),
+})
+    .passthrough();
+const CodexSpeakToolDetailSchema = z
+    .object({
+    name: z.literal("speak"),
+    input: z
+        .union([
+        z.string().transform((text) => ({ text })),
+        z.object({ text: z.string() }).passthrough(),
+    ])
+        .nullable(),
+    output: z.unknown().nullable(),
+    cwd: z.string().nullable().optional(),
+})
+    .transform(({ input }) => {
+    const text = input?.text?.trim() ?? "";
+    if (!text) {
+        return undefined;
+    }
+    return {
+        type: "unknown",
+        input: text,
+        output: null,
+    };
+});
+const CodexLooseEditOutputSchema = z.unknown().transform((value) => {
+    const parsed = ToolEditOutputSchema.safeParse(value);
+    return parsed.success ? parsed.data : null;
+});
+export function normalizeCodexFilePath(filePath, cwd) {
+    if (!filePath) {
+        return undefined;
+    }
+    if (typeof cwd === "string" && cwd.length > 0) {
+        return stripCwdPrefix(filePath, cwd);
+    }
+    return filePath;
+}
+function normalizePathForCwd(cwd) {
+    return (filePath) => normalizeCodexFilePath(filePath, cwd);
+}
+const CodexToolDetailPass2Schema = z.union([
+    toolDetailBranchByNameWithCwd("Bash", ToolShellInputSchema, ToolShellOutputSchema, (input, output) => toShellToolDetail(input, output)),
+    toolDetailBranchByNameWithCwd("shell", ToolShellInputSchema, ToolShellOutputSchema, (input, output) => toShellToolDetail(input, output)),
+    toolDetailBranchByNameWithCwd("bash", ToolShellInputSchema, ToolShellOutputSchema, (input, output) => toShellToolDetail(input, output)),
+    toolDetailBranchByNameWithCwd("exec", ToolShellInputSchema, ToolShellOutputSchema, (input, output) => toShellToolDetail(input, output)),
+    toolDetailBranchByNameWithCwd("exec_command", ToolShellInputSchema, ToolShellOutputSchema, (input, output) => toShellToolDetail(input, output)),
+    toolDetailBranchByNameWithCwd("command", ToolShellInputSchema, ToolShellOutputSchema, (input, output) => toShellToolDetail(input, output)),
+    toolDetailBranchByNameWithCwd("read", ToolReadInputSchema, z.unknown(), (input, output, cwd) => {
+        const parsedOutput = ToolReadOutputWithPathSchema.safeParse(output);
+        return toReadToolDetail(input, parsedOutput.success ? parsedOutput.data : null, {
+            normalizePath: normalizePathForCwd(cwd),
+        });
+    }),
+    toolDetailBranchByNameWithCwd("read_file", ToolReadInputSchema, z.unknown(), (input, output, cwd) => {
+        const parsedOutput = ToolReadOutputWithPathSchema.safeParse(output);
+        return toReadToolDetail(input, parsedOutput.success ? parsedOutput.data : null, {
+            normalizePath: normalizePathForCwd(cwd),
+        });
+    }),
+    toolDetailBranchByNameWithCwd("write", ToolWriteInputSchema, ToolWriteOutputSchema, (input, output, cwd) => toWriteToolDetail(input, output, { normalizePath: normalizePathForCwd(cwd) })),
+    toolDetailBranchByNameWithCwd("write_file", ToolWriteInputSchema, ToolWriteOutputSchema, (input, output, cwd) => toWriteToolDetail(input, output, { normalizePath: normalizePathForCwd(cwd) })),
+    toolDetailBranchByNameWithCwd("create_file", ToolWriteInputSchema, ToolWriteOutputSchema, (input, output, cwd) => toWriteToolDetail(input, output, { normalizePath: normalizePathForCwd(cwd) })),
+    toolDetailBranchByNameWithCwd("edit", ToolEditInputSchema, CodexLooseEditOutputSchema, (input, output, cwd) => toEditToolDetail(input, output, { normalizePath: normalizePathForCwd(cwd) })),
+    toolDetailBranchByNameWithCwd("apply_patch", ToolEditInputSchema, CodexLooseEditOutputSchema, (input, output, cwd) => toEditToolDetail(input, output, { normalizePath: normalizePathForCwd(cwd) })),
+    toolDetailBranchByNameWithCwd("apply_diff", ToolEditInputSchema, CodexLooseEditOutputSchema, (input, output, cwd) => toEditToolDetail(input, output, { normalizePath: normalizePathForCwd(cwd) })),
+    toolDetailBranchByNameWithCwd("search", ToolSearchInputSchema, z.unknown(), (input) => toSearchToolDetail({ input, toolName: "search" })),
+    toolDetailBranchByNameWithCwd("web_search", ToolSearchInputSchema, z.unknown(), (input) => toSearchToolDetail({ input, toolName: "web_search" })),
+    CodexSpeakToolDetailSchema,
+]);
+export function deriveCodexToolDetail(params) {
+    const pass1 = CodexToolEnvelopeSchema.safeParse({
+        name: params.name,
+        input: params.input ?? null,
+        output: params.output ?? null,
+        cwd: params.cwd ?? null,
+    });
+    if (!pass1.success) {
+        return {
+            type: "unknown",
+            input: params.input ?? null,
+            output: params.output ?? null,
+        };
+    }
+    const pass2 = CodexToolDetailPass2Schema.safeParse(pass1.data);
+    if (pass2.success && pass2.data) {
+        return pass2.data;
+    }
+    return {
+        type: "unknown",
+        input: pass1.data.input,
+        output: pass1.data.output,
+    };
+}
+//# sourceMappingURL=tool-call-detail-parser.js.map

package/dist/server/server/agent/providers/codex/tool-call-mapper.d.ts

@@ -0,0 +1,24 @@
+import type { ToolCallTimelineItem } from "../../agent-sdk-types.js";
+interface CodexMapperOptions {
+    cwd?: string | null;
+}
+export interface CodexMcpToolResultImage {
+    data: string;
+    mimeType: string;
+}
+interface CodexMcpToolResultImagesSplit {
+    images: CodexMcpToolResultImage[];
+    output: unknown;
+}
+export declare function splitCodexMcpToolResultImages(result: unknown): CodexMcpToolResultImagesSplit;
+export declare function mapCodexToolCallFromThreadItem(item: unknown, options?: CodexMapperOptions): ToolCallTimelineItem | null;
+export declare function mapCodexToolCallEnvelope(params: {
+    callId?: string | null;
+    name: string;
+    input?: unknown;
+    output?: unknown;
+    error?: unknown;
+    cwd?: string | null;
+}): ToolCallTimelineItem | null;
+export {};
+//# sourceMappingURL=tool-call-mapper.d.ts.map