@ccpocket/bridge 0.2.0 → 1.0.0

package/dist/codex-process.js

@@ -3,17 +3,29 @@ import { randomUUID } from "node:crypto";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { rm, writeFile } from "node:fs/promises";
-import { Codex } from "@openai/codex-sdk";
+import { spawn } from "node:child_process";
 export class CodexProcess extends EventEmitter {
-    codex;
-    thread = null;
+    child = null;
     _status = "starting";
     _threadId = null;
     stopped = false;
     startModel;
-    // User input channel
     inputResolve = null;
-    pendingAbort = null;
+    pendingTurnId = null;
+    pendingTurnCompletion = null;
+    pendingApprovals = new Map();
+    pendingUserInputs = new Map();
+    lastTokenUsage = null;
+    rpcSeq = 1;
+    pendingRpc = new Map();
+    stdoutBuffer = "";
+    // Collaboration mode & plan completion state
+    _approvalPolicy = "never";
+    _collaborationMode = "default";
+    lastPlanItemText = null;
+    pendingPlanCompletion = null;
+    /** Queued plan execution text when inputResolve wasn't ready at approval time. */
+    _pendingPlanInput = null;
     get status() {
         return this._status;
     }
@@ -24,67 +36,112 @@ export class CodexProcess extends EventEmitter {
         return this._threadId;
     }
     get isRunning() {
-        return this.thread !== null;
+        return this.child !== null;
     }
-    constructor() {
-        super();
-        this.codex = new Codex();
+    get approvalPolicy() {
+        return this._approvalPolicy;
+    }
+    /**
+     * Update approval policy at runtime.
+     * Takes effect on the next `turn/start` RPC call.
+     */
+    setApprovalPolicy(policy) {
+        this._approvalPolicy = policy;
+        console.log(`[codex-process] Approval policy changed to: ${policy}`);
+    }
+    /**
+     * Set collaboration mode ("plan" or "default").
+     * Takes effect on the next `turn/start` RPC call.
+     */
+    setCollaborationMode(mode) {
+        this._collaborationMode = mode;
+        console.log(`[codex-process] Collaboration mode changed to: ${mode}`);
+    }
+    get collaborationMode() {
+        return this._collaborationMode;
     }
     start(projectPath, options) {
-        if (this.thread) {
+        if (this.child) {
             this.stop();
         }
         this.stopped = false;
         this._threadId = null;
-        const threadOpts = {
-            workingDirectory: projectPath,
-            approvalPolicy: options?.approvalPolicy ?? "never",
-            sandboxMode: options?.sandboxMode ?? "workspace-write",
-            networkAccessEnabled: options?.networkAccessEnabled ?? true,
-            skipGitRepoCheck: true,
-            ...(options?.model ? { model: options.model } : {}),
-            ...(options?.modelReasoningEffort ? { modelReasoningEffort: options.modelReasoningEffort } : {}),
-            ...(options?.webSearchMode ? { webSearchMode: options.webSearchMode } : {}),
-        };
-        console.log(`[codex-process] Starting (cwd: ${projectPath}, sandbox: ${threadOpts.sandboxMode}, approval: ${threadOpts.approvalPolicy}, model: ${threadOpts.model ?? "default"}, reasoning: ${threadOpts.modelReasoningEffort ?? "default"}, network: ${threadOpts.networkAccessEnabled}, webSearch: ${threadOpts.webSearchMode ?? "default"})`);
-        this.thread = options?.threadId
-            ? this.codex.resumeThread(options.threadId, threadOpts)
-            : this.codex.startThread(threadOpts);
-        this.setStatus("idle");
+        this.pendingTurnId = null;
+        this.pendingTurnCompletion = null;
+        this.pendingApprovals.clear();
+        this.pendingUserInputs.clear();
+        this.lastTokenUsage = null;
         this.startModel = options?.model;
-        // Start input loop
-        this.runInputLoop().catch((err) => {
-            if (!this.stopped) {
-                console.error("[codex-process] Input loop error:", err);
-                this.emitMessage({
-                    type: "error",
-                    message: `Codex error: ${err instanceof Error ? err.message : String(err)}`,
-                });
+        this._approvalPolicy = options?.approvalPolicy ?? "never";
+        this._collaborationMode = options?.collaborationMode ?? "default";
+        this.lastPlanItemText = null;
+        this.pendingPlanCompletion = null;
+        this._pendingPlanInput = null;
+        console.log(`[codex-process] Starting app-server (cwd: ${projectPath}, sandbox: ${options?.sandboxMode ?? "workspace-write"}, approval: ${options?.approvalPolicy ?? "never"}, model: ${options?.model ?? "default"}, collaboration: ${this._collaborationMode})`);
+        const child = spawn("codex", ["app-server", "--listen", "stdio://"], {
+            cwd: projectPath,
+            stdio: "pipe",
+            env: process.env,
+        });
+        this.child = child;
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            this.handleStdoutChunk(chunk);
+        });
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => {
+            const line = chunk.trim();
+            if (line) {
+                console.log(`[codex-process] stderr: ${line}`);
             }
+        });
+        child.on("error", (err) => {
+            if (this.stopped)
+                return;
+            console.error("[codex-process] app-server process error:", err);
+            this.emitMessage({ type: "error", message: `Failed to start codex app-server: ${err.message}` });
             this.setStatus("idle");
             this.emit("exit", 1);
         });
+        child.on("exit", (code) => {
+            const exitCode = code ?? 0;
+            this.child = null;
+            this.rejectAllPending(new Error("codex app-server exited"));
+            if (!this.stopped && exitCode !== 0) {
+                this.emitMessage({ type: "error", message: `codex app-server exited with code ${exitCode}` });
+            }
+            this.setStatus("idle");
+            this.emit("exit", code);
+        });
+        void this.bootstrap(projectPath, options);
     }
     stop() {
         this.stopped = true;
-        if (this.pendingAbort) {
-            this.pendingAbort.abort();
-            this.pendingAbort = null;
-        }
-        // Unblock pending input wait
         if (this.inputResolve) {
             this.inputResolve({ text: "" });
             this.inputResolve = null;
         }
-        this.thread = null;
+        this.pendingApprovals.clear();
+        this.pendingUserInputs.clear();
+        this.rejectAllPending(new Error("stopped"));
+        if (this.child) {
+            this.child.kill("SIGTERM");
+            this.child = null;
+        }
         this.setStatus("idle");
         console.log("[codex-process] Stopped");
     }
     interrupt() {
-        if (this.pendingAbort) {
-            console.log("[codex-process] Interrupting current turn");
-            this.pendingAbort.abort();
-        }
+        if (!this._threadId || !this.pendingTurnId)
+            return;
+        void this.request("turn/interrupt", {
+            threadId: this._threadId,
+            turnId: this.pendingTurnId,
+        }).catch((err) => {
+            if (!this.stopped) {
+                console.warn(`[codex-process] turn/interrupt failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        });
     }
     sendInput(text) {
         if (!this.inputResolve) {
@@ -102,201 +159,744 @@ export class CodexProcess extends EventEmitter {
         }
         const resolve = this.inputResolve;
         this.inputResolve = null;
-        resolve({
-            text,
-            images,
+        resolve({ text, images });
+    }
+    approve(toolUseId, _updatedInput) {
+        // Check if this is a plan completion approval
+        if (this.pendingPlanCompletion && toolUseId === this.pendingPlanCompletion.toolUseId) {
+            this.handlePlanApproved(_updatedInput);
+            return;
+        }
+        const pending = this.resolvePendingApproval(toolUseId);
+        if (!pending) {
+            console.log("[codex-process] approve() called but no pending permission requests");
+            return;
+        }
+        this.pendingApprovals.delete(pending.toolUseId);
+        this.respondToServerRequest(pending.requestId, {
+            decision: "accept",
+        });
+        this.emitToolResult(pending.toolUseId, "Approved");
+        if (this.pendingApprovals.size === 0) {
+            this.setStatus("running");
+        }
+    }
+    approveAlways(toolUseId) {
+        const pending = this.resolvePendingApproval(toolUseId);
+        if (!pending) {
+            console.log("[codex-process] approveAlways() called but no pending permission requests");
+            return;
+        }
+        this.pendingApprovals.delete(pending.toolUseId);
+        this.respondToServerRequest(pending.requestId, {
+            decision: "accept",
+            acceptSettings: {
+                forSession: true,
+            },
         });
+        this.emitToolResult(pending.toolUseId, "Approved (always)");
+        if (this.pendingApprovals.size === 0) {
+            this.setStatus("running");
+        }
     }
-    // ---- Private ----
-    async runInputLoop() {
+    reject(toolUseId, _message) {
+        // Check if this is a plan completion rejection
+        if (this.pendingPlanCompletion && toolUseId === this.pendingPlanCompletion.toolUseId) {
+            this.handlePlanRejected(_message);
+            return;
+        }
+        const pending = this.resolvePendingApproval(toolUseId);
+        if (!pending) {
+            console.log("[codex-process] reject() called but no pending permission requests");
+            return;
+        }
+        this.pendingApprovals.delete(pending.toolUseId);
+        this.respondToServerRequest(pending.requestId, {
+            decision: "decline",
+        });
+        this.emitToolResult(pending.toolUseId, "Rejected");
+        if (this.pendingApprovals.size === 0) {
+            this.setStatus("running");
+        }
+    }
+    answer(toolUseId, result) {
+        const pending = this.resolvePendingUserInput(toolUseId);
+        if (!pending) {
+            console.log("[codex-process] answer() called but no pending AskUserQuestion");
+            return;
+        }
+        this.pendingUserInputs.delete(pending.toolUseId);
+        this.respondToServerRequest(pending.requestId, {
+            answers: buildUserInputAnswers(pending.questions, result),
+        });
+        this.emitToolResult(pending.toolUseId, "Answered");
+        if (this.pendingApprovals.size === 0 && this.pendingUserInputs.size === 0) {
+            this.setStatus("running");
+        }
+    }
+    getPendingPermission(toolUseId) {
+        // Check plan completion first
+        if (this.pendingPlanCompletion) {
+            if (!toolUseId || toolUseId === this.pendingPlanCompletion.toolUseId) {
+                return {
+                    toolUseId: this.pendingPlanCompletion.toolUseId,
+                    toolName: "ExitPlanMode",
+                    input: { plan: this.pendingPlanCompletion.planText },
+                };
+            }
+        }
+        const pending = this.resolvePendingApproval(toolUseId);
+        if (pending) {
+            return {
+                toolUseId: pending.toolUseId,
+                toolName: pending.toolName,
+                input: { ...pending.input },
+            };
+        }
+        const pendingAsk = this.resolvePendingUserInput(toolUseId);
+        if (!pendingAsk)
+            return undefined;
+        return {
+            toolUseId: pendingAsk.toolUseId,
+            toolName: "AskUserQuestion",
+            input: { ...pendingAsk.input },
+        };
+    }
+    /** Emit a synthetic tool_result so history replay can match it to a permission_request. */
+    emitToolResult(toolUseId, content) {
+        this.emitMessage({
+            type: "tool_result",
+            toolUseId,
+            content,
+        });
+    }
+    resolvePendingApproval(toolUseId) {
+        if (toolUseId)
+            return this.pendingApprovals.get(toolUseId);
+        const first = this.pendingApprovals.values().next();
+        return first.done ? undefined : first.value;
+    }
+    resolvePendingUserInput(toolUseId) {
+        if (toolUseId)
+            return this.pendingUserInputs.get(toolUseId);
+        const first = this.pendingUserInputs.values().next();
+        return first.done ? undefined : first.value;
+    }
+    // ---------------------------------------------------------------------------
+    // Plan completion handlers (native collaboration_mode)
+    // ---------------------------------------------------------------------------
+    /**
+     * Plan approved → switch to Default mode and auto-start execution.
+     */
+    handlePlanApproved(updatedInput) {
+        const planText = updatedInput?.plan ?? this.pendingPlanCompletion?.planText ?? "";
+        const resolvedToolUseId = this.pendingPlanCompletion?.toolUseId;
+        this.pendingPlanCompletion = null;
+        this._collaborationMode = "default";
+        console.log("[codex-process] Plan approved, switching to Default mode");
+        // Emit synthetic tool_result so history replay knows this approval is resolved
+        if (resolvedToolUseId) {
+            this.emitToolResult(resolvedToolUseId, "Plan approved");
+        }
+        // Resolve inputResolve to start the next turn (Default mode) automatically
+        if (this.inputResolve) {
+            const resolve = this.inputResolve;
+            this.inputResolve = null;
+            resolve({ text: `Execute the following plan:\n\n${planText}` });
+        }
+        else {
+            // inputResolve may not be ready yet if approval comes before the next
+            // input loop iteration.  Queue the text so sendInput() can pick it up.
+            console.warn("[codex-process] Plan approved but inputResolve not ready, queuing as pending input");
+            this._pendingPlanInput = `Execute the following plan:\n\n${planText}`;
+        }
+    }
+    /**
+     * Plan rejected → stay in Plan mode and re-plan with feedback.
+     */
+    handlePlanRejected(feedback) {
+        const resolvedToolUseId = this.pendingPlanCompletion?.toolUseId;
+        this.pendingPlanCompletion = null;
+        console.log("[codex-process] Plan rejected, continuing in Plan mode");
+        // Stay in Plan mode
+        // Emit synthetic tool_result so history replay knows this approval is resolved
+        if (resolvedToolUseId) {
+            this.emitToolResult(resolvedToolUseId, "Plan rejected");
+        }
+        if (feedback) {
+            if (this.inputResolve) {
+                const resolve = this.inputResolve;
+                this.inputResolve = null;
+                resolve({ text: feedback });
+            }
+            else {
+                console.warn("[codex-process] Plan rejected but inputResolve not ready, queuing feedback");
+                this._pendingPlanInput = feedback;
+            }
+        }
+        else {
+            this.setStatus("idle");
+        }
+    }
+    async bootstrap(projectPath, options) {
+        try {
+            await this.request("initialize", {
+                clientInfo: {
+                    name: "ccpocket_bridge",
+                    version: "1.0.0",
+                    title: "ccpocket bridge",
+                },
+                capabilities: {
+                    experimentalApi: true,
+                },
+            });
+            this.notify("initialized", {});
+            const threadParams = {
+                cwd: projectPath,
+                approvalPolicy: normalizeApprovalPolicy(options?.approvalPolicy ?? "never"),
+                sandbox: normalizeSandboxMode(options?.sandboxMode ?? "workspace-write"),
+            };
+            if (options?.model)
+                threadParams.model = options.model;
+            if (options?.modelReasoningEffort) {
+                threadParams.effort = normalizeReasoningEffort(options.modelReasoningEffort);
+            }
+            if (options?.networkAccessEnabled !== undefined) {
+                threadParams.sandboxPolicy = {
+                    type: normalizeSandboxMode(options?.sandboxMode ?? "workspace-write"),
+                    networkAccess: options.networkAccessEnabled,
+                };
+            }
+            if (options?.webSearchMode) {
+                threadParams.webSearchMode = options.webSearchMode;
+            }
+            const method = options?.threadId ? "thread/resume" : "thread/start";
+            if (options?.threadId) {
+                threadParams.threadId = options.threadId;
+            }
+            const response = await this.request(method, threadParams);
+            const thread = response.thread;
+            const threadId = typeof thread?.id === "string"
+                ? thread.id
+                : options?.threadId;
+            if (!threadId) {
+                throw new Error(`${method} returned no thread id`);
+            }
+            // Capture the resolved model name from thread response
+            if (typeof thread?.model === "string" && thread.model) {
+                this.startModel = thread.model;
+            }
+            this._threadId = threadId;
+            this.emitMessage({
+                type: "system",
+                subtype: "init",
+                sessionId: threadId,
+                model: this.startModel ?? "codex",
+            });
+            this.setStatus("idle");
+            await this.runInputLoop(options);
+        }
+        catch (err) {
+            if (!this.stopped) {
+                const message = err instanceof Error ? err.message : String(err);
+                console.error("[codex-process] bootstrap error:", err);
+                this.emitMessage({ type: "error", message: `Codex error: ${message}` });
+                this.emitMessage({ type: "result", subtype: "error", error: message, sessionId: this._threadId ?? undefined });
+            }
+            this.setStatus("idle");
+            this.emit("exit", 1);
+        }
+    }
+    async runInputLoop(options) {
         while (!this.stopped) {
-            // Wait for user input
             const pendingInput = await new Promise((resolve) => {
                 this.inputResolve = resolve;
+                // If plan approval arrived before inputResolve was ready, drain it now.
+                if (this._pendingPlanInput) {
+                    const text = this._pendingPlanInput;
+                    this._pendingPlanInput = null;
+                    this.inputResolve = null;
+                    resolve({ text });
+                }
             });
-            if (this.stopped || !pendingInput.text || !this.thread)
+            if (this.stopped || !pendingInput.text)
                 break;
-            const { input, tempPaths } = await this.toSdkInput(pendingInput);
+            if (!this._threadId) {
+                this.emitMessage({ type: "error", message: "Codex thread is not initialized" });
+                continue;
+            }
+            const { input, tempPaths } = await this.toRpcInput(pendingInput);
             if (!input) {
                 continue;
             }
-            // Execute turn
             this.setStatus("running");
-            const controller = new AbortController();
-            this.pendingAbort = controller;
-            try {
-                const streamed = await this.thread.runStreamed(input, {
-                    signal: controller.signal,
-                });
-                for await (const event of streamed.events) {
-                    if (this.stopped)
-                        break;
-                    this.processEvent(event);
+            this.lastTokenUsage = null;
+            const completion = await new Promise((resolve, reject) => {
+                this.pendingTurnCompletion = { resolve, reject };
+                const params = {
+                    threadId: this._threadId,
+                    input,
+                    approvalPolicy: normalizeApprovalPolicy(this._approvalPolicy),
+                };
+                if (options?.model)
+                    params.model = options.model;
+                if (options?.modelReasoningEffort) {
+                    params.effort = normalizeReasoningEffort(options.modelReasoningEffort);
                 }
-            }
-            catch (err) {
-                if (!this.stopped) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    // Don't emit error for abort (user-initiated interrupt)
-                    if (!controller.signal.aborted) {
-                        this.emitMessage({ type: "error", message: msg });
+                // Always send collaborationMode so the server switches modes correctly.
+                // Omitting it causes the server to persist the previous turn's mode.
+                const modeSettings = {
+                    model: options?.model || this.startModel || "gpt-5.3-codex",
+                };
+                if (this._collaborationMode === "plan") {
+                    modeSettings.reasoning_effort = "medium";
+                }
+                params.collaborationMode = {
+                    mode: this._collaborationMode,
+                    settings: modeSettings,
+                };
+                console.log(`[codex-process] turn/start: approval=${params.approvalPolicy}, collaboration=${this._collaborationMode}`);
+                void this.request("turn/start", params)
+                    .then((result) => {
+                    const turn = result.turn;
+                    if (typeof turn?.id === "string") {
+                        this.pendingTurnId = turn.id;
                     }
+                })
+                    .catch((err) => {
+                    this.pendingTurnCompletion = null;
+                    reject(err instanceof Error ? err : new Error(String(err)));
+                });
+            }).catch((err) => {
+                if (!this.stopped) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    this.emitMessage({ type: "error", message });
                     this.emitMessage({
                         type: "result",
-                        subtype: controller.signal.aborted ? "interrupted" : "error",
-                        error: controller.signal.aborted ? undefined : msg,
+                        subtype: "error",
+                        error: message,
                         sessionId: this._threadId ?? undefined,
                     });
+                    this.setStatus("idle");
                 }
+            });
+            await Promise.all(tempPaths.map((path) => rm(path, { force: true }).catch(() => { })));
+            void completion;
+        }
+    }
+    handleStdoutChunk(chunk) {
+        this.stdoutBuffer += chunk;
+        while (true) {
+            const newlineIndex = this.stdoutBuffer.indexOf("\n");
+            if (newlineIndex < 0)
+                break;
+            const line = this.stdoutBuffer.slice(0, newlineIndex).trim();
+            this.stdoutBuffer = this.stdoutBuffer.slice(newlineIndex + 1);
+            if (!line)
+                continue;
+            try {
+                const envelope = JSON.parse(line);
+                this.handleRpcEnvelope(envelope);
             }
-            finally {
-                for (const path of tempPaths) {
-                    await rm(path, { force: true }).catch(() => { });
-                }
-                this.pendingAbort = null;
+            catch (err) {
+                console.warn(`[codex-process] failed to parse app-server JSON line: ${line.slice(0, 200)}`);
                 if (!this.stopped) {
-                    this.setStatus("idle");
+                    this.emitMessage({
+                        type: "error",
+                        message: `Failed to parse codex app-server output: ${err instanceof Error ? err.message : String(err)}`,
+                    });
                 }
             }
         }
     }
-    processEvent(event) {
-        switch (event.type) {
-            case "thread.started":
-                this._threadId = event.thread_id;
-                console.log(`[codex-process] Thread started: ${event.thread_id}`);
+    handleRpcEnvelope(envelope) {
+        if (envelope.id != null && envelope.method && envelope.result === undefined && envelope.error === undefined) {
+            this.handleServerRequest(envelope.id, envelope.method, envelope.params ?? {});
+            return;
+        }
+        if (envelope.id != null && (envelope.result !== undefined || envelope.error)) {
+            this.handleRpcResponse(envelope);
+            return;
+        }
+        if (envelope.method) {
+            this.handleNotification(envelope.method, envelope.params ?? {});
+        }
+    }
+    handleRpcResponse(envelope) {
+        if (typeof envelope.id !== "number") {
+            return;
+        }
+        const pending = this.pendingRpc.get(envelope.id);
+        if (!pending)
+            return;
+        this.pendingRpc.delete(envelope.id);
+        if ("error" in envelope && envelope.error) {
+            const message = envelope.error.message ?? `RPC error ${envelope.error.code ?? ""}`;
+            pending.reject(new Error(message));
+            return;
+        }
+        pending.resolve(envelope.result);
+    }
+    handleServerRequest(id, method, params) {
+        switch (method) {
+            case "item/commandExecution/requestApproval": {
+                const toolUseId = this.extractToolUseId(params, id);
+                const input = {
+                    ...(typeof params.command === "string" ? { command: params.command } : {}),
+                    ...(typeof params.cwd === "string" ? { cwd: params.cwd } : {}),
+                    ...(params.commandActions ? { commandActions: params.commandActions } : {}),
+                    ...(params.networkApprovalContext ? { networkApprovalContext: params.networkApprovalContext } : {}),
+                    ...(typeof params.reason === "string" ? { reason: params.reason } : {}),
+                };
+                this.pendingApprovals.set(toolUseId, {
+                    requestId: id,
+                    toolUseId,
+                    toolName: "Bash",
+                    input,
+                });
+                this.emitMessage({
+                    type: "permission_request",
+                    toolUseId,
+                    toolName: "Bash",
+                    input,
+                });
+                this.setStatus("waiting_approval");
+                break;
+            }
+            case "item/fileChange/requestApproval": {
+                const toolUseId = this.extractToolUseId(params, id);
+                const input = {
+                    ...(Array.isArray(params.changes) ? { changes: params.changes } : {}),
+                    ...(typeof params.reason === "string" ? { reason: params.reason } : {}),
+                };
+                this.pendingApprovals.set(toolUseId, {
+                    requestId: id,
+                    toolUseId,
+                    toolName: "FileChange",
+                    input,
+                });
+                this.emitMessage({
+                    type: "permission_request",
+                    toolUseId,
+                    toolName: "FileChange",
+                    input,
+                });
+                this.setStatus("waiting_approval");
+                break;
+            }
+            case "item/tool/requestUserInput": {
+                const toolUseId = this.extractToolUseId(params, id);
+                const questions = normalizeUserInputQuestions(params.questions);
+                const input = {
+                    questions: questions.map((q) => ({
+                        id: q.id,
+                        question: q.question,
+                        header: q.header,
+                        options: q.options,
+                        multiSelect: false,
+                        isOther: q.isOther,
+                        isSecret: q.isSecret,
+                    })),
+                };
+                this.pendingUserInputs.set(toolUseId, {
+                    requestId: id,
+                    toolUseId,
+                    questions: questions.map((q) => ({
+                        id: q.id,
+                        question: q.question,
+                    })),
+                    input,
+                });
                 this.emitMessage({
-                    type: "system",
-                    subtype: "init",
-                    sessionId: event.thread_id,
-                    model: this.startModel ?? "codex",
+                    type: "permission_request",
+                    toolUseId,
+                    toolName: "AskUserQuestion",
+                    input,
                 });
+                this.setStatus("waiting_approval");
                 break;
-            case "turn.started":
+            }
+            default:
+                this.respondToServerRequest(id, {});
+                break;
+        }
+    }
+    handleNotification(method, params) {
+        switch (method) {
+            case "thread/started": {
+                const thread = params.thread;
+                if (typeof thread?.id === "string") {
+                    this._threadId = thread.id;
+                }
+                break;
+            }
+            case "turn/started": {
+                const turn = params.turn;
+                if (typeof turn?.id === "string") {
+                    this.pendingTurnId = turn.id;
+                }
                 this.setStatus("running");
                 break;
-            case "item.started":
-                this.processItemStarted(event.item);
+            }
+            case "turn/completed": {
+                this.handleTurnCompleted(params.turn);
                 break;
-            case "item.completed":
-                this.processItemCompleted(event.item);
+            }
+            case "thread/tokenUsage/updated": {
+                const usage = params.usage;
+                if (usage) {
+                    this.lastTokenUsage = {
+                        input: numberOrUndefined(usage.inputTokens ?? usage.input_tokens),
+                        cachedInput: numberOrUndefined(usage.cachedInputTokens ?? usage.cached_input_tokens),
+                        output: numberOrUndefined(usage.outputTokens ?? usage.output_tokens),
+                    };
+                }
                 break;
-            case "item.updated":
-                // Not fired in current SDK version, but handle for future compatibility
-                this.processItemCompleted(event.item);
+            }
+            case "item/started": {
+                this.processItemStarted(params.item);
                 break;
-            case "turn.completed":
-                this.emitMessage({
-                    type: "result",
-                    subtype: "success",
-                    sessionId: this._threadId ?? undefined,
-                    inputTokens: event.usage.input_tokens,
-                    cachedInputTokens: event.usage.cached_input_tokens,
-                    outputTokens: event.usage.output_tokens,
-                });
+            }
+            case "item/completed": {
+                this.processItemCompleted(params.item);
+                break;
+            }
+            case "item/agentMessage/delta": {
+                const delta = typeof params.delta === "string"
+                    ? params.delta
+                    : typeof params.textDelta === "string"
+                        ? params.textDelta
+                        : "";
+                if (delta) {
+                    this.emitMessage({ type: "stream_delta", text: delta });
+                }
+                break;
+            }
+            case "item/reasoning/summaryTextDelta":
+            case "item/reasoning/textDelta": {
+                const delta = typeof params.delta === "string"
+                    ? params.delta
+                    : typeof params.textDelta === "string"
+                        ? params.textDelta
+                        : "";
+                if (delta) {
+                    this.emitMessage({ type: "thinking_delta", text: delta });
+                }
                 break;
-            case "turn.failed":
+            }
+            case "item/plan/delta": {
+                const delta = typeof params.delta === "string" ? params.delta : "";
+                if (delta) {
+                    this.emitMessage({ type: "thinking_delta", text: delta });
+                }
+                break;
+            }
+            case "turn/plan/updated": {
+                // Default mode's update_plan tool output — always show as informational text
+                const text = formatPlanUpdateText(params);
+                if (!text)
+                    break;
                 this.emitMessage({
-                    type: "result",
-                    subtype: "error",
-                    error: event.error.message,
-                    sessionId: this._threadId ?? undefined,
+                    type: "assistant",
+                    message: {
+                        id: randomUUID(),
+                        role: "assistant",
+                        content: [{ type: "text", text }],
+                        model: "codex",
+                    },
                 });
                 break;
-            case "error":
-                this.emitMessage({ type: "error", message: event.message });
+            }
+            default:
                 break;
         }
     }
+    handleTurnCompleted(turn) {
+        const status = String(turn?.status ?? "completed");
+        const usage = this.lastTokenUsage;
+        this.lastTokenUsage = null;
+        if (status === "failed") {
+            const errorObj = turn?.error;
+            const message = typeof errorObj?.message === "string"
+                ? errorObj.message
+                : "Turn failed";
+            this.emitMessage({
+                type: "result",
+                subtype: "error",
+                error: message,
+                sessionId: this._threadId ?? undefined,
+            });
+        }
+        else if (status === "interrupted") {
+            this.emitMessage({
+                type: "result",
+                subtype: "interrupted",
+                sessionId: this._threadId ?? undefined,
+            });
+        }
+        else {
+            this.emitMessage({
+                type: "result",
+                subtype: "success",
+                sessionId: this._threadId ?? undefined,
+                ...(usage?.input != null ? { inputTokens: usage.input } : {}),
+                ...(usage?.cachedInput != null ? { cachedInputTokens: usage.cachedInput } : {}),
+                ...(usage?.output != null ? { outputTokens: usage.output } : {}),
+            });
+        }
+        this.pendingTurnId = null;
+        // Plan mode: emit synthetic plan approval and wait for user decision
+        if (this._collaborationMode === "plan" && this.lastPlanItemText) {
+            const toolUseId = `plan_${randomUUID()}`;
+            this.pendingPlanCompletion = {
+                toolUseId,
+                planText: this.lastPlanItemText,
+            };
+            this.lastPlanItemText = null;
+            this.emitMessage({
+                type: "permission_request",
+                toolUseId,
+                toolName: "ExitPlanMode",
+                input: { plan: this.pendingPlanCompletion.planText },
+            });
+            this.setStatus("waiting_approval");
+            // Do NOT set idle — waiting for plan approval
+        }
+        else {
+            this.lastPlanItemText = null;
+            if (this.pendingApprovals.size === 0 && this.pendingUserInputs.size === 0) {
+                this.setStatus("idle");
+            }
+        }
+        if (this.pendingTurnCompletion) {
+            this.pendingTurnCompletion.resolve();
+            this.pendingTurnCompletion = null;
+        }
+    }
     processItemStarted(item) {
-        switch (item.type) {
-            case "command_execution":
-                // Emit tool_use for the command (shown before result)
+        if (!item || typeof item !== "object")
+            return;
+        const itemId = typeof item.id === "string" ? item.id : randomUUID();
+        const itemType = normalizeItemType(item.type);
+        switch (itemType) {
+            case "commandexecution": {
+                const commandText = typeof item.command === "string"
+                    ? item.command
+                    : Array.isArray(item.command)
+                        ? item.command.map((part) => String(part)).join(" ")
+                        : "";
                 this.emitMessage({
                     type: "assistant",
                     message: {
-                        id: item.id,
+                        id: itemId,
                         role: "assistant",
                         content: [
                             {
                                 type: "tool_use",
-                                id: item.id,
+                                id: itemId,
                                 name: "Bash",
-                                input: { command: item.command },
+                                input: { command: commandText },
+                            },
+                        ],
+                        model: "codex",
+                    },
+                });
+                break;
+            }
+            case "filechange": {
+                this.emitMessage({
+                    type: "assistant",
+                    message: {
+                        id: itemId,
+                        role: "assistant",
+                        content: [
+                            {
+                                type: "tool_use",
+                                id: itemId,
+                                name: "FileChange",
+                                input: {
+                                    changes: Array.isArray(item.changes) ? item.changes : [],
+                                },
                             },
                         ],
                         model: "codex",
                     },
                 });
                 break;
-            // Other item types: nothing to show on start
+            }
+            default:
+                break;
         }
     }
     processItemCompleted(item) {
-        switch (item.type) {
-            case "agent_message":
+        if (!item || typeof item !== "object")
+            return;
+        const itemId = typeof item.id === "string" ? item.id : randomUUID();
+        const itemType = normalizeItemType(item.type);
+        switch (itemType) {
+            case "agentmessage": {
+                const text = extractAgentText(item);
+                if (!text)
+                    return;
                 this.emitMessage({
                     type: "assistant",
                     message: {
-                        id: item.id,
+                        id: itemId,
                         role: "assistant",
-                        content: [{ type: "text", text: item.text }],
+                        content: [{ type: "text", text }],
                         model: "codex",
                     },
                 });
                 break;
-            case "reasoning":
-                this.emitMessage({ type: "thinking_delta", text: item.text });
+            }
+            case "reasoning": {
+                const text = extractReasoningText(item);
+                if (text) {
+                    this.emitMessage({ type: "thinking_delta", text });
+                }
                 break;
-            case "command_execution":
+            }
+            case "commandexecution": {
+                const output = typeof item.aggregatedOutput === "string"
+                    ? item.aggregatedOutput
+                    : typeof item.output === "string"
+                        ? item.output
+                        : "";
+                const exitCode = numberOrUndefined(item.exitCode ?? item.exit_code);
                 this.emitMessage({
                     type: "tool_result",
-                    toolUseId: item.id,
-                    content: item.aggregated_output || `exit code: ${item.exit_code}`,
+                    toolUseId: itemId,
+                    content: output || `exit code: ${exitCode ?? "unknown"}`,
                     toolName: "Bash",
                 });
                 break;
-            case "file_change":
-                // Emit tool_use first (for display)
-                this.emitMessage({
-                    type: "assistant",
-                    message: {
-                        id: item.id,
-                        role: "assistant",
-                        content: [
-                            {
-                                type: "tool_use",
-                                id: item.id,
-                                name: "FileChange",
-                                input: { changes: item.changes },
-                            },
-                        ],
-                        model: "codex",
-                    },
-                });
+            }
+            case "filechange": {
+                const content = formatFileChangesWithDiff(item.changes);
                 this.emitMessage({
                     type: "tool_result",
-                    toolUseId: item.id,
-                    content: item.changes
-                        .map((c) => `${c.kind}: ${c.path}`)
-                        .join("\n"),
+                    toolUseId: itemId,
+                    content,
                     toolName: "FileChange",
                 });
                 break;
-            case "mcp_tool_call": {
-                const toolName = `mcp:${item.server}/${item.tool}`;
-                // Emit tool_use first
+            }
+            case "mcptoolcall": {
+                const server = typeof item.server === "string" ? item.server : "mcp";
+                const tool = typeof item.tool === "string" ? item.tool : "unknown";
+                const toolName = `mcp:${server}/${tool}`;
+                const result = item.result ?? item.error ?? "MCP call completed";
                 this.emitMessage({
                     type: "assistant",
                     message: {
-                        id: item.id,
+                        id: itemId,
                         role: "assistant",
                         content: [
                             {
                                 type: "tool_use",
-                                id: item.id,
+                                id: itemId,
                                 name: toolName,
-                                input: item.arguments,
+                                input: item.arguments ?? {},
                             },
                         ],
                         model: "codex",
@@ -304,26 +904,25 @@ export class CodexProcess extends EventEmitter {
                 });
                 this.emitMessage({
                     type: "tool_result",
-                    toolUseId: item.id,
-                    content: item.result
-                        ? JSON.stringify(item.result)
-                        : item.error?.message ?? "MCP call completed",
+                    toolUseId: itemId,
+                    content: typeof result === "string" ? result : JSON.stringify(result),
                     toolName,
                 });
                 break;
             }
-            case "web_search":
+            case "websearch": {
+                const query = typeof item.query === "string" ? item.query : "";
                 this.emitMessage({
                     type: "assistant",
                     message: {
-                        id: item.id,
+                        id: itemId,
                         role: "assistant",
                         content: [
                             {
                                 type: "tool_use",
-                                id: item.id,
+                                id: itemId,
                                 name: "WebSearch",
-                                input: { query: item.query },
+                                input: { query },
                             },
                         ],
                         model: "codex",
@@ -331,53 +930,33 @@ export class CodexProcess extends EventEmitter {
                 });
                 this.emitMessage({
                     type: "tool_result",
-                    toolUseId: item.id,
-                    content: `Web search: ${item.query}`,
+                    toolUseId: itemId,
+                    content: query ? `Web search: ${query}` : "Web search completed",
                     toolName: "WebSearch",
                 });
                 break;
-            case "todo_list":
-                this.emitMessage({
-                    type: "assistant",
-                    message: {
-                        id: item.id,
-                        role: "assistant",
-                        content: [
-                            {
-                                type: "text",
-                                text: item.items
-                                    .map((t) => `${t.completed ? "\u2705" : "\u2B1C"} ${t.text}`)
-                                    .join("\n"),
-                            },
-                        ],
-                        model: "codex",
-                    },
-                });
+            }
+            case "plan": {
+                // Plan item completed — save text for plan approval emission in handleTurnCompleted()
+                const planText = typeof item.text === "string" ? item.text : "";
+                this.lastPlanItemText = planText;
                 break;
-            case "error":
-                this.emitMessage({ type: "error", message: item.message });
+            }
+            case "error": {
+                const message = typeof item.message === "string" ? item.message : "Codex item error";
+                this.emitMessage({ type: "error", message });
+                break;
+            }
+            default:
                 break;
         }
     }
-    setStatus(status) {
-        if (this._status !== status) {
-            this._status = status;
-            this.emit("status", status);
-            this.emitMessage({ type: "status", status });
-        }
-    }
-    emitMessage(msg) {
-        this.emit("message", msg);
-    }
-    async toSdkInput(pendingInput) {
+    async toRpcInput(pendingInput) {
+        const input = [{ type: "text", text: pendingInput.text }];
+        const tempPaths = [];
         if (!pendingInput.images || pendingInput.images.length === 0) {
-            return { input: pendingInput.text, tempPaths: [] };
+            return { input, tempPaths };
         }
-        const inputParts = [];
-        const tempPaths = [];
-        // Add text first
-        inputParts.push({ type: "text", text: pendingInput.text });
-        // Add each image
         for (const image of pendingInput.images) {
             const ext = extensionFromMime(image.mimeType);
             if (!ext) {
@@ -400,14 +979,311 @@ export class CodexProcess extends EventEmitter {
             }
             const tempPath = join(tmpdir(), `ccpocket-codex-image-${randomUUID()}.${ext}`);
             await writeFile(tempPath, buffer);
-            inputParts.push({ type: "local_image", path: tempPath });
             tempPaths.push(tempPath);
+            input.push({ type: "localImage", path: tempPath });
+        }
+        return { input, tempPaths };
+    }
+    request(method, params) {
+        const id = this.rpcSeq++;
+        const envelope = { id, method, params };
+        return new Promise((resolve, reject) => {
+            this.pendingRpc.set(id, { resolve, reject, method });
+            try {
+                this.writeEnvelope(envelope);
+            }
+            catch (err) {
+                this.pendingRpc.delete(id);
+                reject(err instanceof Error ? err : new Error(String(err)));
+            }
+        });
+    }
+    notify(method, params) {
+        this.writeEnvelope({ method, params });
+    }
+    respondToServerRequest(id, result) {
+        try {
+            this.writeEnvelope({ id, result });
+        }
+        catch (err) {
+            if (!this.stopped) {
+                console.warn(`[codex-process] failed to respond to server request: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    writeEnvelope(envelope) {
+        if (!this.child || this.child.killed) {
+            throw new Error("codex app-server is not running");
+        }
+        const line = `${JSON.stringify(envelope)}\n`;
+        this.child.stdin.write(line);
+    }
+    rejectAllPending(error) {
+        for (const pending of this.pendingRpc.values()) {
+            pending.reject(error);
+        }
+        this.pendingRpc.clear();
+        if (this.pendingTurnCompletion) {
+            this.pendingTurnCompletion.reject(error);
+            this.pendingTurnCompletion = null;
+        }
+    }
+    setStatus(status) {
+        if (this._status !== status) {
+            this._status = status;
+            this.emit("status", status);
+            this.emitMessage({ type: "status", status });
+        }
+    }
+    emitMessage(msg) {
+        this.emit("message", msg);
+    }
+    extractToolUseId(params, requestId) {
+        if (typeof params.approvalId === "string")
+            return params.approvalId;
+        if (typeof params.itemId === "string")
+            return params.itemId;
+        if (typeof requestId === "string")
+            return requestId;
+        return `approval-${requestId}`;
+    }
+}
+function normalizeApprovalPolicy(value) {
+    switch (value) {
+        case "on-request":
+            return "on-request";
+        case "on-failure":
+            return "on-failure";
+        case "untrusted":
+            return "untrusted";
+        case "never":
+        default:
+            return "never";
+    }
+}
+function normalizeSandboxMode(value) {
+    switch (value) {
+        case "read-only":
+            return "read-only";
+        case "danger-full-access":
+            return "danger-full-access";
+        case "workspace-write":
+        default:
+            return "workspace-write";
+    }
+}
+function normalizeReasoningEffort(value) {
+    switch (value) {
+        case "xhigh":
+            return "high";
+        default:
+            return value;
+    }
+}
+function normalizeItemType(raw) {
+    if (typeof raw !== "string")
+        return "";
+    return raw.replace(/[_\s-]/g, "").toLowerCase();
+}
+function numberOrUndefined(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function summarizeFileChanges(changes) {
+    if (!Array.isArray(changes) || changes.length === 0) {
+        return "No file changes";
+    }
+    return changes
+        .map((entry) => {
+        if (!entry || typeof entry !== "object")
+            return "changed";
+        const record = entry;
+        const kind = typeof record.kind === "string" ? record.kind : "changed";
+        const path = typeof record.path === "string" ? record.path : "(unknown)";
+        return `${kind}: ${path}`;
+    })
+        .join("\n");
+}
+/**
+ * Format file changes including unified diff content for display in chat.
+ * Falls back to `kind: path` summary when no diff is available.
+ */
+function formatFileChangesWithDiff(changes) {
+    if (!Array.isArray(changes) || changes.length === 0) {
+        return "No file changes";
+    }
+    return changes
+        .map((entry) => {
+        if (!entry || typeof entry !== "object")
+            return "changed";
+        const record = entry;
+        const kind = typeof record.kind === "string" ? record.kind : "changed";
+        const path = typeof record.path === "string" ? record.path : "(unknown)";
+        const diff = typeof record.diff === "string" ? record.diff.trim() : "";
+        if (diff) {
+            // If diff already has unified headers, use as-is; otherwise add them
+            if (diff.startsWith("---") || diff.startsWith("@@")) {
+                return `--- a/${path}\n+++ b/${path}\n${diff}`;
+            }
+            return diff;
         }
-        if (tempPaths.length === 0) {
-            // All images failed, send text only
-            return { input: pendingInput.text, tempPaths: [] };
+        return `${kind}: ${path}`;
+    })
+        .join("\n\n");
+}
+function extractAgentText(item) {
+    if (typeof item.text === "string")
+        return item.text;
+    const parts = item.content;
+    if (Array.isArray(parts)) {
+        const text = parts
+            .filter((part) => part && typeof part === "object")
+            .map((part) => {
+            const record = part;
+            if (record.type === "text" && typeof record.text === "string") {
+                return record.text;
+            }
+            return "";
+        })
+            .filter((part) => part.length > 0)
+            .join("\n");
+        if (text)
+            return text;
+    }
+    return "";
+}
+function extractReasoningText(item) {
+    if (typeof item.text === "string")
+        return item.text;
+    const summary = item.summary;
+    if (Array.isArray(summary)) {
+        const text = summary
+            .map((entry) => {
+            if (!entry || typeof entry !== "object")
+                return "";
+            const record = entry;
+            return typeof record.text === "string" ? record.text : "";
+        })
+            .filter((part) => part.length > 0)
+            .join("\n");
+        if (text)
+            return text;
+    }
+    return "";
+}
+function normalizeUserInputQuestions(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .filter((entry) => !!entry && typeof entry === "object")
+        .map((entry, index) => {
+        const id = typeof entry.id === "string" ? entry.id : `question_${index + 1}`;
+        const question = typeof entry.question === "string" ? entry.question : "";
+        const header = typeof entry.header === "string" ? entry.header : `Question ${index + 1}`;
+        const optionsRaw = Array.isArray(entry.options) ? entry.options : [];
+        const options = optionsRaw
+            .filter((option) => !!option && typeof option === "object")
+            .map((option) => ({
+            label: typeof option.label === "string" ? option.label : "",
+            description: typeof option.description === "string" ? option.description : "",
+        }))
+            .filter((option) => option.label.length > 0);
+        return {
+            id,
+            question,
+            header,
+            options,
+            isOther: Boolean(entry.isOther),
+            isSecret: Boolean(entry.isSecret),
+        };
+    })
+        .filter((question) => question.question.length > 0);
+}
+function buildUserInputAnswers(questions, rawResult) {
+    const parsed = parseResultObject(rawResult);
+    const answerMap = {};
+    for (const question of questions) {
+        const candidate = parsed.byId[question.id] ?? parsed.byQuestion[question.question];
+        const answers = normalizeAnswerValues(candidate);
+        if (answers.length > 0) {
+            answerMap[question.id] = { answers };
+        }
+    }
+    if (Object.keys(answerMap).length === 0 && questions.length > 0) {
+        answerMap[questions[0].id] = { answers: normalizeAnswerValues(rawResult) };
+    }
+    return answerMap;
+}
+function parseResultObject(rawResult) {
+    try {
+        const parsed = JSON.parse(rawResult);
+        const byId = {};
+        const byQuestion = {};
+        if (parsed && typeof parsed === "object") {
+            const answers = parsed.answers;
+            if (answers && typeof answers === "object" && !Array.isArray(answers)) {
+                for (const [key, value] of Object.entries(answers)) {
+                    byId[key] = value;
+                    byQuestion[key] = value;
+                }
+            }
         }
-        return { input: inputParts, tempPaths };
+        return { byId, byQuestion };
+    }
+    catch {
+        return { byId: {}, byQuestion: {} };
+    }
+}
+function normalizeAnswerValues(value) {
+    if (typeof value === "string") {
+        return value
+            .split(",")
+            .map((part) => part.trim())
+            .filter((part) => part.length > 0);
+    }
+    if (Array.isArray(value)) {
+        return value
+            .map((entry) => String(entry).trim())
+            .filter((entry) => entry.length > 0);
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        if (Array.isArray(record.answers)) {
+            return record.answers
+                .map((entry) => String(entry).trim())
+                .filter((entry) => entry.length > 0);
+        }
+    }
+    if (value == null)
+        return [];
+    const normalized = String(value).trim();
+    return normalized ? [normalized] : [];
+}
+function formatPlanUpdateText(params) {
+    const stepsRaw = params.plan;
+    if (!Array.isArray(stepsRaw) || stepsRaw.length === 0)
+        return "";
+    const explanation = typeof params.explanation === "string" ? params.explanation.trim() : "";
+    const lines = stepsRaw
+        .filter((entry) => !!entry && typeof entry === "object")
+        .map((entry, index) => {
+        const step = typeof entry.step === "string" ? entry.step : `Step ${index + 1}`;
+        const status = normalizePlanStatus(entry.status);
+        return `${index + 1}. [${status}] ${step}`;
+    });
+    if (lines.length === 0)
+        return "";
+    const header = explanation ? `Plan update: ${explanation}` : "Plan update:";
+    return `${header}\n${lines.join("\n")}`;
+}
+function normalizePlanStatus(raw) {
+    switch (raw) {
+        case "inProgress":
+            return "in progress";
+        case "completed":
+            return "completed";
+        case "pending":
+        default:
+            return "pending";
     }
 }
 function extensionFromMime(mimeType) {