Harden managed cloud bridge lifecycle

esokullu · esokullu · commit 062dc54f3bc9 · 2026-07-13T04:05:42.000+03:00
diff --git a/src/chrome/src/cloud-runs.js b/src/chrome/src/cloud-runs.js
@@ -2,6 +2,9 @@ const DEFAULT_CLOUD_BRIDGE_URL = 'ws://127.0.0.1:17373/extension';
 const CLOUD_RUN_STORAGE_KEY = 'webbrainCloudRunSnapshots';
 const CLOUD_UPDATE_LIMIT = 200;
 const CLOUD_RUN_LIMIT = 50;
+const CLOUD_STRING_LIMIT = 16 * 1024;
+const CLOUD_RUN_PERSIST_BYTES_LIMIT = 256 * 1024;
+const CLOUD_PERSIST_BYTES_LIMIT = 4 * 1024 * 1024;
 const TERMINAL_STATUSES = new Set(['completed', 'failed', 'aborted']);
 
 export function normalizeCloudBridgeUrl(value = DEFAULT_CLOUD_BRIDGE_URL) {
@@ -22,21 +25,83 @@ function scrubCloudValue(value) {
       if ((key === '_attachImage' || key === 'screenshot') && typeof item === 'string' && item.length > 500) {
         return `[large payload omitted: ${item.length} chars]`;
       }
+      if (typeof item === 'string' && item.length > CLOUD_STRING_LIMIT) {
+        return `${item.slice(0, CLOUD_STRING_LIMIT)}\n[truncated ${item.length - CLOUD_STRING_LIMIT} chars for cloud persistence]`;
+      }
       return item;
     }));
   } catch {
     return { unserializable: true };
   }
 }
 
