peer-term 1.2.9 → 1.2.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peer-term",
-  "version": "1.2.9",
+  "version": "1.2.11",
   "license": "MIT",
   "description": "Share your terminal instantly using a 6-digit code. Encrypted. No config.",
   "keywords": [

package/src/index.js

@@ -326,6 +326,7 @@ class Session {
     this.awaitingRejoin = false;
     this.destroyed = false;
     this.intentionalClose = false;
+    this.ptyOutputQueue = Promise.resolve();
     this.reconnectTimer = null;
     this.createdAt = Date.now();
     this.relayUrl = null;  // Track which relay URL we connected to
@@ -647,13 +648,10 @@ class Session {
     try {
       const resizeJson = JSON.stringify({ type: 'resize', cols, rows });
       const payload = await encrypt(this.sharedKey, resizeJson);
-      // Phase 4: Route through DataChannel if active, else relay
-      if (this.useDataChannel && this.webrtc && this.webrtc.isActive()) {
-        // Send resize as a tagged message so client can distinguish
-        this.webrtc.send(JSON.stringify({ _meta: 'resize', payload }));
-      } else if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-        this.ws.send(JSON.stringify({ type: 'data', payload, meta: 'resize' }));
-      }
+      this._sendEncryptedToClient(payload, {
+        directPayload: JSON.stringify({ _meta: 'resize', payload }),
+        meta: 'resize',
+      });
     } catch {}
   }
 
@@ -708,25 +706,14 @@ class Session {
       env: process.env,
     });
 
-    this.ptyProcess.onData(async (data) => {
+    this.ptyProcess.onData((data) => {
       // Mirror PTY output to local viewer terminal
       if (this.viewerSocket) {
         try { this.viewerSocket.write(data); } catch {}
       }
 
       if (!this.sharedKey) return;
-      try {
-        const payload = await encrypt(this.sharedKey, data);
-        // Phase 4: Route through DataChannel if active, else relay
-        if (this.useDataChannel && this.webrtc && this.webrtc.isActive()) {
-          this.webrtc.send(payload);
-        } else if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-          // Backpressure: drop chunk if relay can't keep up (1.25 MB buffer limit)
-          if (this.ws.bufferedAmount < 1.25 * 1024 * 1024) {
-            this.ws.send(JSON.stringify({ type: 'data', payload }));
-          }
-        }
-      } catch {}
+      this._queuePtyOutput(data, this.sharedKey);
     });
 
     this.ptyProcess.onExit(({ exitCode }) => {
@@ -742,6 +729,58 @@ class Session {
   }
 
   // ─── Local TCP viewer for host terminal ─────────────────────────────
+  _queuePtyOutput(data, sharedKey) {
+    this.ptyOutputQueue = this.ptyOutputQueue
+      .then(() => this._sendPtyOutput(data, sharedKey))
+      .catch((err) => {
+        this.logDebug(`Failed to send PTY output: ${err.message}`);
+      });
+  }
+
+  async _sendPtyOutput(data, sharedKey) {
+    if (this.destroyed || !sharedKey || sharedKey !== this.sharedKey) return;
+
+    const payload = await encrypt(sharedKey, data);
+    if (this.destroyed || sharedKey !== this.sharedKey) return;
+
+    this._sendEncryptedToClient(payload, { enforceBackpressure: true });
+  }
+
+  _sendEncryptedToClient(payload, options = {}) {
+    const directPayload = options.directPayload || payload;
+
+    if (this.useDataChannel) {
+      if (this.webrtc && this.webrtc.isActive()) {
+        let sentDirect = false;
+        try {
+          sentDirect = this.webrtc.send(directPayload);
+        } catch {}
+
+        if (sentDirect) return true;
+      }
+
+      this.useDataChannel = false;
+      this.log('DataChannel send failed — falling back to relay');
+    }
+
+    return this._sendViaRelay(payload, options);
+  }
+
+  _sendViaRelay(payload, { meta, enforceBackpressure = false } = {}) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return false;
+    if (enforceBackpressure && this.ws.bufferedAmount >= 1.25 * 1024 * 1024) return false;
+
+    const msg = { type: 'data', payload };
+    if (meta) msg.meta = meta;
+
+    try {
+      this.ws.send(JSON.stringify(msg));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
   _startViewerServer() {
     this.viewerServer = net.createServer((socket) => {
       // Close any existing viewer connection before accepting a new one