peer-term 1.2.14 → 1.3.0

package/package.json

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

package/src/index.js

@@ -336,6 +336,10 @@ class Session {
     this.webrtc = null;
     this.useDataChannel = false;
 
+    // File upload: in-progress file transfers from client
+    // Shape: { [id]: { name, size, totalChunks, chunks: Map<index, Buffer> } }
+    this._incomingFiles = {};
+
     // Local TCP viewer (new terminal window)
     this.viewerServer = null;
     this.viewerSocket = null;
@@ -820,6 +824,129 @@ class Session {
     }
   }
 
+  // ─── File Upload Handling ─────────────────────────────────────────────
+
+  /**
+   * Route file transfer messages (file-start, file-chunk, file-end).
+   * All file messages arrive over the DataChannel only.
+   */
+  _handleFileMessage(msg) {
+    switch (msg.type) {
+      case 'file-start': {
+        // Validate required fields
+        if (!msg.id || !msg.name || !msg.size || !msg.totalChunks) {
+          this._sendFileError(msg.id, 'Invalid file-start message');
+          return;
+        }
+        this.log(`File upload started: "${msg.name}" (${msg.size} bytes, ${msg.totalChunks} chunks)`);
+        this._incomingFiles[msg.id] = {
+          name: msg.name,
+          size: msg.size,
+          totalChunks: msg.totalChunks,
+          chunks: new Map(),
+        };
+        break;
+      }
+      case 'file-chunk': {
+        const transfer = this._incomingFiles[msg.id];
+        if (!transfer) {
+          this._sendFileError(msg.id, 'Unknown transfer ID');
+          return;
+        }
+        // data is base64-encoded raw bytes
+        transfer.chunks.set(msg.index, Buffer.from(msg.data, 'base64'));
+        this.logDebug(`File chunk ${msg.index + 1}/${transfer.totalChunks} received for "${transfer.name}"`);
+        break;
+      }
+      case 'file-end': {
+        this._finalizeFile(msg.id);
+        break;
+      }
+    }
+  }
+
+  /**
+   * Reassemble all chunks in order and write the completed file to disk.
+   * Saves to ~/peerterm-uploads/<filename>.
+   */
+  async _finalizeFile(id) {
+    const transfer = this._incomingFiles[id];
+    if (!transfer) {
+      this._sendFileError(id, 'Unknown transfer ID');
+      return;
+    }
+
+    // Check all chunks are present
+    for (let i = 0; i < transfer.totalChunks; i++) {
+      if (!transfer.chunks.has(i)) {
+        this.log(`File "${transfer.name}" missing chunk ${i}`);
+        this._sendFileError(id, `Missing chunk ${i}`);
+        delete this._incomingFiles[id];
+        return;
+      }
+    }
+
+    // Reassemble in order using Buffer.concat
+    const ordered = [];
+    for (let i = 0; i < transfer.totalChunks; i++) {
+      ordered.push(transfer.chunks.get(i));
+    }
+    const fileData = Buffer.concat(ordered);
+
+    // Determine save path: ~/peerterm-uploads/<filename>
+    const homeDir = os.homedir();
+    const uploadDir = path.join(homeDir, 'peerterm-uploads');
+    const savePath = path.join(uploadDir, transfer.name);
+
+    try {
+      await fs.promises.mkdir(uploadDir, { recursive: true });
+      await fs.promises.writeFile(savePath, fileData);
+
+      this.log(`File saved: ${savePath}`);
+
+      // Write green ANSI message into the PTY to show the save path
+      if (this.ptyProcess) {
+        this.ptyProcess.write(`\r\n\x1b[32m[PeerTerm] File saved: ${savePath}\x1b[0m\r\n`);
+      }
+
+      // Send ack to client
+      this._sendFileAck(id, transfer.name);
+    } catch (err) {
+      this.log(`Failed to save file "${transfer.name}": ${err.message}`);
+      this._sendFileError(id, `Save failed: ${err.message}`);
+    }
+
+    delete this._incomingFiles[id];
+  }
+
+  /**
+   * Send file-ack to the client confirming successful file save.
+   */
+  async _sendFileAck(id, name) {
+    if (!this.sharedKey) return;
+    try {
+      const ackJson = JSON.stringify({ type: 'file-ack', id, name });
+      const payload = await encrypt(this.sharedKey, ackJson);
+      this._sendEncryptedToClient(payload);
+    } catch (err) {
+      this.log(`Failed to send file-ack: ${err.message}`);
+    }
+  }
+
+  /**
+   * Send file-error to the client with an error message.
+   */
+  async _sendFileError(id, msg) {
+    if (!this.sharedKey) return;
+    try {
+      const errJson = JSON.stringify({ type: 'file-error', id, msg });
+      const payload = await encrypt(this.sharedKey, errJson);
+      this._sendEncryptedToClient(payload);
+    } catch (err) {
+      this.log(`Failed to send file-error: ${err.message}`);
+    }
+  }
+
   _startViewerServer() {
     // Generate a random nonce for viewer authentication
     this.viewerToken = crypto.randomBytes(16).toString('hex');
@@ -1221,6 +1348,8 @@ class Session {
     this.intentionalClose = true;
     this.stopHeartbeat();
     this._stopReconnecting();
+    // Clean up in-progress file uploads
+    this._incomingFiles = {};
     // Clean up viewer
     if (this.viewerSocket) {
       try { this.viewerSocket.destroy(); } catch {}
@@ -1267,7 +1396,7 @@ class Session {
     });
 
     this.webrtc.onMessage(async (data) => {
-      if (!this.sharedKey || !this.ptyProcess) return;
+      if (!this.sharedKey) return;
       try {
         // Check if this is a tagged message (resize)
         let parsed;
@@ -1286,8 +1415,22 @@ class Session {
           return;
         }
 
-        // Normal encrypted terminal data
+        // Normal encrypted data — decrypt first
         const plaintext = await decrypt(this.sharedKey, data);
+
+        // Check if decrypted message is a file transfer message (file-start, file-chunk, file-end)
+        try {
+          const msg = JSON.parse(plaintext);
+          if (msg && typeof msg.type === 'string' && msg.type.startsWith('file-')) {
+            this._handleFileMessage(msg);
+            return;
+          }
+        } catch {
+          // Not JSON — normal keystroke data, fall through
+        }
+
+        // Normal keystroke — drop if read-only or no PTY
+        if (!this.ptyProcess) return;
         if (this.readOnly) return;
         this.ptyProcess.write(plaintext);
       } catch (err) {