@bytetrue/byspace 0.1.0

package/node_modules/@bytetrue/byspace-server/dist/server/server/agent/providers/codex/rewind.d.ts

@@ -0,0 +1,21 @@
+import type { CodexThreadForkParams, CodexThreadForkResponse, CodexThreadRollbackParams, CodexThreadRollbackResponse } from "./app-server-transport.js";
+export interface CodexRewindClient {
+    forkThread?(params: CodexThreadForkParams): Promise<CodexThreadForkResponse>;
+    rollbackThread?(params: CodexThreadRollbackParams): Promise<CodexThreadRollbackResponse>;
+    request(method: string, params?: unknown, timeoutMs?: number): Promise<unknown>;
+}
+export interface CodexUserMessageTurnIndex {
+    resolve(messageId: string): number | null;
+    count(): number;
+}
+export declare function revertCodexConversation(input: {
+    client: CodexRewindClient;
+    threadId: string | null;
+    messageId: string;
+    cwd?: string | null;
+    model?: string | null;
+    serviceTier?: string | null;
+    userMessageTurns: CodexUserMessageTurnIndex;
+    setThreadId: (threadId: string) => void | Promise<void>;
+}): Promise<void>;
+//# sourceMappingURL=rewind.d.ts.map

package/node_modules/@bytetrue/byspace-server/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/node_modules/@bytetrue/byspace-server/dist/server/server/agent/providers/codex/test-utils/fake-app-server.d.ts

@@ -0,0 +1,118 @@
+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;
+interface FakeSubAgentActivity {
+    callId: string;
+    threadId: string;
+    agentPath: string;
+    kind: "started" | "interacted" | "interrupted";
+    parentThreadId?: string;
+}
+interface FakeLegacyCommand {
+    threadId: string;
+    callId: string;
+    command: string;
+    output: string;
+}
+interface FakeSilentCommand {
+    threadId: string;
+    callId: string;
+    command: string;
+    cwd: string;
+}
+interface FakeTerminalInput {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    processId: string;
+    text: string;
+}
+interface FakeLegacyPatch {
+    threadId: string;
+    callId: string;
+    path: string;
+    diff: string;
+}
+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>;
+    startsTurn(params: {
+        threadId: string;
+        turnId?: string;
+    }): void;
+    completeTurn(params?: {
+        threadId?: string;
+    }): void;
+    startsSubAgent(params: {
+        callId: string;
+        threadId: string;
+        agentPath: string;
+        parentThreadId?: string;
+    }): void;
+    startsLegacyOnlySubAgent(params: {
+        callId: string;
+        threadId: string;
+        agentPath: string;
+        parentThreadId?: string;
+    }): void;
+    beginsSubAgentActivity(params: FakeSubAgentActivity): void;
+    completesSubAgentActivity(params: FakeSubAgentActivity): void;
+    completesCompaction(params: {
+        threadId: string;
+        itemId: string;
+    }): void;
+    runsLegacyCommand(params: FakeLegacyCommand): void;
+    appliesLegacyPatch(params: FakeLegacyPatch): void;
+    completesCommand(params: FakeLegacyCommand): void;
+    completesSilentCommand(params: FakeSilentCommand): void;
+    completesSilentLegacyCommand(params: FakeSilentCommand): void;
+    typesIntoTerminal(params: FakeTerminalInput): void;
+    says(params: {
+        threadId: string;
+        itemId?: string;
+        text: string;
+        chunks?: string[];
+    }): void;
+    requestCommandApproval(params: {
+        itemId: string;
+        threadId: string;
+        turnId: string;
+        command: string;
+        cwd: string;
+        reason: string;
+    }): void;
+    waitForCommandApprovalDecision(itemId: string): Promise<unknown>;
+    requestMcpElicitation(params: {
+        threadId: string;
+        turnId: string | null;
+        serverName: string;
+        message: string;
+        requestedSchema: Record<string, unknown>;
+    }): void;
+    waitForMcpElicitationDecision(): Promise<unknown>;
+    resolvesMcpElicitation(): void;
+}
+export declare function createCodexAppServerChildProcess(): CodexAppServerChildProcess;
+export declare function createFakeCodexAppServer(handlers?: Record<string, FakeCodexAppServerHandler>): FakeCodexAppServer;
+type StreamEventType = AgentStreamEvent["type"];
+type StreamEventOfType<TType extends StreamEventType> = Extract<AgentStreamEvent, {
+    type: TType;
+}>;
+type TimelineEvent = StreamEventOfType<"timeline">;
+type ProviderSubagentEvent = StreamEventOfType<"provider_subagent">;
+export declare function waitForNextPermission(session: AgentSession): Promise<StreamEventOfType<"permission_requested">>;
+export declare function waitForNextTimelineItem(session: AgentSession): Promise<TimelineEvent>;
+export declare function waitForTimelineToolCall(session: AgentSession, callId: string): Promise<TimelineEvent>;
+export declare function waitForProviderSubagent(session: AgentSession, id: string): Promise<ProviderSubagentEvent>;
+export {};
+//# sourceMappingURL=fake-app-server.d.ts.map

