teyyare 0.2.2 → 0.2.3

package/bin/teyyare.js

@@ -50,6 +50,11 @@ async function main() {
     process.exit(0);
   }
 
+  if (command === '--version' || command === '-v' || command === 'version') {
+    console.log('0.2.3');
+    process.exit(0);
+  }
+
   if (command === 'serve') {
     let port = 7421;
     let dir = process.cwd();
@@ -105,6 +110,7 @@ Backpressure:     ${snap.backpressureCount}
 Protocol overhead:${snap.protocolOverheadPercent.toFixed(2)}%
 Peak RSS:         ${(snap.peakRSS / (1024 * 1024)).toFixed(2)} MB
 `);
+    process.exit(0);
   } else if (command === 'pull') {
     const source = args[1];
     const target = args[2] || './';
@@ -135,8 +141,9 @@ Backpressure:     ${snap.backpressureCount}
 Protocol overhead:${snap.protocolOverheadPercent.toFixed(2)}%
 Peak RSS:         ${(snap.peakRSS / (1024 * 1024)).toFixed(2)} MB
 `);
+    process.exit(0);
   } else if (command === 'status') {
-    console.log('\x1b[1m\x1b[36mTeyyare\x1b[0m v0.2.2 status: ready');
+    console.log('\x1b[1m\x1b[36mTeyyare\x1b[0m v0.2.3 status: ready');
   } else {
     console.error(`Unknown command: ${command}`);
     printUsage();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teyyare",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "High-performance resumable file transfer engine and CLI built on muttafa and raptiye",
   "main": "src/index.js",
   "type": "module",

package/src/index.js

@@ -5,6 +5,7 @@
 import path from 'node:path';
 import { existsSync } from 'node:fs';
 import { TCPTransport, ReplicationPipeline } from 'raptiye';
+import { readHeader, decodeMessage, HEADER_SIZE } from 'raptiye/src/protocol/wire.js';
 import { SenderPipeline } from './sender/pipeline.js';
 import { ReceiverPipeline } from './receiver/pipeline.js';
 import { TransferManifest } from './manifest/manifest.js';
@@ -22,6 +23,116 @@ import {
   unpackPullError
 } from './core/protocol.js';
 
+// High-performance streaming TCP framer patch for TCPTransport
+// Eliminates O(N^2) Buffer.concat and ensures clean socket lifecycle management
+TCPTransport.prototype._attachSocketReader = function(socket) {
+  socket.setNoDelay(true);
+  const chunks = [];
+  let bufferedLength = 0;
+
+  socket.on('data', (chunk) => {
+    chunks.push(chunk);
+    bufferedLength += chunk.length;
+
+    while (bufferedLength >= HEADER_SIZE) {
+      let headerBuf = chunks[0];
+      if (headerBuf.length < HEADER_SIZE) {
+        const tempHeader = Buffer.allocUnsafe(HEADER_SIZE);
+        let off = 0;
+        for (let i = 0; off < HEADER_SIZE && i < chunks.length; i++) {
+          const c = chunks[i];
+          const toCopy = Math.min(c.length, HEADER_SIZE - off);
+          tempHeader.set(c.subarray(0, toCopy), off);
+          off += toCopy;
+        }
+        headerBuf = tempHeader;
+      }
+
+      let header;
+      try {
+        header = readHeader(headerBuf, 0);
+      } catch (err) {
+        socket.destroy(err);
+        return;
+      }
+
+      const totalLength = HEADER_SIZE + header.payloadLength;
+      if (bufferedLength < totalLength) {
+        break;
+      }
+
+      let rawFrame;
+      if (chunks[0].length >= totalLength) {
+        rawFrame = chunks[0].subarray(0, totalLength);
+        if (chunks[0].length === totalLength) {
+          chunks.shift();
+        } else {
+          chunks[0] = chunks[0].subarray(totalLength);
+        }
+        bufferedLength -= totalLength;
+      } else {
+        rawFrame = Buffer.allocUnsafe(totalLength);
+        let dstOff = 0;
+        let remaining = totalLength;
+        while (remaining > 0) {
+          const head = chunks[0];
+          if (head.length <= remaining) {
+            rawFrame.set(head, dstOff);
+            dstOff += head.length;
+            remaining -= head.length;
+            chunks.shift();
+          } else {
+            rawFrame.set(head.subarray(0, remaining), dstOff);
+            dstOff += remaining;
+            chunks[0] = head.subarray(remaining);
+            remaining = 0;
+          }
+        }
+        bufferedLength -= totalLength;
+      }
+
+      try {
+        const frame = new Uint8Array(rawFrame.buffer, rawFrame.byteOffset, rawFrame.byteLength);
+        const msg = decodeMessage(frame, 0, true);
+        if (msg.sourceNode) {
+          this._outboundSockets.set(msg.sourceNode, socket);
+        }
+        if (this._messageHandler) {
+          this._messageHandler(msg.sourceNode, msg);
+        }
+      } catch (err) {
+        console.error(`[TCPTransport ${this.id}] Error decoding frame:`, err.message);
+      }
+    }
+  });
+
+  socket.on('close', () => {
+    this._inboundSockets.delete(socket);
+    for (const [peer, s] of this._outboundSockets.entries()) {
+      if (s === socket) {
+        this._outboundSockets.delete(peer);
+      }
+    }
+  });
+
+  socket.on('error', () => {
+    socket.destroy();
+  });
+};
+
+// Reset stalled inflight receipts on connection drop or before starting new transfer
+ReplicationPipeline.prototype.reset = function(err = new Error('Replication pipeline reset')) {
+  for (const pending of this._pendingReceipts.values()) {
+    pending.reject(err);
+  }
+  this._pendingReceipts.clear();
+  this.inflightBatches = 0;
+  this.inflightBytes = 0;
+  this.stats.inflightBatches = 0;
+  this.stats.inflightBytes = 0;
+  this._notifyCapacity();
+};
+
 export {
   SenderPipeline,
   ReceiverPipeline,
@@ -108,6 +219,7 @@ export async function serve({
       }
 
       const manifest = await TransferManifest.build(resolved);
+      replication.reset();
       const sender = new SenderPipeline({
         replication,
         manifest,

package/src/sender/pipeline.js

@@ -102,10 +102,10 @@ export class SenderPipeline {
     this.replication = replication;
     this.manifest = manifest;
     this.chunkSize = options.chunkSize || 1024 * 1024;
-    this.maxEntries = options.maxEntries || 8;
-    this.maxBytes = options.maxBytes || 8 * 1024 * 1024;
+    this.maxEntries = options.maxEntries || 4;
+    this.maxBytes = options.maxBytes || 4 * 1024 * 1024;
     this.maxImmutableBuffers = options.maxImmutableBuffers || 8;
-    this.maxConcurrentFlushes = options.maxConcurrentFlushes || 4;
+    this.maxConcurrentFlushes = options.maxConcurrentFlushes || Math.min(this.maxImmutableBuffers, 4);
     this.metrics = metrics;
     this.progress = progress;
     this.knownResumeState = knownResumeState;