@ccpocket/bridge 1.69.1 → 1.69.3

package/dist/websocket.js

@@ -11,6 +11,7 @@ import { codexErrorMessage, CodexRpcError, CodexProcess, } from "./codex-process
 import { stopManagedCodexAppServers } from "./codex-transport.js";
 import { parseClientMessage, } from "./parser.js";
 import { getAllRecentSessions, getCodexSessionHistory, getSessionHistory, codexUserTurnUuid, codexThreadToSessionHistory, findSessionsByClaudeIds, extractMessageImages, getClaudeSessionName, getCodexSessionIndexMetadata, loadCodexSessionNames, renameClaudeSession, renameCodexSession, saveCodexSessionProfile, } from "./sessions-index.js";
+import { formatResumePerformanceLog, summarizeResumeHistory, } from "./resume-metrics.js";
 import { ArchiveStore } from "./archive-store.js";
 import { WorktreeStore } from "./worktree-store.js";
 import { listWorktrees, removeWorktree, worktreeExists, getMainBranch, } from "./worktree.js";
@@ -24,6 +25,8 @@ import { fetchAllUsage } from "./usage.js";
 import { getPackageVersion } from "./version.js";
 import { isPathWithinAllowedDirectory, resolvePlatformPath, resolvePlatformPathFrom, } from "./path-utils.js";
 import { deriveCodexPermissionsMode, normalizeCodexPermissionsMode, withDerivedCodexPermissionsMode, } from "./codex-permissions.js";
