@ccpocket/bridge 1.74.0 → 1.76.0

package/dist/websocket.js

@@ -2,7 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { execFile, execFileSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { lstat, readFile, readlink, realpath, stat, unlink } from "node:fs/promises";
-import { resolve, extname } from "node:path";
+import { resolve, extname, posix, win32 } from "node:path";
 import { promisify } from "node:util";
 import { WebSocketServer, WebSocket } from "ws";
 import { SessionManager, MAX_HISTORY_PER_SESSION, } from "./session.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 { isSafeUploadFileName, UploadStoreError, } from "./upload-store.js";
 import { formatResumePerformanceLog, summarizeResumeHistory, } from "./resume-metrics.js";
 import { ArchiveStore } from "./archive-store.js";
 import { WorktreeStore } from "./worktree-store.js";
@@ -394,6 +395,44 @@ function normalizeNonNegativeLimit(value, fallback) {
         ? value
         : fallback;
 }
+export function downloadMimeType(filePath) {
+    const extension = extname(filePath).toLowerCase();
+    const mimeTypes = {
+        ".aac": "audio/aac",
+        ".avi": "video/x-msvideo",
+        ".bmp": "image/bmp",
+        ".csv": "text/csv",
+        ".doc": "application/msword",
+        ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        ".gif": "image/gif",
+        ".gz": "application/gzip",
+        ".html": "text/html",
+        ".jpeg": "image/jpeg",
+        ".jpg": "image/jpeg",
+        ".json": "application/json",
+        ".m4a": "audio/mp4",
+        ".md": "text/markdown",
+        ".mov": "video/quicktime",
+        ".mp3": "audio/mpeg",
+        ".mp4": "video/mp4",
+        ".ogg": "audio/ogg",
+        ".pdf": "application/pdf",
+        ".png": "image/png",
+        ".ppt": "application/vnd.ms-powerpoint",
+        ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+        ".svg": "image/svg+xml",
+        ".tar": "application/x-tar",
+        ".txt": "text/plain",
+        ".wav": "audio/wav",
+        ".webm": "video/webm",
+        ".webp": "image/webp",
+        ".xls": "application/vnd.ms-excel",
+        ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        ".xml": "application/xml",
+        ".zip": "application/zip",
+    };
+    return mimeTypes[extension] ?? "application/octet-stream";
+}
 function codexThreadToRecentSession(thread, indexed) {
     // thread/list only exposes a single preview blob; prefer the real
     // first/last/summary texts parsed from the rollout file so display-mode
@@ -444,6 +483,8 @@ export class BridgeWebSocketServer {
     static CONNECT_METADATA_REFRESH_COOLDOWN_MS = 5 * 60 * 1000;
     static DEFAULT_FILE_LIST_MAX_ENTRIES = 5000;
     static DEFAULT_FILE_LIST_MAX_BYTES = 512 * 1024;
+    static DEFAULT_FILE_DOWNLOAD_MAX_BYTES = 512 * 1024 * 1024;
+    static DEFAULT_FILE_UPLOAD_MAX_BYTES = 512 * 1024 * 1024;
     static DEFAULT_DELTA_BATCH_MS = 100;
     static DEFAULT_DELTA_BATCH_MAX_CHARS = 4096;
     wss;
@@ -452,6 +493,7 @@ export class BridgeWebSocketServer {
     allowedDirs;
     imageStore;
     mediaStore;
+    uploadStore;
     galleryStore;
     projectHistory;
     debugTraceStore;
@@ -495,6 +537,8 @@ export class BridgeWebSocketServer {
     failSetSandboxMode = envFlagEnabled("BRIDGE_FAIL_SET_SANDBOX_MODE");
     fileListMaxEntries;
     fileListMaxBytes;
+    fileDownloadMaxBytes;
+    fileUploadMaxBytes;
     deltaBatchMs;
     deltaBatchMaxChars;
     deltaBatches = new Map();
@@ -503,11 +547,12 @@ export class BridgeWebSocketServer {
     pendingClaudeResumeInputs = new WeakMap();
     resumeOperations = new Map();
     constructor(options) {
-        const { server, apiKey, allowedDirs, imageStore, mediaStore, galleryStore, projectHistory, debugTraceStore, recordingStore, firebaseAuth, promptHistoryBackup, promptHistoryStore, platform, fileListMaxEntries, fileListMaxBytes, deltaBatchMs, deltaBatchMaxChars, } = options;
+        const { server, apiKey, allowedDirs, imageStore, mediaStore, uploadStore, galleryStore, projectHistory, debugTraceStore, recordingStore, firebaseAuth, promptHistoryBackup, promptHistoryStore, platform, fileListMaxEntries, fileListMaxBytes, fileDownloadMaxBytes, fileUploadMaxBytes, deltaBatchMs, deltaBatchMaxChars, } = options;
         this.apiKey = apiKey ?? null;
         this.allowedDirs = allowedDirs ?? [];
         this.imageStore = imageStore ?? null;
         this.mediaStore = mediaStore ?? null;
+        this.uploadStore = uploadStore ?? null;
         this.galleryStore = galleryStore ?? null;
         this.projectHistory = projectHistory ?? null;
         this.debugTraceStore = debugTraceStore ?? new DebugTraceStore();
@@ -519,6 +564,8 @@ export class BridgeWebSocketServer {
         this.platform = platform ?? process.platform;
         this.fileListMaxEntries = normalizePositiveLimit(fileListMaxEntries, positiveEnvInt("BRIDGE_FILE_LIST_MAX_ENTRIES", BridgeWebSocketServer.DEFAULT_FILE_LIST_MAX_ENTRIES));
         this.fileListMaxBytes = normalizePositiveLimit(fileListMaxBytes, positiveEnvInt("BRIDGE_FILE_LIST_MAX_BYTES", BridgeWebSocketServer.DEFAULT_FILE_LIST_MAX_BYTES));
+        this.fileDownloadMaxBytes = normalizePositiveLimit(fileDownloadMaxBytes, positiveEnvInt("BRIDGE_FILE_DOWNLOAD_MAX_SIZE_MB", BridgeWebSocketServer.DEFAULT_FILE_DOWNLOAD_MAX_BYTES / 1024 / 1024) * 1024 * 1024);
+        this.fileUploadMaxBytes = normalizePositiveLimit(fileUploadMaxBytes, positiveEnvInt("BRIDGE_FILE_UPLOAD_MAX_SIZE_MB", BridgeWebSocketServer.DEFAULT_FILE_UPLOAD_MAX_BYTES / 1024 / 1024) * 1024 * 1024);
         this.deltaBatchMs = normalizeNonNegativeLimit(deltaBatchMs, nonNegativeEnvInt("BRIDGE_DELTA_BATCH_MS", BridgeWebSocketServer.DEFAULT_DELTA_BATCH_MS));
         this.deltaBatchMaxChars = normalizePositiveLimit(deltaBatchMaxChars, positiveEnvInt("BRIDGE_DELTA_BATCH_MAX_CHARS", BridgeWebSocketServer.DEFAULT_DELTA_BATCH_MAX_CHARS));
         this.archiveStore = new ArchiveStore();
@@ -595,6 +642,155 @@ export class BridgeWebSocketServer {
         }
         return false;
     }
+    sendFileDownloadError(ws, request, errorCode, message) {
+        this.send(ws, {
+            type: "error",
+            errorCode,
+            message,
+            path: request.filePath,
+            requestId: request.requestId,
+        });
+    }
+    async prepareFileDownload(ws, request) {
+        const pathApi = this.platform === "win32" ? win32 : posix;
+        const projectPath = pathApi.resolve(request.projectPath);
+        if (pathApi.isAbsolute(request.filePath)) {
+            this.sendFileDownloadError(ws, request, "file_download_not_allowed", "Only project-relative file paths can be downloaded.");
+            return;
+        }
+        const requestedPath = pathApi.resolve(projectPath, request.filePath);
+        if (!this.isPathAllowed(projectPath) ||
+            !isPathWithinAllowedDirectory(requestedPath, projectPath, this.platform)) {
+            this.sendFileDownloadError(ws, request, "file_download_not_allowed", "The requested file is outside the current project.");
+            return;
+        }
+        let canonicalProjectPath;
+        try {
+            canonicalProjectPath = await realpath(projectPath);
+            const projectStat = await stat(canonicalProjectPath);
+            if (!projectStat.isDirectory())
+                throw new Error("not a directory");
+        }
+        catch {
+            this.sendFileDownloadError(ws, request, "file_download_not_allowed", "The current project is unavailable or not allowed.");
+            return;
+        }
+        let canonicalFilePath;
+        try {
+            canonicalFilePath = await realpath(requestedPath);
+        }
+        catch {
+            this.sendFileDownloadError(ws, request, "file_download_not_found", "File not found.");
+            return;
+        }
+        if (!isPathWithinAllowedDirectory(canonicalFilePath, canonicalProjectPath, this.platform) ||
+            !(await this.isCanonicalPathAllowed(canonicalFilePath))) {
+            this.sendFileDownloadError(ws, request, "file_download_not_allowed", "The requested file resolves outside the current project.");
+            return;
+        }
+        try {
+            const fileStat = await stat(canonicalFilePath);
+            if (!fileStat.isFile()) {
+                this.sendFileDownloadError(ws, request, "file_download_not_file", "Only regular files can be downloaded.");
+                return;
+            }
+            if (fileStat.size > this.fileDownloadMaxBytes) {
+                const maxSizeMb = Math.max(1, Math.ceil(this.fileDownloadMaxBytes / 1024 / 1024));
+                this.sendFileDownloadError(ws, request, "file_download_too_large", `File is too large to download. Maximum size is ${maxSizeMb} MB.`);
+                return;
+            }
+            if (!this.mediaStore) {
+                this.sendFileDownloadError(ws, request, "file_download_unavailable", "File downloads are unavailable on this Bridge.");
+                return;
+            }
+            const fileName = pathApi.basename(requestedPath);
+            const mimeType = downloadMimeType(fileName);
+            const ref = await this.mediaStore.register(canonicalFilePath, mimeType, fileStat.size, fileName);
+            this.send(ws, {
+                type: "file_download_ready",
+                requestId: request.requestId,
+                filePath: request.filePath,
+                fileName,
+                mimeType: ref.mimeType,
+                sizeBytes: ref.sizeBytes,
+                downloadUrl: ref.url,
+            });
+        }
+        catch {
+            this.sendFileDownloadError(ws, request, "file_download_failed", "Unable to prepare the file download.");
+        }
+    }
+    sendFileUploadError(ws, requestId, errorCode, message, path) {
+        this.send(ws, { type: "error", errorCode, message, requestId, path });
+    }
+    async prepareFileUpload(ws, request) {
+        const pathApi = this.platform === "win32" ? win32 : posix;
+        const projectPath = pathApi.resolve(request.projectPath);
+        if (!this.uploadStore ||
+            pathApi.isAbsolute(request.directoryPath) ||
+            !isSafeUploadFileName(request.fileName)) {
+            this.sendFileUploadError(ws, request.requestId, !this.uploadStore ? "file_upload_unavailable" : "file_upload_not_allowed", !this.uploadStore
+                ? "File uploads are unavailable on this Bridge."
+                : "The upload destination or file name is not allowed.", request.directoryPath);
+            return;
+        }
+        if (request.sizeBytes > this.fileUploadMaxBytes) {
+            this.sendFileUploadError(ws, request.requestId, "file_upload_too_large", `File is too large to upload. Maximum size is ${Math.ceil(this.fileUploadMaxBytes / 1024 / 1024)} MB.`, request.fileName);
+            return;
+        }
+        const requestedDirectory = pathApi.resolve(projectPath, request.directoryPath || ".");
+        if (!this.isPathAllowed(projectPath) ||
+            !isPathWithinAllowedDirectory(requestedDirectory, projectPath, this.platform)) {
+            this.sendFileUploadError(ws, request.requestId, "file_upload_not_allowed", "The upload destination is outside the current project.", request.directoryPath);
+            return;
+        }
+        try {
+            const canonicalProject = await realpath(projectPath);
+            const canonicalDirectory = await realpath(requestedDirectory);
+            const directoryStat = await stat(canonicalDirectory);
+            if (!directoryStat.isDirectory() ||
+                !isPathWithinAllowedDirectory(canonicalDirectory, canonicalProject, this.platform) ||
+                !(await this.isCanonicalPathAllowed(canonicalDirectory))) {
+                throw new UploadStoreError("file_upload_directory_changed", "The upload destination is not allowed.");
+            }
+            const ref = await this.uploadStore.register({
+                directoryPath: canonicalDirectory,
+                relativeDirectoryPath: pathApi
+                    .relative(projectPath, requestedDirectory)
+                    .split(pathApi.sep)
+                    .join("/"),
+                fileName: request.fileName,
+                sizeBytes: request.sizeBytes,
+                conflictPolicy: request.conflictPolicy,
+            });
+            this.send(ws, {
+                type: "file_upload_ready",
+                requestId: request.requestId,
+                fileName: request.fileName,
+                sizeBytes: request.sizeBytes,
+                uploadUrl: ref.url,
+                uploadToken: ref.token,
+            });
+        }
+        catch (error) {
+            const known = error instanceof UploadStoreError ? error : null;
+            this.sendFileUploadError(ws, request.requestId, known?.code ?? "file_upload_directory_not_found", known?.message ?? "The upload destination was not found or is not allowed.", request.directoryPath);
+        }
+    }
+    async finalizeFileUpload(ws, request) {
+        if (!this.uploadStore) {
+            this.sendFileUploadError(ws, request.requestId, "file_upload_unavailable", "File uploads are unavailable on this Bridge.");
+            return;
+        }
+        try {
+            const result = await this.uploadStore.finalize(request.uploadToken, request.sha256);
+            this.send(ws, { type: "file_upload_complete", requestId: request.requestId, ...result });
+        }
+        catch (error) {
+            const known = error instanceof UploadStoreError ? error : null;
+            this.sendFileUploadError(ws, request.requestId, known?.code ?? "file_upload_failed", known?.message ?? "Unable to finish the file upload.");
+        }
+    }
     /** Build a user-friendly error for disallowed project paths. */
     buildPathNotAllowedError(projectPath) {
         return {
@@ -4013,6 +4209,23 @@ export class BridgeWebSocketServer {
                 }
                 break;
             }
+            case "prepare_file_download": {
+                void this.prepareFileDownload(ws, msg);
+                break;
+            }
+            case "prepare_file_upload": {
+                void this.prepareFileUpload(ws, msg);
+                break;
+            }
+            case "finalize_file_upload": {
+                void this.finalizeFileUpload(ws, msg);
+                break;
+            }
+            case "cancel_file_upload": {
+                if (this.uploadStore)
+                    void this.uploadStore.cancel(msg.uploadToken);
+                break;
+            }
             case "read_file":
             case "read_media_file": {
                 const absPath = resolve(msg.projectPath, msg.filePath);