adhdev 0.9.55 → 0.9.56

package/dist/index.js

@@ -13748,6 +13748,12 @@ var init_provider_cli_adapter = __esm({
       accumulatedRawBuffer = "";
       /** Current visible terminal screen snapshot */
       terminalScreen = new TerminalScreen(24, 80);
+      static MAX_RESPONSE_BUFFER = 8e3;
+      static MAX_RECENT_OUTPUT_BUFFER = 1e3;
+      responseBufferDroppedChars = 0;
+      recentOutputDroppedChars = 0;
+      accumulatedBufferDroppedChars = 0;
+      accumulatedRawBufferDroppedChars = 0;
       /** Max accumulated buffer size. Sized to comfortably hold a single long
        *  Hermes turn (tool calls + reasoning + final bubble) without the
        *  rolling window pushing the turn's ╭─ opening line out of view. */
@@ -13765,6 +13771,23 @@ var init_provider_cli_adapter = __esm({
       providerResolutionMeta;
       static FINISH_RETRY_DELAY_MS = 300;
       static MAX_FINISH_RETRIES = 2;
+      getBufferState() {
+        const build = (droppedChars, maxChars) => droppedChars > 0 ? { truncated: true, droppedChars, maxChars } : void 0;
+        const responseBuffer = build(this.responseBufferDroppedChars, _ProviderCliAdapter.MAX_RESPONSE_BUFFER);
+        const recentOutputBuffer = build(this.recentOutputDroppedChars, _ProviderCliAdapter.MAX_RECENT_OUTPUT_BUFFER);
+        const accumulatedBuffer = build(this.accumulatedBufferDroppedChars, _ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
+        const accumulatedRawBuffer = build(this.accumulatedRawBufferDroppedChars, _ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
+        if (!responseBuffer && !recentOutputBuffer && !accumulatedBuffer && !accumulatedRawBuffer) return void 0;
+        return {
+          ...responseBuffer ? { responseBuffer } : {},
+          ...recentOutputBuffer ? { recentOutputBuffer } : {},
+          ...accumulatedBuffer ? { accumulatedBuffer } : {},
+          ...accumulatedRawBuffer ? { accumulatedRawBuffer } : {}
+        };
+      }
+      recordBoundedAppendDrop(previousLength, appendedLength, nextLength) {
+        return Math.max(0, previousLength + appendedLength - nextLength);
+      }
       buildCommittedMessagesActivitySignature() {
         const last = this.committedMessages[this.committedMessages.length - 1];
         return [
@@ -14130,7 +14153,9 @@ var init_provider_cli_adapter = __esm({
           this.scheduleStartupSettleCheck();
         }
         if (this.isWaitingForResponse && cleanData) {
-          this.responseBuffer = appendBoundedText(this.responseBuffer, cleanData, 8e3);
+          const previousResponseLen = this.responseBuffer.length;
+          this.responseBuffer = appendBoundedText(this.responseBuffer, cleanData, _ProviderCliAdapter.MAX_RESPONSE_BUFFER);
+          this.responseBufferDroppedChars += this.recordBoundedAppendDrop(previousResponseLen, cleanData.length, this.responseBuffer.length);
         }
         if (cleanData.trim()) {
           if (this.serverConn) {
@@ -14139,14 +14164,19 @@ var init_provider_cli_adapter = __esm({
             this.logBuffer.push({ message: cleanData.trim(), level: "info" });
           }
         }
+        const prevRecentLen = this.recentOutputBuffer.length;
         const prevAccumulatedLen = this.accumulatedBuffer.length;
         const prevAccumulatedRawLen = this.accumulatedRawBuffer.length;
-        this.recentOutputBuffer = appendBoundedText(this.recentOutputBuffer, cleanData, 1e3);
+        this.recentOutputBuffer = appendBoundedText(this.recentOutputBuffer, cleanData, _ProviderCliAdapter.MAX_RECENT_OUTPUT_BUFFER);
         this.accumulatedBuffer = appendBoundedText(this.accumulatedBuffer, cleanData, _ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
         this.accumulatedRawBuffer = appendBoundedText(this.accumulatedRawBuffer, rawData, _ProviderCliAdapter.MAX_ACCUMULATED_BUFFER);
+        const droppedRecent = this.recordBoundedAppendDrop(prevRecentLen, cleanData.length, this.recentOutputBuffer.length);
+        const droppedClean = this.recordBoundedAppendDrop(prevAccumulatedLen, cleanData.length, this.accumulatedBuffer.length);
+        const droppedRaw = this.recordBoundedAppendDrop(prevAccumulatedRawLen, rawData.length, this.accumulatedRawBuffer.length);
+        this.recentOutputDroppedChars += droppedRecent;
+        this.accumulatedBufferDroppedChars += droppedClean;
+        this.accumulatedRawBufferDroppedChars += droppedRaw;
         if (this.currentTurnScope) {
-          const droppedClean = prevAccumulatedLen + cleanData.length - this.accumulatedBuffer.length;
-          const droppedRaw = prevAccumulatedRawLen + rawData.length - this.accumulatedRawBuffer.length;
           if (droppedClean > 0) {
             this.currentTurnScope.bufferStart = Math.max(0, this.currentTurnScope.bufferStart - droppedClean);
           }
@@ -14976,13 +15006,15 @@ var init_provider_cli_adapter = __esm({
             effectiveModal = parsedModal;
           }
         }
+        const bufferState = this.getBufferState();
         return {
           status: effectiveStatus,
           messages: [...this.committedMessages],
           workingDir: this.workingDir,
           activeModal: effectiveModal,
           errorMessage: this.parseErrorMessage || void 0,
-          errorReason: this.parseErrorMessage ? "parse_error" : void 0
+          errorReason: this.parseErrorMessage ? "parse_error" : void 0,
+          ...bufferState ? { bufferState } : {}
         };
       }
       seedCommittedMessages(messages) {
@@ -15164,10 +15196,12 @@ var init_provider_cli_adapter = __esm({
             messages: hydratedMessages,
             activeModal: parsed.activeModal ?? this.activeModal,
             providerSessionId: typeof parsed.providerSessionId === "string" ? parsed.providerSessionId : void 0,
+            ...this.getBufferState() ? { bufferState: this.getBufferState() } : {},
             ...this.providerOwnsTranscript() ? { transcriptAuthority: "provider", coverage: this.shouldUseFullProviderTranscriptContext() ? "full" : "tail" } : {}
           };
         } else {
           const messages = [...this.committedMessages];
+          const bufferState = this.getBufferState();
           result = {
             id: "cli_session",
             status: this.currentStatus,
@@ -15178,7 +15212,8 @@ var init_provider_cli_adapter = __esm({
               index: typeof message.index === "number" ? message.index : index,
               receivedAt: typeof message.receivedAt === "number" ? message.receivedAt : message.timestamp
             })),
-            activeModal: this.activeModal
+            activeModal: this.activeModal,
+            ...bufferState ? { bufferState } : {}
           };
         }
         const hasVisibleAssistantMessage = Array.isArray(result?.messages) && result.messages.some((message) => message?.role === "assistant" && typeof message?.content === "string" && message.content.trim());
@@ -49617,7 +49652,7 @@ function sendToPeer(peer, data) {
     return false;
   }
   const json2 = JSON.stringify(data);
-  if (messageType === "command_result" && json2.length > MAX_INLINE_JSON_MESSAGE_CHARS) {
+  if (messageType === "command_result" && Buffer.byteLength(json2, "utf8") > MAX_INLINE_JSON_MESSAGE_CHARS) {
     return sendChunkedCommandResult(peer, peerId, requestId, json2);
   }
   try {
@@ -49630,21 +49665,51 @@ function sendToPeer(peer, data) {
     return false;
   }
 }
+function buildCommandResultChunkEnvelope(requestId, chunkId, index, total, data) {
+  return JSON.stringify({
+    type: "command_result_chunk",
+    id: requestId,
+    chunkId,
+    index,
+    total,
+    data
+  });
+}
+function splitJsonIntoCommandResultChunks(json2, requestId, chunkId) {
+  const chunks = [];
+  let offset = 0;
+  while (offset < json2.length) {
+    let end = Math.min(json2.length, offset + JSON_CHUNK_PAYLOAD_CHARS);
+    while (end > offset) {
+      const candidate = json2.slice(offset, end);
+      const envelope = buildCommandResultChunkEnvelope(requestId, chunkId, chunks.length, MAX_JSON_CHUNKS, candidate);
+      if (Buffer.byteLength(envelope, "utf8") <= MAX_INLINE_JSON_MESSAGE_BYTES) break;
+      end = offset + Math.max(1, Math.floor((end - offset) * 0.8));
+    }
+    chunks.push(json2.slice(offset, end));
+    if (chunks.length > MAX_JSON_CHUNKS) return [];
+    offset = end;
+  }
+  return chunks;
+}
 function sendChunkedCommandResult(peer, peerId, requestId, json2) {
   const chunkId = requestId || `command_result_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-  const total = Math.ceil(json2.length / JSON_CHUNK_PAYLOAD_CHARS);
+  const chunks = splitJsonIntoCommandResultChunks(json2, requestId, chunkId);
+  const total = chunks.length;
+  if (total === 0 || total > MAX_JSON_CHUNKS) {
+    log(`command_result send failed: peer=${peerId} id=${requestId || "-"} reason=too_many_chunks chunks=${total || "unknown"}`);
+    return false;
+  }
   logDebug(`command_result chunked: peer=${peerId} id=${requestId || "-"} chars=${json2.length} chunks=${total}`);
   for (let index = 0; index < total; index += 1) {
-    const chunk = json2.slice(index * JSON_CHUNK_PAYLOAD_CHARS, (index + 1) * JSON_CHUNK_PAYLOAD_CHARS);
+    const chunk = chunks[index] || "";
     try {
-      peer.dataChannel?.sendMessage(JSON.stringify({
-        type: "command_result_chunk",
-        id: requestId,
-        chunkId,
-        index,
-        total,
-        data: chunk
-      }));
+      const envelope = buildCommandResultChunkEnvelope(requestId, chunkId, index, total, chunk);
+      if (Buffer.byteLength(envelope, "utf8") > MAX_INLINE_JSON_MESSAGE_BYTES) {
+        log(`command_result send failed: peer=${peerId} id=${requestId || "-"} chunk=${index + 1}/${total} reason=chunk_too_large`);
+        return false;
+      }
+      peer.dataChannel?.sendMessage(envelope);
     } catch (error48) {
       log(`command_result send failed: peer=${peerId} id=${requestId || "-"} chunk=${index + 1}/${total} error=${error48?.message || error48}`);
       return false;
@@ -49652,10 +49717,58 @@ function sendChunkedCommandResult(peer, peerId, requestId, json2) {
   }
   return true;
 }
+function parseChunkedJsonMessage(peerId, parsed) {
+  const chunkType = typeof parsed?.type === "string" ? parsed.type : "";
+  if (!chunkType.endsWith("_chunk")) return parsed;
+  const chunkId = typeof parsed?.chunkId === "string" ? parsed.chunkId : "";
+  const id = typeof parsed?.id === "string" ? parsed.id : "";
+  const index = Number(parsed?.index);
+  const total = Number(parsed?.total);
+  const data = typeof parsed?.data === "string" ? parsed.data : "";
+  if (!chunkId || !Number.isInteger(index) || !Number.isInteger(total) || index < 0 || total <= 0 || total > MAX_JSON_CHUNKS || index >= total || !data) {
+    log(`chunked JSON ignored: peer=${peerId} type=${chunkType || "unknown"} reason=malformed`);
+    return null;
+  }
+  const now = Date.now();
+  incomingJsonChunks.forEach((entry2, key2) => {
+    if (now - entry2.createdAt > JSON_CHUNK_TTL_MS) incomingJsonChunks.delete(key2);
+  });
+  const key = `${peerId}:${chunkId}`;
+  let entry = incomingJsonChunks.get(key);
+  if (!entry || entry.total !== total || entry.type !== chunkType) {
+    entry = { total, chunks: new Array(total).fill(""), received: 0, createdAt: now, type: chunkType, id };
+    incomingJsonChunks.set(key, entry);
+  }
+  if (!entry.chunks[index]) {
+    entry.chunks[index] = data;
+    entry.received += 1;
+  }
+  if (entry.received < entry.total) return null;
+  incomingJsonChunks.delete(key);
+  try {
+    return JSON.parse(entry.chunks.join(""));
+  } catch (error48) {
+    log(`chunked JSON parse failed: peer=${peerId} type=${chunkType} id=${entry.id || "-"} error=${error48?.message || error48}`);
+    return CHUNK_PARSE_FAILED;
+  }
+}
 function routeDataChannelMessage(peerId, msg, peers, handlers) {
   const text = typeof msg === "string" ? msg : msg.toString("utf-8");
   try {
-    const parsed = JSON.parse(text);
+    let parsed = JSON.parse(text);
+    const chunked = parseChunkedJsonMessage(peerId, parsed);
+    if (chunked === null) return;
+    if (chunked === CHUNK_PARSE_FAILED) {
+      const peer = peers.get(peerId);
+      const id = typeof parsed?.id === "string" ? parsed.id : "";
+      if (parsed?.type === "command_chunk") {
+        sendToPeer(peer, { type: "command_result", id, success: false, error: "Failed to reassemble chunked command" });
+      } else if (id) {
+        sendToPeer(peer, { id, type: "response", success: false, error: "Failed to reassemble chunked request" });
+      }
+      return;
+    }
+    parsed = chunked;
     if (parsed.type !== "command" && parsed.type !== "pty_input" && parsed.type !== "pty_resize" && parsed.type !== "ping" && parsed.type !== "pong") {
       logDebug(`Files message from peer ${peerId}: type=${parsed.type}`);
     }
@@ -49951,7 +50064,7 @@ async function handleFileRequest(peerId, req, peers, handlers) {
   }
   sendToPeer(peer, response);
 }
-var MAX_INLINE_JSON_MESSAGE_CHARS, JSON_CHUNK_PAYLOAD_CHARS;
+var MAX_INLINE_JSON_MESSAGE_CHARS, MAX_INLINE_JSON_MESSAGE_BYTES, JSON_CHUNK_PAYLOAD_CHARS, JSON_CHUNK_TTL_MS, MAX_JSON_CHUNKS, CHUNK_PARSE_FAILED, incomingJsonChunks;
 var init_data_channel_router = __esm({
   "src/daemon-p2p/data-channel-router.ts"() {
     "use strict";
@@ -49959,18 +50072,23 @@ var init_data_channel_router = __esm({
     init_permission();
     init_log();
     MAX_INLINE_JSON_MESSAGE_CHARS = 6e4;
-    JSON_CHUNK_PAYLOAD_CHARS = 32e3;
+    MAX_INLINE_JSON_MESSAGE_BYTES = 6e4;
+    JSON_CHUNK_PAYLOAD_CHARS = 16e3;
+    JSON_CHUNK_TTL_MS = 6e4;
+    MAX_JSON_CHUNKS = 1024;
+    CHUNK_PARSE_FAILED = /* @__PURE__ */ Symbol("chunk_parse_failed");
+    incomingJsonChunks = /* @__PURE__ */ new Map();
   }
 });
 
 // src/daemon-p2p/screenshot-sender.ts
-var CHUNK_SIZE, MAX_INLINE_JSON_MESSAGE_BYTES, JSON_CHUNK_PAYLOAD_CHARS2, ScreenshotSender;
+var CHUNK_SIZE, MAX_INLINE_JSON_MESSAGE_BYTES2, JSON_CHUNK_PAYLOAD_CHARS2, ScreenshotSender;
 var init_screenshot_sender = __esm({
   "src/daemon-p2p/screenshot-sender.ts"() {
     "use strict";
     init_log();
     CHUNK_SIZE = 6e4;
-    MAX_INLINE_JSON_MESSAGE_BYTES = 6e4;
+    MAX_INLINE_JSON_MESSAGE_BYTES2 = 6e4;
     JSON_CHUNK_PAYLOAD_CHARS2 = 16e3;
     ScreenshotSender = class {
       _ssDebugDone = false;
@@ -50014,7 +50132,7 @@ var init_screenshot_sender = __esm({
           type: "topic_update",
           update
         });
-        if (Buffer.byteLength(json2, "utf8") > MAX_INLINE_JSON_MESSAGE_BYTES) {
+        if (Buffer.byteLength(json2, "utf8") > MAX_INLINE_JSON_MESSAGE_BYTES2) {
           return this.sendChunkedTopicUpdate(peer, update, json2);
         }
         try {
@@ -50053,6 +50171,10 @@ var init_screenshot_sender = __esm({
         let sentAny = false;
         for (const peer of peers.values()) {
           if (peer.state !== "connected" || !peer.dataChannel?.isOpen()) continue;
+          if (Buffer.byteLength(msg, "utf8") > MAX_INLINE_JSON_MESSAGE_BYTES2) {
+            if (this.sendChunkedSessionOutput(peer, sessionId, msg)) sentAny = true;
+            continue;
+          }
           try {
             peer.dataChannel.sendMessage(msg);
             sentAny = true;
@@ -50061,6 +50183,27 @@ var init_screenshot_sender = __esm({
         }
         return sentAny;
       }
+      sendChunkedSessionOutput(peer, sessionId, json2) {
+        const chunkId = `session_output:${sessionId}:${Date.now()}:${Math.random().toString(36).slice(2, 8)}`;
+        const total = Math.ceil(json2.length / JSON_CHUNK_PAYLOAD_CHARS2);
+        logDebug(`session_output chunked: peer=${peer.peerId || "unknown"} sessionId=${sessionId || "-"} chars=${json2.length} chunks=${total}`);
+        for (let index = 0; index < total; index += 1) {
+          const chunk = json2.slice(index * JSON_CHUNK_PAYLOAD_CHARS2, (index + 1) * JSON_CHUNK_PAYLOAD_CHARS2);
+          try {
+            peer.dataChannel?.sendMessage(JSON.stringify({
+              type: "session_output_chunk",
+              sessionId,
+              chunkId,
+              index,
+              total,
+              data: chunk
+            }));
+          } catch {
+            return false;
+          }
+        }
+        return true;
+      }
       sendScreenshot(peers, base64Data, targetSessionId) {
         const buffer = Buffer.from(base64Data, "base64");
         return this.sendScreenshotBuffer(peers, buffer, targetSessionId);
@@ -58894,7 +59037,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.55" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.56" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;