@rahularya01/pi-cursor 1.4.15 → 1.4.17

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [1.4.17] - 2026-08-16
+
+### Fixed
+
+- **A corrupted/misaligned incoming Connect frame (`Connect message exceeds 67108864 bytes`) no longer fails the turn outright.** This case bypassed the existing transport-loss retry machinery used for every other bridge failure (GOAWAY, connection reset, auth, ...). It's now treated the same way: the bridge is killed and, since the desync is local per-connection state rather than a permanent condition, the turn resumes over a fresh connection via checkpoint/history recovery when possible, falling back to the same error as before only when a retry isn't safe or attempts are exhausted.
+- Added a randomized differential test for the Connect frame reassembly logic (chunk-boundary fragmentation, large frames split across many tiny reads), which also caught and fixed a correctness bug in the chunk accumulator introduced in 1.4.16 — verified byte-for-byte against a reference implementation across many trials.
+
+## [1.4.16] - 2026-08-16
+
+### Performance
+
+- **Eliminated O(n²) frame reassembly on the streaming hot path.** The bridge's stdout reader, the Connect frame parser, and `h2-bridge.mjs`'s stdin reader all re-concatenated the entire buffered backlog on every incoming chunk, which is quadratic in a frame's total size once it arrives split across many small reads (large tool results, images, checkpoints). Replaced with a chunk-array accumulator that only merges what's needed to make progress — up to ~690x faster reassembling a large frame from small chunks in benchmarks.
+- **Cached checkpoint history fingerprinting.** `fingerprintCompletedTurns()` re-serialized and hashed the full completed-turn history from scratch on every call, even though it runs multiple times per turn over overlapping turn arrays. Added a per-turn cache keyed by turn-object identity.
+- **Memoized MCP tool schema slimming.** `buildMcpToolDefinitions()` and the derived MCP tool-name list re-slimmed and re-encoded every tool's schema on every call, even when the underlying tool set was unchanged from the previous turn. Both are now cached by array identity.
+
 ## [1.4.15] - 2026-08-15
 
 ### Documentation

package/dist/h2-bridge.mjs

@@ -48,14 +48,21 @@ function connectEndStreamError(code, message) {
 }
 
 // --- Buffered stdin reader ---
+//
+// Chunks are queued in an array and only concatenated once enough bytes have arrived to satisfy
+// a `readExact` call. Concatenating on every `data` event instead (`stdinBuf = Buffer.concat([
+// stdinBuf, chunk])`) is O(n^2) in the message size when a large message arrives split across
+// many small pipe reads, since every partial chunk re-copies everything buffered so far.
 
-let stdinBuf = Buffer.alloc(0);
+let stdinChunks = [];
+let stdinLength = 0;
 let stdinResolve = null;
 let stdinEnded = false;
 
 process.stdin.on("data", (chunk) => {
-  stdinBuf = Buffer.concat([stdinBuf, chunk]);
-  if (stdinBuf.length > MAX_BRIDGE_MESSAGE_BYTES + 4) {
+  stdinChunks.push(chunk);
+  stdinLength += chunk.length;
+  if (stdinLength > MAX_BRIDGE_MESSAGE_BYTES + 4) {
     process.stderr.write("[h2-bridge] stdin buffer limit exceeded\n");
     process.exit(1);
   }
@@ -82,12 +89,16 @@ function waitForData() {
 }
 
 async function readExact(n) {
-  while (stdinBuf.length < n) {
+  while (stdinLength < n) {
     if (stdinEnded) return null;
     await waitForData();
   }
-  const result = stdinBuf.subarray(0, n);
-  stdinBuf = stdinBuf.subarray(n);
+  if (stdinChunks.length > 1) stdinChunks = [Buffer.concat(stdinChunks, stdinLength)];
+  const buf = stdinChunks[0] ?? Buffer.alloc(0);
+  const result = buf.subarray(0, n);
+  const rest = buf.subarray(n);
+  stdinChunks = rest.length > 0 ? [rest] : [];
+  stdinLength = rest.length;
   return Buffer.from(result);
 }