+const RESUME_OPERATION_TIMEOUT_MS = 5 * 60 * 1000;
+const RESUME_COMPLETED_TTL_MS = 30 * 1000;
 // ---- Available model lists (delivered to clients via session_list) ----
 const FALLBACK_CLAUDE_MODELS = [
     "claude-opus-4-7",
@@ -491,6 +494,7 @@ export class BridgeWebSocketServer {
     platform;
     clientSupportedServerMessages = new WeakMap();
     pendingClaudeResumeInputs = new WeakMap();
+    resumeOperations = new Map();
     constructor(options) {
         const { server, apiKey, allowedDirs, imageStore, galleryStore, projectHistory, debugTraceStore, recordingStore, firebaseAuth, promptHistoryBackup, promptHistoryStore, platform, fileListMaxEntries, fileListMaxBytes, deltaBatchMs, deltaBatchMaxChars, } = options;
         this.apiKey = apiKey ?? null;
@@ -980,7 +984,9 @@ export class BridgeWebSocketServer {
         const threadId = this.codexThreadIdForSession(session);
         if (!threadId)
             return null;
-        const history = await this.getCodexThreadHistoryFromRpc(threadId, session.projectPath, session.process);
+        const history = session.codexInitialHistoryPending
+            ? (session.pastMessages ?? [])
+            : await this.getCodexThreadHistoryFromRpc(threadId, session.projectPath, session.process);
         session.claudeSessionId = threadId;
         const messages = await this.codexHistoryToServerMessages(session, history);
         const entries = messages.map((message, index) => ({
@@ -988,6 +994,7 @@ export class BridgeWebSocketServer {
             message,
         }));
         this.applyCodexCanonicalHistoryBaseline(session, history, entries);
+        session.codexInitialHistoryPending = false;
         return entries;
     }
     applyCodexCanonicalHistoryBaseline(session, history, canonicalEntries) {
@@ -1556,6 +1563,11 @@ export class BridgeWebSocketServer {
     }
     close() {
         console.log("[ws] Shutting down...");
+        for (const operation of this.resumeOperations.values()) {
+            if (operation.timeout)
+                clearTimeout(operation.timeout);
+        }
+        this.resumeOperations.clear();
         this.flushAllDeltaBatches();
         this.sessionManager.destroyAll();
         this.flushAllDeltaBatches();
@@ -3397,13 +3409,19 @@ export class BridgeWebSocketServer {
                 break;
             }
             case "resume_session": {
+                const resumeStartedAt = Date.now();
                 console.log(`[ws] resume_session: sessionId=${msg.sessionId} projectPath=${msg.projectPath} provider=${msg.provider ?? "claude"}`);
                 const resumeProjectPath = resolvePlatformPath(msg.projectPath, this.platform);
+                const provider = msg.provider ?? "claude";
                 if (!this.isPathAllowed(resumeProjectPath)) {
+                    this.sendResumeFailed(ws, {
+                        provider,
+                        sourceSessionId: msg.sessionId,
+                        projectPath: resumeProjectPath,
+                    });
                     this.send(ws, this.buildPathNotAllowedError(msg.projectPath));
                     break;
                 }
-                const provider = msg.provider ?? "claude";
                 const normalizedCodexPermissionsMode = provider === "codex"
                     ? normalizeCodexPermissionsMode(msg.codexPermissionsMode)
                     : undefined;
@@ -3449,6 +3467,11 @@ export class BridgeWebSocketServer {
                         : undefined;
                     const additionalWritableRoots = this.normalizeAdditionalWritableRoots(msg.additionalWritableRoots, effectiveProjectPath);
                     if (additionalWritableRoots.deniedRoot) {
+                        this.sendResumeFailed(ws, {
+                            provider,
+                            sourceSessionId: sessionRefId,
+                            projectPath: effectiveProjectPath,
+                        });
                         this.send(ws, this.buildPathNotAllowedError(additionalWritableRoots.deniedRoot));
                         break;
                     }
@@ -3467,8 +3490,27 @@ export class BridgeWebSocketServer {
                             };
                         }
                     }
+                    const resumeOperation = this.beginResumeOperation({
+                        ws,
+                        provider: "codex",
+                        sourceSessionId: sessionRefId,
+                        projectPath: effectiveProjectPath,
+                        request: msg,
+                    });
+                    if (!resumeOperation.isOwner)
+                        break;
+                    let historyMetrics = summarizeResumeHistory([]);
+                    let historyLoadMs = 0;
+                    let historyLoaded = false;
+                    let sessionCreateMs = 0;
+                    let nameLoadMs = 0;
+                    const historyStartedAt = Date.now();
                     try {
                         const pastMessages = await this.getCodexThreadHistory(sessionRefId, effectiveProjectPath);
+                        historyLoadMs = Date.now() - historyStartedAt;
+                        historyLoaded = true;
+                        historyMetrics = summarizeResumeHistory(pastMessages);
+                        const createStartedAt = Date.now();
                         const sessionId = this.sessionManager.create(effectiveProjectPath, undefined, pastMessages, worktreeOpts, "codex", this.withCodexAutoReviewPolicy({
                             threadId: sessionRefId,
                             profile: effectiveProfile,
@@ -3494,10 +3536,19 @@ export class BridgeWebSocketServer {
                                 ? "plan"
                                 : "default",
                         }));
+                        sessionCreateMs = Date.now() - createStartedAt;
                         const createdSession = this.sessionManager.get(sessionId);
+                        if (createdSession) {
+                            // get_history immediately follows session_created on the app.
+                            // Reuse the canonical history loaded above instead of issuing a
+                            // second thread/read for the same restored session.
+                            createdSession.codexInitialHistoryPending = true;
+                        }
                         const cached = this.sessionManager.getCachedCommands("codex", createdSession?.worktreePath ?? effectiveProjectPath);
+                        const nameStartedAt = Date.now();
                         await this.loadAndSetSessionName(createdSession, "codex", effectiveProjectPath, sessionRefId);
-                        this.send(ws, this.buildSessionCreatedMessage({
+                        nameLoadMs = Date.now() - nameStartedAt;
+                        const createdMessage = this.buildSessionCreatedMessage({
                             sessionId,
                             provider: "codex",
                             projectPath: effectiveProjectPath,
@@ -3527,7 +3578,11 @@ export class BridgeWebSocketServer {
                                         : {}),
                                 }
                                 : {}),
-                        }));
+                        });
+                        if (!this.completeResumeOperation(resumeOperation.key, resumeOperation.operationId, sessionId, createdMessage)) {
+                            this.sessionManager.destroy(sessionId);
+                            break;
+                        }
                         this.broadcastSessionList();
                         this.debugEvents.set(sessionId, []);
                         this.recordDebugEvent(sessionId, {
@@ -3537,29 +3592,36 @@ export class BridgeWebSocketServer {
                             detail: `provider=codex thread=${sessionRefId}`,
                         });
                         this.projectHistory?.addProject(effectiveProjectPath);
+                        console.info(formatResumePerformanceLog({
+                            provider: "codex",
+                            sourceSessionId: sessionRefId,
+                            outcome: "success",
+                            ...historyMetrics,
+                            historyLoadMs,
+                            sessionCreateMs,
+                            nameLoadMs,
+                            totalMs: Date.now() - resumeStartedAt,
+                        }));
                     }
                     catch (err) {
-                        this.send(ws, {
-                            type: "error",
-                            message: `Failed to load Codex session history: ${err}`,
-                        });
+                        if (!historyLoaded) {
+                            historyLoadMs = Date.now() - historyStartedAt;
+                        }
+                        console.info(formatResumePerformanceLog({
+                            provider: "codex",
+                            sourceSessionId: sessionRefId,
+                            outcome: "failed",
+                            ...historyMetrics,
+                            historyLoadMs,
+                            sessionCreateMs,
+                            nameLoadMs,
+                            totalMs: Date.now() - resumeStartedAt,
+                        }));
+                        this.failResumeOperation(resumeOperation.key, resumeOperation.operationId, `Failed to load Codex session history: ${err}`);
                     }
                     break;
                 }
                 const claudeSessionId = sessionRefId;
-                let pendingResumes = this.pendingClaudeResumeInputs.get(ws);
-                if (!pendingResumes) {
-                    pendingResumes = new Map();
-                    this.pendingClaudeResumeInputs.set(ws, pendingResumes);
-                }
-                if (pendingResumes.has(claudeSessionId)) {
-                    this.send(ws, {
-                        type: "error",
-                        message: `Session resume already in progress: ${claudeSessionId}`,
-                    });
-                    break;
-                }
-                pendingResumes.set(claudeSessionId, []);
                 // Look up worktree mapping for this Claude session
                 const wtMapping = this.worktreeStore.get(claudeSessionId);
                 let worktreeOpts;
@@ -3579,8 +3641,26 @@ export class BridgeWebSocketServer {
                         };
                     }
                 }
+                const resumeOperation = this.beginResumeOperation({
+                    ws,
+                    provider: "claude",
+                    sourceSessionId: claudeSessionId,
+                    projectPath: resumeProjectPath,
+                    request: msg,
+                });
+                if (!resumeOperation.isOwner)
+                    break;
+                const historyStartedAt = Date.now();
+                let historyMetrics = summarizeResumeHistory([]);
+                let historyLoadMs = 0;
+                let historyLoaded = false;
+                let sessionCreateMs = 0;
                 getSessionHistory(claudeSessionId)
                     .then((pastMessages) => {
+                    historyLoadMs = Date.now() - historyStartedAt;
+                    historyLoaded = true;
+                    historyMetrics = summarizeResumeHistory(pastMessages);
+                    const createStartedAt = Date.now();
                     const { sessionId, permissionMode: effectivePermissionMode, executionMode: effectiveExecutionMode, planMode: effectivePlanMode, usedFallback: autoFallbackUsed, } = this.createClaudeSessionWithFallback({
                         projectPath: resumeProjectPath,
                         options: {
@@ -3600,10 +3680,12 @@ export class BridgeWebSocketServer {
                         pastMessages,
                         worktreeOptions: worktreeOpts,
                     });
+                    sessionCreateMs = Date.now() - createStartedAt;
                     const createdSession = this.sessionManager.get(sessionId);
                     const cached = this.sessionManager.getCachedCommands("claude", createdSession?.worktreePath ?? resumeProjectPath);
+                    const nameStartedAt = Date.now();
                     const finishResume = () => {
-                        this.send(ws, {
+                        const createdMessage = {
                             ...this.buildSessionCreatedMessage({
                                 sessionId,
                                 provider: "claude",
@@ -3632,16 +3714,25 @@ export class BridgeWebSocketServer {
                                     : {}),
                             }),
                             claudeSessionId,
-                        });
-                        const queuedInputs = pendingResumes.get(claudeSessionId) ?? [];
-                        pendingResumes.delete(claudeSessionId);
-                        for (const input of queuedInputs) {
-                            void this.handleClientMessage({ ...input, sessionId }, ws);
+                        };
+                        if (!this.completeResumeOperation(resumeOperation.key, resumeOperation.operationId, sessionId, createdMessage)) {
+                            this.sessionManager.destroy(sessionId);
+                            return;
                         }
                         this.broadcastSessionList();
                         if (autoFallbackUsed) {
                             this.sendTip(ws, sessionId, "auto_mode_fallback_default", createdSession);
                         }
+                        console.info(formatResumePerformanceLog({
+                            provider: "claude",
+                            sourceSessionId: claudeSessionId,
+                            outcome: "success",
+                            ...historyMetrics,
+                            historyLoadMs,
+                            sessionCreateMs,
+                            nameLoadMs: Date.now() - nameStartedAt,
+                            totalMs: Date.now() - resumeStartedAt,
+                        }));
                     };
                     void this.loadAndSetSessionName(createdSession, "claude", resumeProjectPath, claudeSessionId).then(finishResume, (err) => {
                         console.error("[ws] Failed to load resumed session name:", err);
@@ -3657,22 +3748,20 @@ export class BridgeWebSocketServer {
                     this.projectHistory?.addProject(resumeProjectPath);
                 })
                     .catch((err) => {
-                    const queuedInputs = pendingResumes.get(claudeSessionId) ?? [];
-                    pendingResumes.delete(claudeSessionId);
-                    for (const input of queuedInputs) {
-                        if (input.clientMessageId) {
-                            this.send(ws, {
-                                type: "input_rejected",
-                                sessionId: claudeSessionId,
-                                clientMessageId: input.clientMessageId,
-                                reason: "Session resume failed",
-                            });
-                        }
+                    if (!historyLoaded) {
+                        historyLoadMs = Date.now() - historyStartedAt;
                     }
-                    this.send(ws, {
-                        type: "error",
-                        message: `Failed to load session history: ${err}`,
-                    });
+                    console.info(formatResumePerformanceLog({
+                        provider: "claude",
+                        sourceSessionId: claudeSessionId,
+                        outcome: "failed",
+                        ...historyMetrics,
+                        historyLoadMs,
+                        sessionCreateMs,
+                        nameLoadMs: 0,
+                        totalMs: Date.now() - resumeStartedAt,
+                    }));
+                    this.failResumeOperation(resumeOperation.key, resumeOperation.operationId, `Failed to load session history: ${err}`);
                 });
                 break;
             }
@@ -4980,6 +5069,199 @@ export class BridgeWebSocketServer {
     clearPendingClaudeResumeInputs(ws) {
         this.pendingClaudeResumeInputs.get(ws)?.clear();
         this.pendingClaudeResumeInputs.delete(ws);
+        for (const operation of this.resumeOperations.values()) {
+            operation.waiters.delete(ws);
+        }
+    }
+    resumeOperationKey(provider, sourceSessionId) {
+        return `${provider}:${sourceSessionId}`;
+    }
+    resumeRequestFingerprint(msg) {
+        return JSON.stringify({
+            provider: msg.provider ?? "claude",
+            sessionId: msg.sessionId,
+            projectPath: msg.projectPath,
+            permissionMode: msg.permissionMode,
+            executionMode: msg.executionMode,
+            approvalPolicy: msg.approvalPolicy,
+            approvalsReviewer: msg.approvalsReviewer,
+            codexPermissionsMode: msg.codexPermissionsMode,
+            planMode: msg.planMode,
+            sandboxMode: msg.sandboxMode,
+            model: msg.model,
+            effort: msg.effort,
+            maxTurns: msg.maxTurns,
+            maxBudgetUsd: msg.maxBudgetUsd,
+            fallbackModel: msg.fallbackModel,
+            forkSession: msg.forkSession ?? false,
+            persistSession: msg.persistSession,
+            profile: msg.profile,
+            modelReasoningEffort: msg.modelReasoningEffort,
+            serviceTier: msg.serviceTier,
+            networkAccessEnabled: msg.networkAccessEnabled,
+            webSearchMode: msg.webSearchMode,
+            additionalWritableRoots: [...(msg.additionalWritableRoots ?? [])].sort(),
+        });
+    }
+    clearResumeOperation(key, operation) {
+        if (operation.timeout)
+            clearTimeout(operation.timeout);
+        if (this.resumeOperations.get(key) === operation) {
+            this.resumeOperations.delete(key);
+        }
+    }
+    ensurePendingClaudeResume(ws, sourceSessionId) {
+        let pendingResumes = this.pendingClaudeResumeInputs.get(ws);
+        if (!pendingResumes) {
+            pendingResumes = new Map();
+            this.pendingClaudeResumeInputs.set(ws, pendingResumes);
+        }
+        if (!pendingResumes.has(sourceSessionId)) {
+            pendingResumes.set(sourceSessionId, []);
+        }
+    }
+    beginResumeOperation(params) {
+        const { ws, provider, sourceSessionId, projectPath, request } = params;
+        const key = this.resumeOperationKey(provider, sourceSessionId);
+        const fingerprint = this.resumeRequestFingerprint(request);
+        let operation = this.resumeOperations.get(key);
+        if (operation?.completed &&
+            (!this.sessionManager.get(operation.completed.sessionId) ||
+                Date.now() - operation.completed.completedAt >
+                    RESUME_COMPLETED_TTL_MS ||
+                operation.fingerprint !== fingerprint ||
+                request.forkSession === true)) {
+            this.clearResumeOperation(key, operation);
+            operation = undefined;
+        }
+        if (operation &&
+            !operation.completed &&
+            operation.fingerprint !== fingerprint) {
+            this.sendResumeFailed(ws, {
+                provider,
+                sourceSessionId,
+                projectPath,
+            });
+            this.send(ws, {
+                type: "error",
+                message: "This session is already being restored with different settings. Wait for it to finish, then try again.",
+            });
+            return { key, operationId: operation.id, isOwner: false };
+        }
+        this.send(ws, {
+            type: "system",
+            subtype: "session_resume_started",
+            sourceSessionId,
+            provider,
+            projectPath,
+        });
+        if (provider === "claude") {
+            this.ensurePendingClaudeResume(ws, sourceSessionId);
+        }
+        if (operation) {
+            if (operation.completed) {
+                this.send(ws, operation.completed.message);
+                this.flushPendingClaudeResumeInputs(ws, sourceSessionId, operation.completed.sessionId);
+            }
+            else {
+                operation.waiters.add(ws);
+            }
+            return { key, operationId: operation.id, isOwner: false };
+        }
+        const operationId = randomUUID();
+        const newOperation = {
+            id: operationId,
+            provider,
+            sourceSessionId,
+            projectPath,
+            fingerprint,
+            waiters: new Set([ws]),
+        };
+        const timeout = setTimeout(() => {
+            this.failResumeOperation(key, operationId, "Session restore is taking longer than expected. Please reconnect and try again.");
+        }, RESUME_OPERATION_TIMEOUT_MS);
+        timeout.unref?.();
+        newOperation.timeout = timeout;
+        this.resumeOperations.set(key, newOperation);
+        return { key, operationId, isOwner: true };
+    }
+    completeResumeOperation(key, operationId, sessionId, message) {
+        const operation = this.resumeOperations.get(key);
+        if (!operation || operation.id !== operationId)
+            return false;
+        if (operation.timeout)
+            clearTimeout(operation.timeout);
+        operation.completed = {
+            sessionId,
+            message,
+            completedAt: Date.now(),
+        };
+        for (const waiter of operation.waiters) {
+            this.send(waiter, message);
+            this.flushPendingClaudeResumeInputs(waiter, operation.sourceSessionId, sessionId);
+        }
+        operation.waiters.clear();
+        const timeout = setTimeout(() => {
+            this.clearResumeOperation(key, operation);
+        }, RESUME_COMPLETED_TTL_MS);
+        timeout.unref?.();
+        operation.timeout = timeout;
+        this.pruneCompletedResumeOperations();
+        return true;
+    }
+    failResumeOperation(key, operationId, message) {
+        const operation = this.resumeOperations.get(key);
+        if (!operation || operation.id !== operationId)
+            return;
+        this.clearResumeOperation(key, operation);
+        for (const waiter of operation.waiters) {
+            this.rejectPendingClaudeResumeInputs(waiter, operation.sourceSessionId);
+            this.sendResumeFailed(waiter, operation);
+            this.send(waiter, { type: "error", message });
+        }
+    }
+    sendResumeFailed(ws, resume) {
+        this.send(ws, {
+            type: "system",
+            subtype: "session_resume_failed",
+            provider: resume.provider,
+            sourceSessionId: resume.sourceSessionId,
+            projectPath: resume.projectPath,
+        });
+    }
+    flushPendingClaudeResumeInputs(ws, sourceSessionId, sessionId) {
+        const pendingResumes = this.pendingClaudeResumeInputs.get(ws);
+        const queuedInputs = pendingResumes?.get(sourceSessionId) ?? [];
+        pendingResumes?.delete(sourceSessionId);
+        for (const input of queuedInputs) {
+            void this.handleClientMessage({ ...input, sessionId }, ws);
+        }
+    }
+    rejectPendingClaudeResumeInputs(ws, sourceSessionId) {
+        const pendingResumes = this.pendingClaudeResumeInputs.get(ws);
+        const queuedInputs = pendingResumes?.get(sourceSessionId) ?? [];
+        pendingResumes?.delete(sourceSessionId);
+        for (const input of queuedInputs) {
+            if (!input.clientMessageId)
+                continue;
+            this.send(ws, {
+                type: "input_rejected",
+                sessionId: sourceSessionId,
+                clientMessageId: input.clientMessageId,
+                reason: "Session resume failed",
+            });
+        }
+    }
+    pruneCompletedResumeOperations() {
+        const completed = [...this.resumeOperations.entries()]
+            .filter((entry) => entry[1].completed)
+            .sort((a, b) => (a[1].completed?.completedAt ?? 0) -
+            (b[1].completed?.completedAt ?? 0));
+        while (completed.length > 100) {
+            const oldest = completed.shift();
+            if (oldest)
+                this.clearResumeOperation(oldest[0], oldest[1]);
+        }
     }
     /**
      * Load the saved session name from CLI storage and set it on the SessionInfo.