@ccpocket/bridge 0.2.0 → 1.1.0

package/dist/websocket.js

@@ -4,7 +4,7 @@ import { WebSocketServer, WebSocket } from "ws";
 import { SessionManager } from "./session.js";
 import { SdkProcess } from "./sdk-process.js";
 import { parseClientMessage } from "./parser.js";
-import { getAllRecentSessions, getCodexSessionHistory, getSessionHistory, findSessionsByClaudeIds, extractMessageImages } from "./sessions-index.js";
+import { getAllRecentSessions, getCodexSessionHistory, getSessionHistory, findSessionsByClaudeIds, extractMessageImages, getClaudeSessionName, loadCodexSessionNames, renameClaudeSession, renameCodexSession } from "./sessions-index.js";
 import { WorktreeStore } from "./worktree-store.js";
 import { listWorktrees, removeWorktree, worktreeExists } from "./worktree.js";
 import { listWindows, takeScreenshot } from "./screenshot.js";
@@ -13,6 +13,16 @@ import { RecordingStore } from "./recording-store.js";
 import { PushRelayClient } from "./push-relay.js";
 import { normalizePushLocale, t } from "./push-i18n.js";
 import { fetchAllUsage } from "./usage.js";
+// ---- Codex mode mapping helpers ----
+/** Map unified PermissionMode to Codex approval_policy.
+ *  Only "bypassPermissions" maps to "never"; all others use "on-request". */
+function permissionModeToApprovalPolicy(mode) {
+    return mode === "bypassPermissions" ? "never" : "on-request";
+}
+/** Map simplified SandboxMode (on/off) to Codex internal sandbox mode. */
+function sandboxModeToInternal(mode) {
+    return mode === "off" ? "danger-full-access" : "workspace-write";
+}
 export class BridgeWebSocketServer {
     static MAX_DEBUG_EVENTS = 800;
     static MAX_HISTORY_SUMMARY_ITEMS = 300;
@@ -135,6 +145,9 @@ export class BridgeWebSocketServer {
         switch (msg.type) {
             case "start": {
                 const provider = msg.provider ?? "claude";
+                if (provider === "codex") {
+                    console.log(`[ws] start(codex): permissionMode=${msg.permissionMode} → collaboration=${msg.permissionMode === "plan" ? "plan" : "default"}`);
+                }
                 const cached = provider === "claude" ? this.sessionManager.getCachedCommands(msg.projectPath) : undefined;
                 const sessionId = this.sessionManager.create(msg.projectPath, {
                     sessionId: msg.sessionId,
@@ -153,29 +166,34 @@ export class BridgeWebSocketServer {
                     existingWorktreePath: msg.existingWorktreePath,
                 }, provider, provider === "codex"
                     ? {
-                        approvalPolicy: msg.approvalPolicy ?? undefined,
-                        sandboxMode: msg.sandboxMode ?? undefined,
+                        approvalPolicy: permissionModeToApprovalPolicy(msg.permissionMode),
+                        sandboxMode: sandboxModeToInternal(msg.sandboxMode),
                         model: msg.model,
                         modelReasoningEffort: msg.modelReasoningEffort ?? undefined,
                         networkAccessEnabled: msg.networkAccessEnabled,
                         webSearchMode: msg.webSearchMode ?? undefined,
                         threadId: msg.sessionId,
+                        collaborationMode: msg.permissionMode === "plan" ? "plan" : "default",
                     }
                     : undefined);
                 const createdSession = this.sessionManager.get(sessionId);
-                this.send(ws, {
-                    type: "system",
-                    subtype: "session_created",
-                    sessionId,
-                    provider,
-                    projectPath: msg.projectPath,
-                    ...(provider === "claude" && msg.permissionMode ? { permissionMode: msg.permissionMode } : {}),
-                    ...(provider === "codex" && msg.sandboxMode ? { sandboxMode: msg.sandboxMode } : {}),
-                    ...(cached ? { slashCommands: cached.slashCommands, skills: cached.skills } : {}),
-                    ...(createdSession?.worktreePath ? {
-                        worktreePath: createdSession.worktreePath,
-                        worktreeBranch: createdSession.worktreeBranch,
-                    } : {}),
+                // Load saved session name from CLI storage (for resumed sessions)
+                void this.loadAndSetSessionName(createdSession, provider, msg.projectPath, msg.sessionId).then(() => {
+                    this.send(ws, {
+                        type: "system",
+                        subtype: "session_created",
+                        sessionId,
+                        provider,
+                        projectPath: msg.projectPath,
+                        ...(provider === "claude" && msg.permissionMode ? { permissionMode: msg.permissionMode } : {}),
+                        ...(provider === "codex" && msg.sandboxMode ? { sandboxMode: msg.sandboxMode } : {}),
+                        ...(cached ? { slashCommands: cached.slashCommands, skills: cached.skills } : {}),
+                        ...(createdSession?.worktreePath ? {
+                            worktreePath: createdSession.worktreePath,
+                            worktreeBranch: createdSession.worktreeBranch,
+                        } : {}),
+                    });
+                    this.broadcastSessionList();
                 });
                 this.debugEvents.set(sessionId, []);
                 this.recordDebugEvent(sessionId, {
@@ -326,11 +344,13 @@ export class BridgeWebSocketServer {
                     return;
                 }
                 if (session.provider === "codex") {
-                    this.send(ws, {
-                        type: "error",
-                        message: "Codex sessions do not support runtime permission mode changes",
-                    });
-                    return;
+                    const codexProcess = session.process;
+                    const approval = permissionModeToApprovalPolicy(msg.mode);
+                    const collaboration = msg.mode === "plan" ? "plan" : "default";
+                    console.log(`[ws] set_permission_mode(codex): mode=${msg.mode} → approval=${approval}, collaboration=${collaboration}`);
+                    codexProcess.setApprovalPolicy(approval);
+                    codexProcess.setCollaborationMode(collaboration);
+                    break;
                 }
                 session.process.setPermissionMode(msg.mode).catch((err) => {
                     this.send(ws, {
@@ -350,32 +370,23 @@ export class BridgeWebSocketServer {
                     this.send(ws, { type: "error", message: "Only Codex sessions support sandbox mode changes" });
                     return;
                 }
-                const validModes = ["read-only", "workspace-write", "danger-full-access"];
-                if (!validModes.includes(msg.sandboxMode)) {
+                // Map on/off to internal Codex sandbox modes
+                if (msg.sandboxMode !== "on" && msg.sandboxMode !== "off") {
                     this.send(ws, { type: "error", message: `Invalid sandbox mode: ${msg.sandboxMode}` });
                     return;
                 }
-                const newSandboxMode = msg.sandboxMode;
-                // Update stored settings
+                const newSandboxMode = sandboxModeToInternal(msg.sandboxMode);
+                // Update stored settings.
+                // Note: Codex app-server does not reliably support resuming an existing
+                // thread with a different sandbox mode. Restarting here can terminate
+                // the process (`codex app-server exited`) and leave the session in a
+                // broken state. We therefore persist the preference and keep the
+                // current runtime alive.
                 if (!session.codexSettings) {
                     session.codexSettings = {};
                 }
                 session.codexSettings.sandboxMode = newSandboxMode;
-                // Restart Codex process with new sandboxMode (required: sandboxMode is set at thread start)
-                const codexProc = session.process;
-                const threadId = session.claudeSessionId ?? undefined;
-                const effectiveCwd = session.worktreePath ?? session.projectPath;
-                codexProc.stop();
-                codexProc.start(effectiveCwd, {
-                    approvalPolicy: session.codexSettings.approvalPolicy ?? undefined,
-                    sandboxMode: newSandboxMode,
-                    model: session.codexSettings.model,
-                    modelReasoningEffort: session.codexSettings.modelReasoningEffort ?? undefined,
-                    networkAccessEnabled: session.codexSettings.networkAccessEnabled,
-                    webSearchMode: session.codexSettings.webSearchMode ?? undefined,
-                    threadId,
-                });
-                console.log(`[ws] Sandbox mode changed to ${newSandboxMode} for session ${session.id} (thread restart)`);
+                console.log(`[ws] Sandbox mode changed to ${newSandboxMode} for session ${session.id} (deferred apply)`);
                 break;
             }
             case "approve": {
@@ -385,8 +396,8 @@ export class BridgeWebSocketServer {
                     return;
                 }
                 if (session.provider === "codex") {
-                    this.send(ws, { type: "error", message: "Codex sessions do not support approval" });
-                    return;
+                    session.process.approve(msg.id, msg.updatedInput);
+                    break;
                 }
                 const sdkProc = session.process;
                 if (msg.clearContext) {
@@ -447,8 +458,8 @@ export class BridgeWebSocketServer {
                     return;
                 }
                 if (session.provider === "codex") {
-                    this.send(ws, { type: "error", message: "Codex sessions do not support approval" });
-                    return;
+                    session.process.approveAlways(msg.id);
+                    break;
                 }
                 session.process.approveAlways(msg.id);
                 break;
@@ -460,8 +471,8 @@ export class BridgeWebSocketServer {
                     return;
                 }
                 if (session.provider === "codex") {
-                    this.send(ws, { type: "error", message: "Codex sessions do not support rejection" });
-                    return;
+                    session.process.reject(msg.id, msg.message);
+                    break;
                 }
                 session.process.reject(msg.id, msg.message);
                 break;
@@ -473,8 +484,8 @@ export class BridgeWebSocketServer {
                     return;
                 }
                 if (session.provider === "codex") {
-                    this.send(ws, { type: "error", message: "Codex sessions do not support answer" });
-                    return;
+                    session.process.answer(msg.toolUseId, msg.result);
+                    break;
                 }
                 session.process.answer(msg.toolUseId, msg.result);
                 break;
@@ -629,25 +640,29 @@ export class BridgeWebSocketServer {
                     getCodexSessionHistory(sessionRefId).then((pastMessages) => {
                         const sessionId = this.sessionManager.create(effectiveProjectPath, undefined, pastMessages, worktreeOpts, "codex", {
                             threadId: sessionRefId,
-                            approvalPolicy: msg.approvalPolicy ?? undefined,
-                            sandboxMode: msg.sandboxMode ?? undefined,
+                            approvalPolicy: permissionModeToApprovalPolicy(msg.permissionMode),
+                            sandboxMode: sandboxModeToInternal(msg.sandboxMode),
                             model: msg.model,
                             modelReasoningEffort: msg.modelReasoningEffort ?? undefined,
                             networkAccessEnabled: msg.networkAccessEnabled,
                             webSearchMode: msg.webSearchMode ?? undefined,
+                            collaborationMode: msg.permissionMode === "plan" ? "plan" : "default",
                         });
                         const createdSession = this.sessionManager.get(sessionId);
-                        this.send(ws, {
-                            type: "system",
-                            subtype: "session_created",
-                            sessionId,
-                            provider: "codex",
-                            projectPath: effectiveProjectPath,
-                            ...(createdSession?.codexSettings?.sandboxMode ? { sandboxMode: createdSession.codexSettings.sandboxMode } : {}),
-                            ...(createdSession?.worktreePath ? {
-                                worktreePath: createdSession.worktreePath,
-                                worktreeBranch: createdSession.worktreeBranch,
-                            } : {}),
+                        void this.loadAndSetSessionName(createdSession, "codex", effectiveProjectPath, sessionRefId).then(() => {
+                            this.send(ws, {
+                                type: "system",
+                                subtype: "session_created",
+                                sessionId,
+                                provider: "codex",
+                                projectPath: effectiveProjectPath,
+                                ...(createdSession?.codexSettings?.sandboxMode ? { sandboxMode: createdSession.codexSettings.sandboxMode } : {}),
+                                ...(createdSession?.worktreePath ? {
+                                    worktreePath: createdSession.worktreePath,
+                                    worktreeBranch: createdSession.worktreeBranch,
+                                } : {}),
+                            });
+                            this.broadcastSessionList();
                         });
                         this.debugEvents.set(sessionId, []);
                         this.recordDebugEvent(sessionId, {
@@ -693,19 +708,22 @@ export class BridgeWebSocketServer {
                         persistSession: msg.persistSession,
                     }, pastMessages, worktreeOpts);
                     const createdSession = this.sessionManager.get(sessionId);
-                    this.send(ws, {
-                        type: "system",
-                        subtype: "session_created",
-                        sessionId,
-                        claudeSessionId,
-                        provider: "claude",
-                        projectPath: msg.projectPath,
-                        ...(msg.permissionMode ? { permissionMode: msg.permissionMode } : {}),
-                        ...(cached ? { slashCommands: cached.slashCommands, skills: cached.skills } : {}),
-                        ...(createdSession?.worktreePath ? {
-                            worktreePath: createdSession.worktreePath,
-                            worktreeBranch: createdSession.worktreeBranch,
-                        } : {}),
+                    void this.loadAndSetSessionName(createdSession, "claude", msg.projectPath, claudeSessionId).then(() => {
+                        this.send(ws, {
+                            type: "system",
+                            subtype: "session_created",
+                            sessionId,
+                            claudeSessionId,
+                            provider: "claude",
+                            projectPath: msg.projectPath,
+                            ...(msg.permissionMode ? { permissionMode: msg.permissionMode } : {}),
+                            ...(cached ? { slashCommands: cached.slashCommands, skills: cached.skills } : {}),
+                            ...(createdSession?.worktreePath ? {
+                                worktreePath: createdSession.worktreePath,
+                                worktreeBranch: createdSession.worktreeBranch,
+                            } : {}),
+                        });
+                        this.broadcastSessionList();
                     });
                     this.debugEvents.set(sessionId, []);
                     this.recordDebugEvent(sessionId, {
@@ -1083,7 +1101,81 @@ export class BridgeWebSocketServer {
                 });
                 break;
             }
+            case "rename_session": {
+                const name = msg.name || null;
+                this.handleRenameSession(ws, msg.sessionId, name, msg);
+                break;
+            }
+        }
+    }
+    /**
+     * Load the saved session name from CLI storage and set it on the SessionInfo.
+     * Called after SessionManager.create() so that session_created carries the name.
+     */
+    async loadAndSetSessionName(session, provider, projectPath, cliSessionId) {
+        if (!session || !cliSessionId)
+            return;
+        try {
+            if (provider === "claude") {
+                const name = await getClaudeSessionName(projectPath, cliSessionId);
+                if (name)
+                    session.name = name;
+            }
+            else if (provider === "codex") {
+                const names = await loadCodexSessionNames();
+                const name = names.get(cliSessionId);
+                if (name)
+                    session.name = name;
+            }
+        }
+        catch {
+            // Non-critical: session works without name
+        }
+    }
+    /**
+     * Handle rename_session: update in-memory name and persist to CLI storage.
+     *
+     * Supports both running sessions (by bridge session id) and recent sessions
+     * (by provider session id, i.e. claudeSessionId or codex threadId).
+     */
+    async handleRenameSession(ws, sessionId, name, msg) {
+        // 1. Try running session first
+        const runningSession = this.sessionManager.get(sessionId);
+        if (runningSession) {
+            this.sessionManager.renameSession(sessionId, name);
+            // Persist to provider storage
+            if (runningSession.provider === "claude" && runningSession.claudeSessionId) {
+                await renameClaudeSession(runningSession.worktreePath ?? runningSession.projectPath, runningSession.claudeSessionId, name);
+            }
+            else if (runningSession.provider === "codex" && runningSession.process) {
+                try {
+                    await runningSession.process.renameThread(name ?? "");
+                }
+                catch (err) {
+                    console.warn(`[websocket] Failed to rename Codex thread:`, err);
+                }
+            }
+            this.broadcastSessionList();
+            this.send(ws, { type: "rename_result", sessionId, name, success: true });
+            return;
+        }
+        // 2. Recent session (not running) — use provider + providerSessionId + projectPath from message
+        const renameMsg = msg;
+        const provider = renameMsg.provider;
+        const providerSessionId = renameMsg.providerSessionId;
+        const projectPath = renameMsg.projectPath;
+        if (provider === "claude" && providerSessionId && projectPath) {
+            const success = await renameClaudeSession(projectPath, providerSessionId, name);
+            this.send(ws, { type: "rename_result", sessionId, name, success });
+            return;
+        }
+        // For Codex recent sessions, write directly to session_index.jsonl.
+        if (provider === "codex" && providerSessionId) {
+            const success = await renameCodexSession(providerSessionId, name);
+            this.send(ws, { type: "rename_result", sessionId, name, success });
+            return;
         }
+        this.send(ws, { type: "rename_result", sessionId, name, success: false });
     }
     resolveSession(sessionId) {
         if (sessionId)