@ccpocket/bridge 1.6.1 → 1.8.0

package/dist/websocket.js

@@ -1,5 +1,8 @@
 import { execFile, execFileSync } from "node:child_process";
-import { unlink } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { readFile, unlink } from "node:fs/promises";
+import { resolve, extname } from "node:path";
+import { promisify } from "node:util";
 import { WebSocketServer, WebSocket } from "ws";
 import { SessionManager } from "./session.js";
 import { SdkProcess } from "./sdk-process.js";
@@ -7,7 +10,7 @@ import { parseClientMessage } from "./parser.js";
 import { getAllRecentSessions, getCodexSessionHistory, getSessionHistory, findSessionsByClaudeIds, extractMessageImages, getClaudeSessionName, loadCodexSessionNames, renameClaudeSession, renameCodexSession } from "./sessions-index.js";
 import { ArchiveStore } from "./archive-store.js";
 import { WorktreeStore } from "./worktree-store.js";
-import { listWorktrees, removeWorktree, worktreeExists } from "./worktree.js";
+import { listWorktrees, removeWorktree, worktreeExists, getMainBranch } from "./worktree.js";
 import { listWindows, takeScreenshot } from "./screenshot.js";
 import { DebugTraceStore } from "./debug-trace-store.js";
 import { RecordingStore } from "./recording-store.js";
@@ -151,70 +154,76 @@ 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,
-                    continueMode: msg.continue,
-                    permissionMode: msg.permissionMode,
-                    model: msg.model,
-                    effort: msg.effort,
-                    maxTurns: msg.maxTurns,
-                    maxBudgetUsd: msg.maxBudgetUsd,
-                    fallbackModel: msg.fallbackModel,
-                    forkSession: msg.forkSession,
-                    persistSession: msg.persistSession,
-                }, undefined, {
-                    useWorktree: msg.useWorktree,
-                    worktreeBranch: msg.worktreeBranch,
-                    existingWorktreePath: msg.existingWorktreePath,
-                }, provider, provider === "codex"
-                    ? {
-                        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",
+                try {
+                    const provider = msg.provider ?? "claude";
+                    if (provider === "codex") {
+                        console.log(`[ws] start(codex): permissionMode=${msg.permissionMode} → collaboration=${msg.permissionMode === "plan" ? "plan" : "default"}`);
                     }
-                    : undefined);
-                const createdSession = this.sessionManager.get(sessionId);
-                // 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,
+                    const cached = provider === "claude" ? this.sessionManager.getCachedCommands(msg.projectPath) : undefined;
+                    const sessionId = this.sessionManager.create(msg.projectPath, {
+                        sessionId: msg.sessionId,
+                        continueMode: msg.continue,
+                        permissionMode: msg.permissionMode,
+                        model: msg.model,
+                        effort: msg.effort,
+                        maxTurns: msg.maxTurns,
+                        maxBudgetUsd: msg.maxBudgetUsd,
+                        fallbackModel: msg.fallbackModel,
+                        forkSession: msg.forkSession,
+                        persistSession: msg.persistSession,
+                    }, undefined, {
+                        useWorktree: msg.useWorktree,
+                        worktreeBranch: msg.worktreeBranch,
+                        existingWorktreePath: msg.existingWorktreePath,
+                    }, provider, provider === "codex"
+                        ? {
+                            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);
+                    // 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, {
+                        direction: "internal",
+                        channel: "bridge",
+                        type: "session_created",
+                        detail: `provider=${provider} projectPath=${msg.projectPath}`,
+                    });
+                    this.recordingStore.saveMeta(sessionId, {
+                        bridgeSessionId: sessionId,
                         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,
-                        } : {}),
+                        createdAt: new Date().toISOString(),
                     });
-                    this.broadcastSessionList();
-                });
-                this.debugEvents.set(sessionId, []);
-                this.recordDebugEvent(sessionId, {
-                    direction: "internal",
-                    channel: "bridge",
-                    type: "session_created",
-                    detail: `provider=${provider} projectPath=${msg.projectPath}`,
-                });
-                this.recordingStore.saveMeta(sessionId, {
-                    bridgeSessionId: sessionId,
-                    projectPath: msg.projectPath,
-                    createdAt: new Date().toISOString(),
-                });
-                this.projectHistory?.addProject(msg.projectPath);
+                    this.projectHistory?.addProject(msg.projectPath);
+                }
+                catch (err) {
+                    console.error(`[ws] Failed to start session:`, err);
+                    this.send(ws, { type: "error", message: `Failed to start session: ${err.message}` });
+                }
                 break;
             }
             case "input": {
@@ -959,14 +968,60 @@ export class BridgeWebSocketServer {
                         this.send(ws, { type: "diff_result", diff: "", error: `Failed to get diff: ${error}` });
                         return;
                     }
-                    this.send(ws, { type: "diff_result", diff });
+                    void this.collectImageChanges(msg.projectPath, diff).then((imageChanges) => {
+                        if (imageChanges.length > 0) {
+                            this.send(ws, { type: "diff_result", diff, imageChanges });
+                        }
+                        else {
+                            this.send(ws, { type: "diff_result", diff });
+                        }
+                    });
                 });
                 break;
             }
