chainlesschain 0.162.124 → 0.162.126

package/src/gateways/ws/message-dispatcher.js

@@ -23,7 +23,10 @@ export function createWsMessageDispatcher(server) {
       }
 
       const client = server.clients.get(clientId);
-      if (server.token && !client.authenticated && type !== "auth") {
+      // client may be undefined if it was removed mid-dispatch (heartbeat sweep
+      // / disconnect); treat a missing client as unauthenticated rather than
+      // throwing a TypeError (every sibling call site null-checks the client).
+      if (server.token && !client?.authenticated && type !== "auth") {
         server._send(ws, {
           id,
           type: "error",
@@ -103,199 +106,179 @@ export function createWsMessageDispatcher(server) {
         "llm.chat": () => server._handleLlmChat(id, ws, message),
       };
 
-      // Phase I — Hosted Session API streaming routes (stream.run).
-      // Each intermediate event goes out as { id, type: "stream.event", event }
-      // and the final response is sent by the normal ok/err wrapper.
-      for (const streamingType of Object.keys(
-        SESSION_CORE_STREAMING_HANDLERS,
-      )) {
-        routes[streamingType] = async () => {
-          const controller = new AbortController();
-          const client = server.clients.get(clientId);
-          if (client) {
-            client._streamAborts = client._streamAborts || new Map();
-            client._streamAborts.set(id, controller);
-          }
-          const sender = (payload) => server._send(ws, { id, ...payload });
-          const context = { server, ws, clientId };
-          try {
-            const result = await SESSION_CORE_STREAMING_HANDLERS[streamingType](
-              message,
-              sender,
-              controller.signal,
-              context,
-            );
-            server._send(ws, {
-              id,
-              type: `${streamingType}.end`,
-              ...result,
-            });
-          } catch (err) {
-            server._send(ws, {
-              id,
-              type: "error",
-              code: "STREAM_RUN_ERROR",
-              message: err?.message || String(err),
-            });
-          } finally {
-            if (client?._streamAborts) client._streamAborts.delete(id);
-          }
-        };
+      // Static core routes take precedence and are dispatched directly. The
+      // feature handler maps below are consulted ONLY when no static route
+      // matches — so a feature topic can never shadow a core protocol route
+      // (auth/cancel/ping/execute), and we no longer allocate a closure for all
+      // ~79 feature keys on every message (the old per-message Object.keys loops
+      // built the entire route table each dispatch). Only the matched handler
+      // runs.
+      const staticHandler = routes[type];
+      if (staticHandler) {
+        return staticHandler();
+      }
+
+      // Phase I — Hosted Session API streaming routes (stream.run). Each
+      // intermediate event goes out as { id, type:"stream.event", event } and
+      // the final response is sent by the normal ok/err wrapper.
+      if (SESSION_CORE_STREAMING_HANDLERS[type]) {
+        const controller = new AbortController();
+        const client = server.clients.get(clientId);
+        if (client) {
+          client._streamAborts = client._streamAborts || new Map();
+          client._streamAborts.set(id, controller);
+        }
+        const sender = (payload) => server._send(ws, { id, ...payload });
+        const context = { server, ws, clientId };
+        try {
+          const result = await SESSION_CORE_STREAMING_HANDLERS[type](
+            message,
+            sender,
+            controller.signal,
+            context,
+          );
+          server._send(ws, { id, type: `${type}.end`, ...result });
+        } catch (err) {
+          server._send(ws, {
+            id,
+            type: "error",
+            code: "STREAM_RUN_ERROR",
+            message: err?.message || String(err),
+          });
+        } finally {
+          if (client?._streamAborts) client._streamAborts.delete(id);
+        }
+        return;
       }
 
       // Video Editing streaming routes
-      for (const videoStreamType of Object.keys(VIDEO_STREAMING_HANDLERS)) {
-        routes[videoStreamType] = async () => {
-          const controller = new AbortController();
-          const client = server.clients.get(clientId);
-          if (client) {
-            client._streamAborts = client._streamAborts || new Map();
-            client._streamAborts.set(id, controller);
-          }
-          const sender = (payload) => server._send(ws, { id, ...payload });
-          try {
-            const result = await VIDEO_STREAMING_HANDLERS[videoStreamType](
-              message,
-              sender,
-              controller.signal,
-            );
-            server._send(ws, {
-              id,
-              type: `${videoStreamType}.end`,
-              ...result,
-            });
-          } catch (err) {
-            server._send(ws, {
-              id,
-              type: "error",
-              code: "VIDEO_STREAM_ERROR",
-              message: err?.message || String(err),
-            });
-          } finally {
-            if (client?._streamAborts) client._streamAborts.delete(id);
-          }
-        };
+      if (VIDEO_STREAMING_HANDLERS[type]) {
+        const controller = new AbortController();
+        const client = server.clients.get(clientId);
+        if (client) {
+          client._streamAborts = client._streamAborts || new Map();
+          client._streamAborts.set(id, controller);
+        }
+        const sender = (payload) => server._send(ws, { id, ...payload });
+        try {
+          const result = await VIDEO_STREAMING_HANDLERS[type](
+            message,
+            sender,
+            controller.signal,
+          );
+          server._send(ws, { id, type: `${type}.end`, ...result });
+        } catch (err) {
+          server._send(ws, {
+            id,
+            type: "error",
+            code: "VIDEO_STREAM_ERROR",
+            message: err?.message || String(err),
+          });
+        } finally {
+          if (client?._streamAborts) client._streamAborts.delete(id);
+        }
+        return;
       }
 
       // Video Editing request/response routes
-      for (const videoType of Object.keys(VIDEO_HANDLERS)) {
-        routes[videoType] = async () => {
-          try {
-            const result = await VIDEO_HANDLERS[videoType](message);
-            server._send(ws, {
-              id,
-              type: `${videoType}.response`,
-              ...result,
-            });
-          } catch (err) {
-            server._send(ws, {
-              id,
-              type: "error",
-              code: "VIDEO_ERROR",
-              message: err?.message || String(err),
-            });
-          }
-        };
+      if (VIDEO_HANDLERS[type]) {
+        try {
+          const result = await VIDEO_HANDLERS[type](message);
+          server._send(ws, { id, type: `${type}.response`, ...result });
+        } catch (err) {
+          server._send(ws, {
+            id,
+            type: "error",
+            code: "VIDEO_ERROR",
+            message: err?.message || String(err),
+          });
+        }
+        return;
       }
 
       // Personal Data Hub topics — same 10 surfaces as the Electron IPC
       // (see desktop-app-vue/src/main/ipc/personal-data-hub-ipc.js). Each
       // handler returns { result } or { error }; we wrap with the standard
       // response envelope so renderer code is shell-agnostic.
-      for (const hubType of Object.keys(PERSONAL_DATA_HUB_HANDLERS)) {
-        routes[hubType] = async () => {
-          try {
-            const out = await PERSONAL_DATA_HUB_HANDLERS[hubType](message);
-            if (out && out.error) {
-              server._send(ws, {
-                id,
-                type: "error",
-                code: "PERSONAL_DATA_HUB_ERROR",
-                message: out.error,
-              });
-            } else {
-              server._send(ws, {
-                id,
-                type: `${hubType}.response`,
-                result: out && out.result !== undefined ? out.result : out,
-              });
-            }
-          } catch (err) {
+      if (PERSONAL_DATA_HUB_HANDLERS[type]) {
+        try {
+          const out = await PERSONAL_DATA_HUB_HANDLERS[type](message);
+          if (out && out.error) {
             server._send(ws, {
               id,
               type: "error",
               code: "PERSONAL_DATA_HUB_ERROR",
-              message: err?.message || String(err),
-            });
-          }
-        };
-      }
-
-      // Phase 5.7 — streaming sync routes. Adapter progress events are
-      // pushed as `<topic>.event` messages tagged with the request id;
-      // the final report comes as `<topic>.end`.
-      for (const streamType of Object.keys(
-        PERSONAL_DATA_HUB_STREAMING_HANDLERS,
-      )) {
-        routes[streamType] = async () => {
-          const sender = (payload) => server._send(ws, { id, ...payload });
-          try {
-            const out = await PERSONAL_DATA_HUB_STREAMING_HANDLERS[streamType](
-              message,
-              sender,
-            );
-            server._send(ws, {
-              id,
-              type: `${streamType}.end`,
-              ...(out && out.result !== undefined
-                ? { result: out.result }
-                : out || {}),
+              message: out.error,
             });
-          } catch (err) {
+          } else {
             server._send(ws, {
               id,
-              type: "error",
-              code: "PERSONAL_DATA_HUB_STREAM_ERROR",
-              message: err?.message || String(err),
+              type: `${type}.response`,
+              result: out && out.result !== undefined ? out.result : out,
             });
           }
-        };
+        } catch (err) {
+          server._send(ws, {
+            id,
+            type: "error",
+            code: "PERSONAL_DATA_HUB_ERROR",
+            message: err?.message || String(err),
+          });
+        }
+        return;
       }
 
-      // Phase I — Hosted Session API (session-core, memory, beta, usage)
-      for (const sessionCoreType of Object.keys(SESSION_CORE_HANDLERS)) {
-        routes[sessionCoreType] = async () => {
-          try {
-            const result =
-              await SESSION_CORE_HANDLERS[sessionCoreType](message);
-            server._send(ws, {
-              id,
-              type: `${sessionCoreType}.response`,
-              ...result,
-            });
-          } catch (err) {
-            server._send(ws, {
-              id,
-              type: "error",
-              code: "SESSION_CORE_ERROR",
-              message: err?.message || String(err),
-            });
-          }
-        };
+      // Phase 5.7 — streaming sync routes. Adapter progress events are pushed
+      // as `<topic>.event` messages tagged with the request id; the final
+      // report comes as `<topic>.end`.
+      if (PERSONAL_DATA_HUB_STREAMING_HANDLERS[type]) {
+        const sender = (payload) => server._send(ws, { id, ...payload });
+        try {
+          const out = await PERSONAL_DATA_HUB_STREAMING_HANDLERS[type](
+            message,
+            sender,
+          );
+          server._send(ws, {
+            id,
+            type: `${type}.end`,
+            ...(out && out.result !== undefined
+              ? { result: out.result }
+              : out || {}),
+          });
+        } catch (err) {
+          server._send(ws, {
+            id,
+            type: "error",
+            code: "PERSONAL_DATA_HUB_STREAM_ERROR",
+            message: err?.message || String(err),
+          });
+        }
+        return;
       }
 
-      const handler = routes[type];
-      if (!handler) {
-        server._send(ws, {
-          id,
-          type: "error",
-          code: "UNKNOWN_TYPE",
-          message: `Unknown message type: ${type}`,
-        });
+      // Phase I — Hosted Session API (session-core, memory, beta, usage)
+      if (SESSION_CORE_HANDLERS[type]) {
+        try {
+          const result = await SESSION_CORE_HANDLERS[type](message);
+          server._send(ws, { id, type: `${type}.response`, ...result });
+        } catch (err) {
+          server._send(ws, {
+            id,
+            type: "error",
+            code: "SESSION_CORE_ERROR",
+            message: err?.message || String(err),
+          });
+        }
         return;
       }
 
-      return handler();
+      server._send(ws, {
+        id,
+        type: "error",
+        code: "UNKNOWN_TYPE",
+        message: `Unknown message type: ${type}`,
+      });
+      return;
     },
   };
 }

package/src/gateways/ws/ws-session-gateway.js

@@ -109,6 +109,47 @@ export class WSSessionManager {
     this.maxSessions = Number.isFinite(options.maxSessions)
       ? options.maxSessions
       : 100;
+
+    // Cap patch bookkeeping per session. `patchHistory` is append-only (every
+    // applyPatch/rejectPatch pushes, nothing trims) and `pendingPatches` grows
+    // with each proposePatch — both are serialized in full by
+    // _persistSessionState on every session op, so unbounded growth means
+    // O(n) memory AND an O(n²) rewrite cost over a long session (and a tool
+    // proposing many large before/after/diff blobs amplifies it). Keep a
+    // recent window; oldest entries fall off (FIFO).
+    this.maxPatchHistory = Number.isFinite(options.maxPatchHistory)
+      ? options.maxPatchHistory
+      : 200;
+    this.maxPendingPatches = Number.isFinite(options.maxPendingPatches)
+      ? options.maxPendingPatches
+      : 50;
+    // The entry-count caps above bound how MANY patches are kept, but a SINGLE
+    // proposed patch (a client-reachable `patch-propose`) could still carry an
+    // unbounded number of files, each with unbounded before/after/diff content
+    // — all held in memory AND serialized to disk by _persistSessionState. One
+    // file with a multi-GB diff string is enough to OOM. Bound a single patch's
+    // payload: cap the file count and truncate each content field.
+    this.maxPatchFiles = Number.isFinite(options.maxPatchFiles)
+      ? options.maxPatchFiles
+      : 200;
+    this.maxPatchContentChars = Number.isFinite(options.maxPatchContentChars)
+      ? options.maxPatchContentChars
+      : 512 * 1024; // 512 KB per before/after/diff field
+  }
+
+  /**
+   * Truncate a patch content field (before/after/diff) to maxPatchContentChars,
+   * appending a visible marker. Preserves the null-vs-string distinction (a null
+   * field stays null — it signals create/delete ops). Pure.
+   */
+  _capPatchContent(value) {
+    if (value == null) return null;
+    const s = String(value);
+    if (s.length <= this.maxPatchContentChars) return s;
+    return (
+      s.slice(0, this.maxPatchContentChars) +
+      `\n…[truncated for storage: field was ${s.length} chars]`
+    );
   }
 
   _normalizeEnabledToolNames(enabledToolNames) {
@@ -499,9 +540,7 @@ export class WSSessionManager {
         permanentMemory,
         reviewState: metadata.reviewState || null,
         pendingPatches: this._hydratePendingPatches(metadata.pendingPatches),
-        patchHistory: Array.isArray(metadata.patchHistory)
-          ? metadata.patchHistory
-          : [],
+        patchHistory: this._boundPatchHistory(metadata.patchHistory),
         taskGraph: this._hydrateTaskGraph(metadata.taskGraph),
         interaction: null,
         createdAt: dbSession.created_at,
@@ -842,8 +881,13 @@ export class WSSessionManager {
     const session = this.sessions.get(sessionId);
     if (!session) return null;
 
-    const files = Array.isArray(payload.files) ? payload.files : [];
-    if (files.length === 0) return null;
+    const rawFiles = Array.isArray(payload.files) ? payload.files : [];
+    if (rawFiles.length === 0) return null;
+    // Cap the per-patch file count; a proposal touching more than this is
+    // pathological for review. Excess files are dropped (count recorded below)
+    // so one message can't pin unbounded memory / disk.
+    const files = rawFiles.slice(0, this.maxPatchFiles);
+    const droppedFiles = rawFiles.length - files.length;
 
     const patchId = `patch-${this._generateId()}`;
     const now = new Date().toISOString();
@@ -854,9 +898,9 @@ export class WSSessionManager {
         index,
         path: file.path || `unknown-${index}`,
         op,
-        before: file.before == null ? null : String(file.before),
-        after: file.after == null ? null : String(file.after),
-        diff: file.diff == null ? null : String(file.diff),
+        before: this._capPatchContent(file.before),
+        after: this._capPatchContent(file.after),
+        diff: this._capPatchContent(file.diff),
         stats,
       };
     });
@@ -883,12 +927,23 @@ export class WSSessionManager {
         fileCount: normalizedFiles.length,
         added: totalStats.added,
         removed: totalStats.removed,
+        // Surfaced so the reviewer/UI knows the proposal was capped for storage.
+        ...(droppedFiles > 0 ? { droppedFiles } : {}),
       },
     };
 
     if (!(session.pendingPatches instanceof Map)) {
       session.pendingPatches = new Map();
     }
+    // Bound un-reviewed proposals: evict the oldest pending (Map preserves
+    // insertion order) once at cap. 50 unresolved patches is already
+    // pathological; dropping the stalest keeps memory + persisted state bounded
+    // without blocking a legitimate new proposal.
+    while (session.pendingPatches.size >= this.maxPendingPatches) {
+      const oldestKey = session.pendingPatches.keys().next().value;
+      if (oldestKey === undefined) break;
+      session.pendingPatches.delete(oldestKey);
+    }
     session.pendingPatches.set(patchId, patch);
     session.lastActivity = now;
     this._persistSessionState(sessionId);
@@ -917,11 +972,35 @@ export class WSSessionManager {
       session.patchHistory = [];
     }
     session.patchHistory.push(patch);
+    this._trimPatchHistory(session);
     session.lastActivity = patch.resolvedAt;
     this._persistSessionState(sessionId);
     return patch;
   }
 
+  /**
+   * Keep `patchHistory` bounded to the most recent maxPatchHistory entries.
+   * Oldest fall off the front (FIFO) so memory + persisted JSON stay bounded.
+   */
+  _trimPatchHistory(session) {
+    if (!Array.isArray(session.patchHistory)) return;
+    const overflow = session.patchHistory.length - this.maxPatchHistory;
+    if (overflow > 0) {
+      session.patchHistory.splice(0, overflow);
+    }
+  }
+
+  /**
+   * Bound a (possibly persisted/tampered) patchHistory array on load, keeping
+   * the most recent entries. Returns a fresh array (never the input).
+   */
+  _boundPatchHistory(list) {
+    if (!Array.isArray(list)) return [];
+    return list.length > this.maxPatchHistory
+      ? list.slice(list.length - this.maxPatchHistory)
+      : list.slice();
+  }
+
   /**
    * Discard a pending patch. Same bookkeeping as applyPatch but records a
    * "rejected" decision instead.
@@ -944,6 +1023,7 @@ export class WSSessionManager {
       session.patchHistory = [];
     }
     session.patchHistory.push(patch);
+    this._trimPatchHistory(session);
     session.lastActivity = patch.resolvedAt;
     this._persistSessionState(sessionId);
     return patch;
@@ -1339,7 +1419,13 @@ export class WSSessionManager {
   _hydratePendingPatches(list) {
     const map = new Map();
     if (Array.isArray(list)) {
-      for (const patch of list) {
+      // Trim from the front so the most recent proposals survive a reload even
+      // if a prior (or tampered) persisted state exceeded the cap.
+      const bounded =
+        list.length > this.maxPendingPatches
+          ? list.slice(list.length - this.maxPendingPatches)
+          : list;
+      for (const patch of bounded) {
         if (patch && patch.patchId) {
           map.set(patch.patchId, patch);
         }

package/src/harness/background-task-manager.js

@@ -194,7 +194,11 @@ export class BackgroundTaskManager extends EventEmitter {
       return history;
     }
 
-    const items = history.slice(offset, offset + limit);
+    // offset + null === offset, so an offset-only page (no limit) used to
+    // slice(offset, offset) === [] and lose every item past the offset. Use
+    // history.length as the end when limit is null.
+    const end = limit === null ? history.length : offset + limit;
+    const items = history.slice(offset, end);
     return {
       items,
       total: history.length,