+function serializedBytes(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).length;
+}
+
+function compactCloudRunForPersistence(run) {
+  const row = scrubCloudValue(run);
+  row.structured = row.structured ?? !!run?.outputSchema;
+  if (serializedBytes(row) <= CLOUD_RUN_PERSIST_BYTES_LIMIT) return row;
+
+  const omittedUpdates = Array.isArray(row.updates) ? row.updates.length : 0;
+  row.updates = [];
+  row.persistenceTruncated = { omittedUpdates };
+  if (serializedBytes(row) <= CLOUD_RUN_PERSIST_BYTES_LIMIT) return row;
+
+  row.content = '';
+  row.outputSchema = null;
+  row.persistenceTruncated.omittedContent = true;
+  row.persistenceTruncated.omittedSchema = true;
+  if (serializedBytes(row) <= CLOUD_RUN_PERSIST_BYTES_LIMIT) return row;
+
+  delete row.result;
+  row.persistenceTruncated.omittedResult = true;
+  if (serializedBytes(row) <= CLOUD_RUN_PERSIST_BYTES_LIMIT) return row;
+
+  return scrubCloudValue({
+    runId: run?.runId,
+    status: run?.status,
+    tabId: run?.tabId,
+    task: run?.task,
+    structured: !!run?.outputSchema || run?.structured === true,
+    summary: run?.summary,
+    content: '',
+    finalUrl: run?.finalUrl,
+    error: run?.error,
+    createdAt: run?.createdAt,
+    updatedAt: run?.updatedAt,
+    completedAt: run?.completedAt,
+    updates: [],
+    persistenceTruncated: { omittedUpdates, omittedResult: true, omittedSchema: true },
+  });
+}
+
+export function buildCloudPersistenceRows(runs) {
+  const values = Array.isArray(runs) ? [...runs] : [...(runs?.values?.() || [])];
+  const candidates = values
+    .sort((a, b) => String(b?.createdAt || '').localeCompare(String(a?.createdAt || '')))
+    .slice(0, CLOUD_RUN_LIMIT)
+    .map(compactCloudRunForPersistence);
+  const rows = [];
+  let totalBytes = 2;
+  for (const row of candidates) {
+    const rowBytes = serializedBytes(row) + (rows.length ? 1 : 0);
+    if (totalBytes + rowBytes > CLOUD_PERSIST_BYTES_LIMIT) continue;
+    rows.push(row);
+    totalBytes += rowBytes;
+  }
+  return rows;
+}
+
 function cloudSnapshot(run, { includeUpdates = true } = {}) {
   if (!run) return null;
   return {
     runId: run.runId,
     status: run.status,
     tabId: run.tabId,
     task: run.task,
-    structured: !!run.outputSchema,
+    structured: run.structured ?? !!run.outputSchema,
     result: run.result,
     summary: run.summary,
     content: run.content,
@@ -79,10 +144,7 @@ export function createCloudRunController({
 
   async function persist() {
     if (!api.storage?.session?.set) return;
-    const rows = [...runs.values()]
-      .sort((a, b) => String(b.createdAt).localeCompare(String(a.createdAt)))
-      .slice(0, CLOUD_RUN_LIMIT)
-      .map(run => scrubCloudValue(run));
+    const rows = buildCloudPersistenceRows(runs);
     persistQueue = persistQueue
       .catch(() => {})
       .then(() => api.storage.session.set({ [CLOUD_RUN_STORAGE_KEY]: rows }));
diff --git a/src/chrome/src/offscreen/cloud-bridge.js b/src/chrome/src/offscreen/cloud-bridge.js
@@ -7,6 +7,7 @@
  */
 
 (() => {
+  const ALLOWED_BRIDGE_ACTIONS = new Set(['cloud_run', 'cloud_status', 'cloud_abort']);
   let socket = null;
   let bridgeUrl = null;
   let enabled = false;
@@ -34,10 +35,10 @@
     };
   }
 
-  function sendJson(obj) {
-    if (!socket || socket.readyState !== WebSocket.OPEN) return;
+  function sendJson(obj, target = socket) {
+    if (!target || target.readyState !== WebSocket.OPEN) return;
     try {
-      socket.send(JSON.stringify(obj));
+      target.send(JSON.stringify(obj));
     } catch (e) {
       lastError = e.message || String(e);
     }
@@ -56,26 +57,33 @@
     if (!enabled || !bridgeUrl) return;
     if (socket && (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING)) return;
     try {
-      socket = new WebSocket(bridgeUrl);
-      socket.addEventListener('open', () => {
+      const nextSocket = new WebSocket(bridgeUrl);
+      socket = nextSocket;
+      nextSocket.addEventListener('open', () => {
+        if (socket !== nextSocket) return;
         reconnectAttempt = 0;
         lastError = '';
-        sendJson({ type: 'hello', client: 'webbrain-extension', status: status() });
+        sendJson({ type: 'hello', client: 'webbrain-extension', status: status() }, nextSocket);
       });
-      socket.addEventListener('message', async (event) => {
+      nextSocket.addEventListener('message', async (event) => {
+        if (socket !== nextSocket) return;
         let msg;
         try {
           msg = JSON.parse(event.data);
         } catch (e) {
-          sendJson({ ok: false, error: `Invalid JSON message: ${e.message}` });
+          sendJson({ ok: false, error: `Invalid JSON message: ${e.message}` }, nextSocket);
           return;
         }
 
         const id = msg.id || null;
         const action = msg.action || msg.command;
         const payload = msg.payload || msg;
         if (!action) {
-          sendJson({ id, ok: false, error: 'Missing action' });
+          sendJson({ id, ok: false, error: 'Missing action' }, nextSocket);
+          return;
+        }
+        if (!ALLOWED_BRIDGE_ACTIONS.has(action)) {
+          sendJson({ id, ok: false, error: `Unsupported cloud bridge action: ${action}` }, nextSocket);
           return;
         }
 
@@ -85,20 +93,25 @@
             target: 'background',
             action,
           });
-          if (response && response.error) {
-            sendJson({ id, ok: false, error: response.error });
+          const isRunSnapshot = !!response
+            && (response.runId != null || response.run_id != null)
+            && typeof response.status === 'string';
+          if (response?.error && !isRunSnapshot) {
+            sendJson({ id, ok: false, error: response.error }, nextSocket);
           } else {
-            sendJson({ id, ok: true, result: response });
+            sendJson({ id, ok: true, result: response }, nextSocket);
           }
         } catch (e) {
-          sendJson({ id, ok: false, error: e.message || String(e) });
+          sendJson({ id, ok: false, error: e.message || String(e) }, nextSocket);
         }
       });
-      socket.addEventListener('close', () => {
+      nextSocket.addEventListener('close', () => {
+        if (socket !== nextSocket) return;
         socket = null;
         scheduleReconnect();
       });
-      socket.addEventListener('error', () => {
+      nextSocket.addEventListener('error', () => {
+        if (socket !== nextSocket) return;
         lastError = 'WebSocket error';
       });
     } catch (e) {
@@ -122,8 +135,9 @@
       enabled = true;
       bridgeUrl = nextUrl;
       if (changed && socket) {
-        try { socket.close(); } catch {}
+        const previousSocket = socket;
         socket = null;
+        try { previousSocket.close(); } catch {}
       }
       connect();
       sendResponse(status());
@@ -135,9 +149,10 @@
       reconnectTimer = null;
       reconnectAttempt = 0;
       if (socket) {
-        try { socket.close(); } catch {}
+        const previousSocket = socket;
+        socket = null;
+        try { previousSocket.close(); } catch {}
       }
-      socket = null;
       sendResponse(status());
       return false;
     }
diff --git a/test/run.js b/test/run.js