+            case "get_diff_image": {
+                if (msg.version === "both") {
+                    void (async () => {
+                        try {
+                            const [oldResult, newResult] = await Promise.all([
+                                this.loadDiffImageAsync(msg.projectPath, msg.filePath, "old"),
+                                this.loadDiffImageAsync(msg.projectPath, msg.filePath, "new"),
+                            ]);
+                            const errors = [oldResult.error, newResult.error].filter(Boolean);
+                            this.send(ws, {
+                                type: "diff_image_result",
+                                filePath: msg.filePath,
+                                version: "both",
+                                oldBase64: oldResult.base64,
+                                newBase64: newResult.base64,
+                                mimeType: oldResult.mimeType ?? newResult.mimeType,
+                                ...(errors.length > 0 ? { error: errors.join("; ") } : {}),
+                            });
+                        }
+                        catch {
+                            // WebSocket may have closed; ignore send errors.
+                        }
+                    })();
+                }
+                else {
+                    const version = msg.version;
+                    void (async () => {
+                        try {
+                            const result = await this.loadDiffImageAsync(msg.projectPath, msg.filePath, version);
+                            this.send(ws, { type: "diff_image_result", filePath: msg.filePath, version, ...result });
+                        }
+                        catch {
+                            // WebSocket may have closed; ignore send errors.
+                        }
+                    })();
+                }
+                break;
+            }
             case "list_worktrees": {
                 try {
                     const worktrees = listWorktrees(msg.projectPath);
-                    this.send(ws, { type: "worktree_list", worktrees });
+                    const mainBranch = getMainBranch(msg.projectPath);
+                    this.send(ws, { type: "worktree_list", worktrees, mainBranch });
                 }
                 catch (err) {
                     this.send(ws, { type: "error", message: `Failed to list worktrees: ${err}` });
@@ -1542,6 +1597,183 @@ export class BridgeWebSocketServer {
             callback({ diff: stdout });
         });
     }