package/node_modules/@bytetrue/byspace-server/dist/server/server/agent/providers/codex/test-utils/fake-app-server.js

@@ -0,0 +1,417 @@
+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();
+    let mcpElicitationRequestId;
+    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);
+        });
+    }
+    function writeSubAgentActivity(method, params) {
+        writeNotification(method, {
+            threadId: params.parentThreadId ?? "thread-1",
+            item: {
+                type: "subAgentActivity",
+                id: params.callId,
+                kind: params.kind,
+                agentThreadId: params.threadId,
+                agentPath: params.agentPath,
+            },
+        });
+    }
+    function writeNotification(method, params) {
+        child.stdout.write(`${JSON.stringify({ method, params })}\n`);
+    }
+    function completeItem(threadId, item) {
+        writeNotification("item/completed", { threadId, item });
+    }
+    function writeLegacyEvent(threadId, method, msg) {
+        writeNotification(method, { threadId, msg });
+    }
+    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()));
+            });
+        },
+        startsTurn(params) {
+            child.stdout.write(`${JSON.stringify({
+                method: "turn/started",
+                params: {
+                    threadId: params.threadId,
+                    turn: { id: params.turnId ?? `turn-${params.threadId}` },
+                },
+            })}\n`);
+        },
+        completeTurn(params = {}) {
+            child.stdout.write(`${JSON.stringify({
+                method: "turn/completed",
+                params: { threadId: params.threadId ?? "thread-1", turn: { status: "completed" } },
+            })}\n`);
+        },
+        startsSubAgent(params) {
+            writeSubAgentActivity("item/completed", { ...params, kind: "started" });
+        },
+        startsLegacyOnlySubAgent(params) {
+            writeLegacyEvent(params.parentThreadId ?? "thread-1", "codex/event/item_completed", {
+                type: "item_completed",
+                item: {
+                    type: "subAgentActivity",
+                    id: params.callId,
+                    kind: "started",
+                    agentThreadId: params.threadId,
+                    agentPath: params.agentPath,
+                },
+            });
+        },
+        beginsSubAgentActivity(params) {
+            writeSubAgentActivity("item/started", params);
+        },
+        completesSubAgentActivity(params) {
+            writeSubAgentActivity("item/completed", params);
+        },
+        completesCompaction(params) {
+            completeItem(params.threadId, { type: "contextCompaction", id: params.itemId });
+        },
+        runsLegacyCommand(params) {
+            writeLegacyEvent(params.threadId, "codex/event/exec_command_begin", {
+                type: "exec_command_begin",
+                call_id: params.callId,
+                command: params.command,
+            });
+            writeLegacyEvent(params.threadId, "codex/event/exec_command_output_delta", {
+                type: "exec_command_output_delta",
+                call_id: params.callId,
+                chunk: params.output,
+            });
+            writeLegacyEvent(params.threadId, "codex/event/exec_command_end", {
+                type: "exec_command_end",
+                call_id: params.callId,
+                command: params.command,
+                exit_code: 0,
+                success: true,
+            });
+        },
+        appliesLegacyPatch(params) {
+            const changes = [
+                {
+                    path: params.path,
+                    kind: "modify",
+                    unified_diff: params.diff,
+                },
+            ];
+            for (const [method, type] of [
+                ["codex/event/patch_apply_begin", "patch_apply_begin"],
+                ["codex/event/patch_apply_end", "patch_apply_end"],
+            ]) {
+                writeLegacyEvent(params.threadId, method, {
+                    type,
+                    call_id: params.callId,
+                    changes,
+                    ...(type === "patch_apply_end" ? { success: true } : {}),
+                });
+            }
+        },
+        completesCommand(params) {
+            completeItem(params.threadId, {
+                type: "commandExecution",
+                id: params.callId,
+                status: "completed",
+                command: params.command,
+                aggregatedOutput: params.output,
+                exitCode: 0,
+            });
+        },
+        completesSilentCommand(params) {
+            completeItem(params.threadId, {
+                type: "commandExecution",
+                id: params.callId,
+                status: "completed",
+                command: params.command,
+                cwd: params.cwd,
+                aggregatedOutput: null,
+                exitCode: 0,
+            });
+        },
+        completesSilentLegacyCommand(params) {
+            writeLegacyEvent(params.threadId, "codex/event/exec_command_end", {
+                type: "exec_command_end",
+                call_id: params.callId,
+                command: params.command,
+                cwd: params.cwd,
+                aggregatedOutput: null,
+                exit_code: 0,
+                success: true,
+            });
+        },
+        typesIntoTerminal(params) {
+            writeNotification("item/commandExecution/terminalInteraction", {
+                threadId: params.threadId,
+                turnId: params.turnId,
+                itemId: params.itemId,
+                processId: params.processId,
+                stdin: params.text,
+            });
+        },
+        says(params) {
+            if (params.itemId) {
+                for (const chunk of params.chunks ?? [params.text]) {
+                    child.stdout.write(`${JSON.stringify({
+                        method: "item/agentMessage/delta",
+                        params: {
+                            threadId: params.threadId,
+                            itemId: params.itemId,
+                            delta: chunk,
+                        },
+                    })}\n`);
+                }
+            }
+            completeItem(params.threadId, {
+                type: "agentMessage",
+                ...(params.itemId ? { id: params.itemId } : {}),
+                text: params.text,
+            });
+        },
+        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;
+        },
+        requestMcpElicitation(params) {
+            const requestId = nextServerRequestId;
+            nextServerRequestId += 1;
+            mcpElicitationRequestId = requestId;
+            child.stdout.write(`${JSON.stringify({
+                jsonrpc: "2.0",
+                id: requestId,
+                method: "mcpServer/elicitation/request",
+                params: {
+                    ...params,
+                    mode: "openai/form",
+                    _meta: null,
+                },
+            })}\n`);
+        },
+        async waitForMcpElicitationDecision() {
+            if (mcpElicitationRequestId === undefined) {
+                throw new Error("No pending fake Codex app-server MCP elicitation");
+            }
+            const message = await waitForMessage((candidate) => candidate.id === mcpElicitationRequestId &&
+                !("method" in candidate) &&
+                "result" in candidate, "MCP elicitation response");
+            return message.result;
+        },
+        resolvesMcpElicitation() {
+            if (mcpElicitationRequestId === undefined) {
+                throw new Error("No pending fake Codex app-server MCP elicitation");
+            }
+            writeNotification("serverRequest/resolved", { requestId: mcpElicitationRequestId });
+        },
+    };
+}
+function toJsonObject(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+}
+function waitForNextEvent(session, type, accepts) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            unsubscribe();
+            reject(new Error(`Timed out waiting for ${type}`));
+        }, 1000);
+        const unsubscribe = session.subscribe((event) => {
+            if (event.type !== type) {
+                return;
+            }
+            const typedEvent = event;
+            if (accepts && !accepts(typedEvent)) {
+                return;
+            }
+            clearTimeout(timeout);
+            unsubscribe();
+            resolve(typedEvent);
+        });
+    });
+}
+export function waitForNextPermission(session) {
+    return waitForNextEvent(session, "permission_requested");
+}
+export function waitForNextTimelineItem(session) {
+    return waitForNextEvent(session, "timeline");
+}
+export function waitForTimelineToolCall(session, callId) {
+    return waitForNextEvent(session, "timeline", (event) => event.item.type === "tool_call" && event.item.callId === callId);
+}
+export function waitForProviderSubagent(session, id) {
+    return waitForNextEvent(session, "provider_subagent", (event) => event.event.id === id);
+}
+//# sourceMappingURL=fake-app-server.js.map

package/node_modules/@bytetrue/byspace-server/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