@ccpocket/bridge 1.71.0 → 1.72.1

package/dist/websocket.js

@@ -1,4 +1,4 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { execFile, execFileSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { lstat, readFile, readlink, stat, unlink } from "node:fs/promises";
@@ -96,6 +96,7 @@ const OPT_IN_SERVER_MESSAGES = new Set([
     "goal_state",
     "guardian_approval",
     "prompt_history_status",
+    "push_registration_result",
 ]);
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -485,6 +486,9 @@ export class BridgeWebSocketServer {
     /** FCM token → push notification locale */
     tokenLocales = new Map();
     tokenPrivacyMode = new Map();
+    pushTokenGeneration = new Map();
+    pushTokenOperations = new Map();
+    nextPushTokenGeneration = 0;
     failSetPermissionMode = envFlagEnabled("BRIDGE_FAIL_SET_PERMISSION_MODE");
     failSetSandboxMode = envFlagEnabled("BRIDGE_FAIL_SET_SANDBOX_MODE");
     fileListMaxEntries;
@@ -579,6 +583,14 @@ export class BridgeWebSocketServer {
             errorCode: "path_not_allowed",
         };
     }
+    sendToolActionError(ws, message, error) {
+        this.send(ws, {
+            type: "error",
+            message: error,
+            sessionId: message.sessionId,
+            toolUseId: message.toolUseId ?? message.id,
+        });
+    }
     normalizeAdditionalWritableRoots(roots, projectPath) {
         if (!roots || roots.length === 0)
             return {};
@@ -2243,33 +2255,64 @@ export class BridgeWebSocketServer {
             case "push_register": {
                 const locale = normalizePushLocale(msg.locale);
                 const privacyMode = msg.privacyMode === true;
+                const supportsRegistrationResult = this.clientSupportedServerMessages
+                    .get(ws)
+                    ?.has("push_registration_result") ?? false;
                 console.log(`[ws] push_register received (platform: ${msg.platform}, locale: ${locale}, privacy: ${privacyMode}, configured: ${this.pushRelay.isConfigured})`);
+                const generation = this.beginPushTokenOperation(msg.token);
                 if (!this.pushRelay.isConfigured) {
-                    this.send(ws, {
-                        type: "error",
-                        message: "Push relay is not configured on bridge",
-                    });
+                    const error = "Push relay is not configured on bridge";
+                    this.send(ws, supportsRegistrationResult
+                        ? {
+                            type: "push_registration_result",
+                            token: msg.token,
+                            requestId: msg.requestId ?? "",
+                            success: false,
+                            error,
+                        }
+                        : { type: "error", message: error });
                     return;
                 }
-                this.tokenLocales.set(msg.token, locale);
-                this.tokenPrivacyMode.set(msg.token, privacyMode);
-                this.pushRelay
-                    .registerToken(msg.token, msg.platform, locale)
+                const operation = this.enqueuePushTokenOperation(msg.token, () => this.pushRelay.registerToken(msg.token, msg.platform, locale));
+                operation
                     .then(() => {
+                    if (!this.isCurrentPushTokenOperation(msg.token, generation))
+                        return;
                     console.log("[ws] push_register: token registered successfully");
+                    if (supportsRegistrationResult) {
+                        this.send(ws, {
+                            type: "push_registration_result",
+                            token: msg.token,
+                            requestId: msg.requestId ?? "",
+                            success: true,
+                        });
+                    }
+                    // Enable delivery only after the acknowledgement has been queued
+                    // on the WebSocket, keeping the app on local fallback until then.
+                    this.tokenLocales.set(msg.token, locale);
+                    this.tokenPrivacyMode.set(msg.token, privacyMode);
                 })
                     .catch((err) => {
+                    if (!this.isCurrentPushTokenOperation(msg.token, generation))
+                        return;
                     const detail = err instanceof Error ? err.message : String(err);
                     console.error(`[ws] push_register failed: ${detail}`);
-                    this.send(ws, {
-                        type: "error",
-                        message: `Failed to register push token: ${detail}`,
-                    });
+                    const error = `Failed to register push token: ${detail}`;
+                    this.send(ws, supportsRegistrationResult
+                        ? {
+                            type: "push_registration_result",
+                            token: msg.token,
+                            requestId: msg.requestId ?? "",
+                            success: false,
+                            error,
+                        }
+                        : { type: "error", message: error });
                 });
                 break;
             }
             case "push_unregister": {
                 console.log("[ws] push_unregister received");
+                const generation = this.beginPushTokenOperation(msg.token);
                 if (!this.pushRelay.isConfigured) {
                     this.send(ws, {
                         type: "error",
@@ -2277,14 +2320,15 @@ export class BridgeWebSocketServer {
                     });
                     return;
                 }
-                this.tokenLocales.delete(msg.token);
-                this.tokenPrivacyMode.delete(msg.token);
-                this.pushRelay
-                    .unregisterToken(msg.token)
+                this.enqueuePushTokenOperation(msg.token, () => this.pushRelay.unregisterToken(msg.token))
                     .then(() => {
+                    if (!this.isCurrentPushTokenOperation(msg.token, generation))
+                        return;
                     console.log("[ws] push_unregister: token unregistered successfully");
                 })
                     .catch((err) => {
+                    if (!this.isCurrentPushTokenOperation(msg.token, generation))
+                        return;
                     const detail = err instanceof Error ? err.message : String(err);
                     console.error(`[ws] push_unregister failed: ${detail}`);
                     this.send(ws, {
@@ -2964,11 +3008,14 @@ export class BridgeWebSocketServer {
             case "approve": {
                 const session = this.resolveSession(msg.sessionId);
                 if (!session) {
-                    this.send(ws, { type: "error", message: "No active session." });
+                    this.sendToolActionError(ws, msg, "No active session.");
                     return;
                 }
                 if (session.provider === "codex") {
-                    session.process.approve(msg.id);
+                    const handled = session.process.approve(msg.id);
+                    if (handled === false) {
+                        this.sendToolActionError(ws, msg, "No matching pending tool action.");
+                    }
                     break;
                 }
                 const sdkProc = session.process;
@@ -3016,70 +3063,85 @@ export class BridgeWebSocketServer {
                     this.broadcastSessionList();
                 }
                 else {
-                    sdkProc.approve(msg.id);
+                    const handled = sdkProc.approve(msg.id);
+                    if (handled === false) {
+                        this.sendToolActionError(ws, msg, "No matching pending tool action.");
+                    }
                 }
                 break;
             }
             case "approve_always": {
                 const session = this.resolveSession(msg.sessionId);
                 if (!session) {
-                    this.send(ws, { type: "error", message: "No active session." });
+                    this.sendToolActionError(ws, msg, "No active session.");
                     return;
                 }
                 if (session.provider === "codex") {
-                    session.process.approveAlways(msg.id);
+                    const handled = session.process.approveAlways(msg.id);
+                    if (handled === false) {
+                        this.sendToolActionError(ws, msg, "No matching pending tool action.");
+                    }
                     break;
                 }
-                session.process.approveAlways(msg.id);
+                const handled = session.process.approveAlways(msg.id);
+                if (handled === false) {
+                    this.sendToolActionError(ws, msg, "No matching pending tool action.");
+                }
                 break;
             }
             case "reject": {
                 const session = this.resolveSession(msg.sessionId);
                 if (!session) {
-                    this.send(ws, { type: "error", message: "No active session." });
+                    this.sendToolActionError(ws, msg, "No active session.");
                     return;
                 }
                 if (session.provider === "codex") {
-                    session.process.reject(msg.id, msg.message);
+                    const handled = session.process.reject(msg.id, msg.message);
+                    if (handled === false) {
+                        this.sendToolActionError(ws, msg, "No matching pending tool action.");
+                    }
                     break;
                 }
-                session.process.reject(msg.id, msg.message);
+                const handled = session.process.reject(msg.id, msg.message);
+                if (handled === false) {
+                    this.sendToolActionError(ws, msg, "No matching pending tool action.");
+                }
                 break;
             }
             case "answer": {
                 const session = this.resolveSession(msg.sessionId);
                 if (!session) {
-                    this.send(ws, { type: "error", message: "No active session." });
+                    this.sendToolActionError(ws, msg, "No active session.");
                     return;
                 }
                 if (session.provider === "codex") {
-                    session.process.answer(msg.toolUseId, msg.result);
+                    const handled = session.process.answer(msg.toolUseId, msg.result);
+                    if (handled === false) {
+                        this.sendToolActionError(ws, msg, "No matching pending tool action.");
+                    }
                     break;
                 }
-                session.process.answer(msg.toolUseId, msg.result);
+                const handled = session.process.answer(msg.toolUseId, msg.result);
+                if (handled === false) {
+                    this.sendToolActionError(ws, msg, "No matching pending tool action.");
+                }
                 break;
             }
             case "install_tool_suggestion": {
                 const session = this.resolveSession(msg.sessionId);
                 if (!session) {
-                    this.send(ws, { type: "error", message: "No active session." });
+                    this.sendToolActionError(ws, msg, "No active session.");
                     return;
                 }
                 if (session.provider !== "codex") {
-                    this.send(ws, {
-                        type: "error",
-                        message: "Tool suggestions are only supported for Codex sessions.",
-                    });
+                    this.sendToolActionError(ws, msg, "Tool suggestions are only supported for Codex sessions.");
                     return;
                 }
                 try {
                     await session.process.installToolSuggestion(msg.toolUseId);
                 }
                 catch (err) {
-                    this.send(ws, {
-                        type: "error",
-                        message: err instanceof Error ? err.message : String(err),
-                    });
+                    this.sendToolActionError(ws, msg, err instanceof Error ? err.message : String(err));
                 }
                 break;
             }
@@ -3882,7 +3944,7 @@ export class BridgeWebSocketServer {
             }
             case "list_directory": {
                 try {
-                    const listing = await listAllowedDirectories(msg.path, this.allowedDirs, this.platform);
+                    const listing = await listAllowedDirectories(msg.path, this.allowedDirs, this.platform, msg.includeHidden ?? false);
                     this.send(ws, {
                         type: "directory_listing",
                         path: listing.path,
@@ -6015,10 +6077,40 @@ export class BridgeWebSocketServer {
         const parts = session.projectPath.replace(/\/+$/, "").split("/");
         return parts[parts.length - 1] || "";
     }
-    /** Get unique locales from registered tokens. Falls back to ["en"] if none registered. */
+    beginPushTokenOperation(token) {
+        const generation = ++this.nextPushTokenGeneration;
+        this.pushTokenGeneration.set(token, generation);
+        // Local delivery is disabled synchronously while the relay operation is
+        // pending. The app stays on local fallback until a successful ACK.
+        this.tokenLocales.delete(token);
+        this.tokenPrivacyMode.delete(token);
+        return generation;
+    }
+    enqueuePushTokenOperation(token, operation) {
+        const previous = this.pushTokenOperations.get(token);
+        const pending = (previous?.catch(() => { }) ?? Promise.resolve()).then(operation);
+        this.pushTokenOperations.set(token, pending);
+        const cleanup = () => {
+            if (this.pushTokenOperations.get(token) === pending) {
+                this.pushTokenOperations.delete(token);
+            }
+        };
+        void pending.then(cleanup, cleanup);
+        return pending;
+    }
+    isCurrentPushTokenOperation(token, generation) {
+        return this.pushTokenGeneration.get(token) === generation;
+    }
+    /** Get unique locales from tokens acknowledged by the push relay. */
     getRegisteredLocales() {
         const locales = new Set(this.tokenLocales.values());
-        return locales.size > 0 ? [...locales] : ["en"];
+        return [...locales];
+    }
+    /** Hashes of relay tokens that are currently safe for remote delivery. */
+    getActivePushTokenHashes(locale) {
+        return [...this.tokenLocales]
+            .filter(([, tokenLocale]) => tokenLocale === locale)
+            .map(([token]) => createHash("sha256").update(token).digest("hex"));
     }
     /** Whether any registered token has privacy mode enabled (conservative: privacy wins). */
     isPrivacyMode() {
@@ -6040,6 +6132,8 @@ export class BridgeWebSocketServer {
     maybeSendPushNotification(sessionId, msg) {
         if (!this.pushRelay.isConfigured)
             return;
+        if (this.tokenLocales.size === 0)
+            return;
         const privacy = this.isPrivacyMode();
         const label = privacy ? "" : this.sessionLabel(sessionId);
         if (msg.type === "permission_request") {
@@ -6104,6 +6198,7 @@ export class BridgeWebSocketServer {
                     title,
                     body,
                     locale,
+                    tokenHashes: this.getActivePushTokenHashes(locale),
                     data,
                 })
                     .catch((err) => {
@@ -6177,6 +6272,7 @@ export class BridgeWebSocketServer {
                 title,
                 body,
                 locale,
+                tokenHashes: this.getActivePushTokenHashes(locale),
                 data,
             })
                 .catch((err) => {