+    // ---------------------------------------------------------------------------
+    // Image diff helpers
+    // ---------------------------------------------------------------------------
+    static IMAGE_EXTENSIONS = new Set([
+        ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".bmp", ".svg",
+    ]);
+    // Image diff thresholds (configurable via environment variables)
+    // - Auto-display: images ≤ threshold are sent inline as base64
+    // - Max size: images ≤ max are available for on-demand loading
+    // - Images > max size show text info only
+    static AUTO_DISPLAY_THRESHOLD = (() => {
+        const kb = parseInt(process.env.DIFF_IMAGE_AUTO_DISPLAY_KB ?? "", 10);
+        return Number.isFinite(kb) && kb > 0 ? kb * 1024 : 1024 * 1024; // default 1 MB
+    })();
+    static MAX_IMAGE_SIZE = (() => {
+        const mb = parseInt(process.env.DIFF_IMAGE_MAX_SIZE_MB ?? "", 10);
+        return Number.isFinite(mb) && mb > 0 ? mb * 1024 * 1024 : 5 * 1024 * 1024; // default 5 MB
+    })();
+    static mimeTypeForExt(ext) {
+        const map = {
+            ".png": "image/png",
+            ".jpg": "image/jpeg",
+            ".jpeg": "image/jpeg",
+            ".gif": "image/gif",
+            ".webp": "image/webp",
+            ".ico": "image/x-icon",
+            ".bmp": "image/bmp",
+            ".svg": "image/svg+xml",
+        };
+        return map[ext.toLowerCase()] ?? "application/octet-stream";
+    }
+    /**
+     * Scan diff text for image file changes and extract base64 data where appropriate.
+     *
+     * Detection strategy:
+     * 1. Binary markers: "Binary files a/<path> and b/<path> differ"
+     * 2. diff --git headers where the file extension is an image type
+     *
+     * For each detected image file:
+     * - Old version: `git show HEAD:<path>` (committed version)
+     * - New version: read from working tree
+     * - Apply size thresholds for auto-display / on-demand / text-only
+     */
+    async collectImageChanges(cwd, diffText) {
+        const entries = [];
+        const processedPaths = new Set();
+        const lines = diffText.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const gitMatch = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+            if (!gitMatch)
+                continue;
+            const filePath = gitMatch[2];
+            const ext = extname(filePath).toLowerCase();
+            if (!BridgeWebSocketServer.IMAGE_EXTENSIONS.has(ext))
+                continue;
+            if (processedPaths.has(filePath))
+                continue;
+            processedPaths.add(filePath);
+            let isNew = false;
+            let isDeleted = false;
+            for (let j = i + 1; j < Math.min(i + 6, lines.length); j++) {
+                if (lines[j].startsWith("diff --git "))
+                    break;
+                if (lines[j].startsWith("new file mode"))
+                    isNew = true;
+                if (lines[j].startsWith("deleted file mode"))
+                    isDeleted = true;
+            }
+            entries.push({
+                filePath,
+                isNew,
+                isDeleted,
+                isSvg: ext === ".svg",
+                mimeType: BridgeWebSocketServer.mimeTypeForExt(ext),
+                ext,
+            });
+        }
+        if (entries.length === 0)
+            return [];
+        // Phase 2: Read image data asynchronously
+        const execFileAsync = promisify(execFile);
+        const changes = [];
+        for (const entry of entries) {
+            let oldBuf;
+            let newBuf;
+            // Read old image (committed version)
+            if (!entry.isNew) {
+                try {
+                    const result = await execFileAsync("git", ["show", `HEAD:${entry.filePath}`], {
+                        cwd,
+                        maxBuffer: BridgeWebSocketServer.MAX_IMAGE_SIZE + 1024,
+                        encoding: "buffer",
+                    });
+                    oldBuf = result.stdout;
+                }
+                catch {
+                    // File may not exist in HEAD (e.g. untracked)
+                }
+            }
+            // Read new image (working tree)
+            if (!entry.isDeleted) {
+                try {
+                    const absPath = resolve(cwd, entry.filePath);
+                    if (existsSync(absPath)) {
+                        newBuf = await readFile(absPath);
+                    }
+                }
+                catch {
+                    // Ignore read errors
+                }
+            }
+            const oldSize = oldBuf?.length;
+            const newSize = newBuf?.length;
+            const maxSize = Math.max(oldSize ?? 0, newSize ?? 0);
+            const autoDisplay = maxSize <= BridgeWebSocketServer.AUTO_DISPLAY_THRESHOLD;
+            const loadable = autoDisplay || maxSize <= BridgeWebSocketServer.MAX_IMAGE_SIZE;
+            const change = {
+                filePath: entry.filePath,
+                isNew: entry.isNew,
+                isDeleted: entry.isDeleted,
+                isSvg: entry.isSvg,
+                mimeType: entry.mimeType,
+                loadable,
+                autoDisplay: autoDisplay || undefined,
+            };
+            if (oldSize !== undefined)
+                change.oldSize = oldSize;
+            if (newSize !== undefined)
+                change.newSize = newSize;
+            // Auto-display images are no longer embedded in the initial response.
+            // They are loaded on-demand when the Flutter widget becomes visible.
+            changes.push(change);
+        }
+        return changes;
+    }
+    /**
+     * Load a single diff image on demand (async I/O for better throughput).
+     */
+    async loadDiffImageAsync(cwd, filePath, version) {
+        // Path traversal guard: reject paths containing '..' or absolute paths
+        if (filePath.includes("..") || filePath.startsWith("/")) {
+            return { error: "Invalid file path" };
+        }
+        const ext = extname(filePath).toLowerCase();
+        if (!BridgeWebSocketServer.IMAGE_EXTENSIONS.has(ext)) {
+            return { error: "Not an image file" };
+        }
+        const mimeType = BridgeWebSocketServer.mimeTypeForExt(ext);
+        try {
+            const execFileAsync = promisify(execFile);
+            let buf;
+            if (version === "old") {
+                const result = await execFileAsync("git", ["show", `HEAD:${filePath}`], {
+                    cwd,
+                    maxBuffer: BridgeWebSocketServer.MAX_IMAGE_SIZE + 1024,
+                    encoding: "buffer",
+                });
+                buf = result.stdout;
+            }
+            else {
+                const absPath = resolve(cwd, filePath);
+                // Verify resolved path stays within cwd
+                if (!absPath.startsWith(resolve(cwd) + "/")) {
+                    return { error: "Invalid file path" };
+                }
+                buf = await readFile(absPath);
+            }
+            if (buf.length > BridgeWebSocketServer.MAX_IMAGE_SIZE) {
+                return { error: "Image too large" };
+            }
+            return { base64: buf.toString("base64"), mimeType };
+        }
+        catch (err) {
+            return { error: err instanceof Error ? err.message : String(err) };
+        }
+    }
     extractSessionIdFromClientMessage(msg) {
         return "sessionId" in msg && typeof msg.sessionId === "string" ? msg.sessionId : undefined;
     }