peer-term 1.3.10 → 1.4.1

package/bin/peer-term.js

@@ -47,7 +47,7 @@ process.on('unhandledRejection', (reason) => {
 
 // ─── Launch Main ─────────────────────────────────────────────────────────────
 
-import('../src/index.js').catch((err) => {
+import('../src/cli.js').catch((err) => {
   logFatalError('Failed to start PeerTerm', err);
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peer-term",
-  "version": "1.3.10",
+  "version": "1.4.1",
   "license": "MIT",
   "description": "Share your terminal instantly using a 6-digit code. Encrypted. No config.",
   "repository": {
@@ -87,6 +87,7 @@
     "minimist": "^1.2.8",
     "node-datachannel": "^0.32.3",
     "node-pty": "^1.0.0",
+    "qrcode-terminal": "^0.12.0",
     "ws": "^8.18.0"
   }
 }

package/src/cli.js

@@ -0,0 +1,128 @@
+/**
+ * PeerTerm CLI — Interactive session manager
+ *
+ * Top-level orchestration:
+ *   1. Detects shell, resolves start path, runs interactive prompts
+ *   2. Creates a SessionManager and starts the first session
+ *   3. Provides a readline-based menu (n/l/k/a/q) for managing sessions
+ *   4. Handles SIGINT and global error handlers
+ */
+
+import readline from 'readline';
+import logger from './logger.js';
+import { printBanner } from './ui.js';
+import { argv, RELAY_URLS } from './config.js';
+import { formatDuration, detectShell, resolveStartPath } from './utils.js';
+import { getExpiryInteractive, getRejoinInteractive } from './prompts.js';
+import { SessionManager } from './index.js';
+
+// ─── Main ────────────────────────────────────────────────────────────────────
+
+async function main() {
+  const shell = detectShell();
+  const readOnly = argv.readonly;
+  const startPath = resolveStartPath(argv.path);
+
+  // Print startup banner
+  printBanner();
+
+  // Interactive prompts — always ask unless flags are passed or non-interactive
+  const expiryMs = await getExpiryInteractive();
+  const rejoinMs = await getRejoinInteractive();
+  console.log('');
+
+  logger.info(`Shell:          ${shell}`);
+  logger.info(`Relays:         ${RELAY_URLS.join(', ')}`);
+  logger.info(`Path:           ${startPath}`);
+  logger.info(`Expiry:         ${formatDuration(expiryMs)}`);
+  logger.info(`Rejoin Window:  ${formatDuration(rejoinMs)}`);
+  if (readOnly) logger.info('Mode:           READ-ONLY');
+  if (argv.verbose) logger.info('Verbose logging enabled');
+  console.log('');
+
+  const manager = new SessionManager(shell, expiryMs, rejoinMs, readOnly, startPath);
+
+  // Create first session automatically
+  const firstCode = await manager.createSession();
+  if (!firstCode) {
+    logger.error('Failed to start. Is the relay server running?');
+    process.exit(1);
+  }
+
+  // ─── Interactive CLI menu ──────────────────────────────────────────
+  console.log('  ─────────────────────────────────────────');
+  console.log('  Commands:');
+  console.log('    [n] New session');
+  console.log('    [l] List sessions');
+  console.log('    [a <code>] Authorize verified fingerprint');
+  console.log('    [k <code>] Kill session');
+  console.log('    [q] Quit all');
+  console.log('  ─────────────────────────────────────────');
+  console.log('');
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: '  > ',
+  });
+
+  rl.prompt();
+
+  rl.on('line', async (line) => {
+    const input = line.trim();
+
+    if (input === 'n') {
+      logger.info('Creating new session...');
+      await manager.createSession();
+    } else if (input === 'l') {
+      manager.listSessions();
+    } else if (input.startsWith('a ')) {
+      const code = input.slice(2).trim();
+      await manager.authorizeSession(code);
+    } else if (input.startsWith('k ')) {
+      const code = input.slice(2).trim();
+      manager.killSession(code);
+    } else if (input === 'q') {
+      logger.info('Shutting down all sessions...');
+      manager.killAll();
+      rl.close();
+      process.exit(0);
+    } else if (input) {
+      console.log('  Unknown command. Use n, l, a <code>, k <code>, or q.');
+    }
+
+    rl.prompt();
+  });
+
+  rl.on('close', () => {
+    manager.killAll();
+    process.exit(0);
+  });
+
+  process.on('SIGINT', () => {
+    console.log('');
+    logger.info('Shutting down...');
+    manager.killAll();
+    rl.close();
+    process.exit(0);
+  });
+}
+
+// ─── Global Error Handling ───────────────────────────────────────────────────
+
+process.on('uncaughtException', (err) => {
+  logger.error(`Uncaught exception: ${err.message}`, err);
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason) => {
+  const err = reason instanceof Error ? reason : new Error(String(reason));
+  logger.error(`Unhandled rejection: ${err.message}`, err);
+});
+
+// ─── Run ─────────────────────────────────────────────────────────────────────
+
+main().catch((err) => {
+  logger.error(`Fatal error: ${err.message}`, err);
+  process.exit(1);
+});

package/src/config.js

@@ -0,0 +1,91 @@
+/**
+ * PeerTerm — Configuration Module
+ *
+ * CLI argument parsing, flag detection, and static configuration constants.
+ * Single source of truth for user-provided options and app-wide constants.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import * as dotenv from 'dotenv';
+import minimist from 'minimist';
+import logger from './logger.js';
+import { printHelp, printVersion } from './ui.js';
+
+// ─── File paths ──────────────────────────────────────────────────────────────
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Load .env from host/ directory (parent of src/)
+dotenv.config({ path: path.join(__dirname, '..', '.env') });
+
+// ─── Version ─────────────────────────────────────────────────────────────────
+
+let version = 'unknown';
+try {
+  const pkgPath = path.join(__dirname, '..', 'package.json');
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+  version = pkg.version;
+} catch {}
+
+// ─── CLI Argument Parsing ────────────────────────────────────────────────────
+
+const argv = minimist(process.argv.slice(2), {
+  boolean: ['readonly', 'verbose', 'help', 'version', 'secure'],
+  string: ['expiry', 'rejoin', 'relay', 'path'],
+  alias: { h: 'help', v: 'version', V: 'verbose' },
+});
+
+// Detect if --expiry or --rejoin were explicitly passed on the command line
+const expiryFlagPassed = process.argv.some(a => a === '--expiry' || a.startsWith('--expiry='));
+const rejoinFlagPassed = process.argv.some(a => a === '--rejoin' || a.startsWith('--rejoin='));
+
+// Handle --help
+if (argv.help) {
+  printHelp();
+  process.exit(0);
+}
+
+// Handle --version
+if (argv.version) {
+  printVersion();
+  process.exit(0);
+}
+
+// Enable verbose logging
+if (argv.verbose) {
+  logger.setVerbose(true);
+}
+
+// ─── Static Configuration ────────────────────────────────────────────────────
+
+const DEFAULT_RELAYS = [
+  'wss://relay.dhananjaybalekar.in'
+];
+
+const RELAY_URLS = argv.relay 
+  ? argv.relay.split(',').map(s => s.trim()) 
+  : (process.env.RELAY_URL ? process.env.RELAY_URL.split(',').map(s => s.trim()) : DEFAULT_RELAYS);
+
+const HEARTBEAT_INTERVAL_MS = 5000;
+const MAX_MISSED_PINGS = 2;
+
+const UPLOAD_MAX_FILE_SIZE = 100 * 1024 * 1024; // 100 MB max
+const UPLOAD_MAX_CHUNKS_PER_FILE = Math.ceil(UPLOAD_MAX_FILE_SIZE / 16384);
+const UPLOAD_MAX_CONCURRENT = 3;
+
+// ─── Exports ─────────────────────────────────────────────────────────────────
+
+export {
+  argv,
+  version,
+  expiryFlagPassed,
+  rejoinFlagPassed,
+  RELAY_URLS,
+  HEARTBEAT_INTERVAL_MS,
+  MAX_MISSED_PINGS,
+  UPLOAD_MAX_FILE_SIZE,
+  UPLOAD_MAX_CHUNKS_PER_FILE,
+  UPLOAD_MAX_CONCURRENT,
+};

package/src/file-transfer.js

@@ -0,0 +1,230 @@
+/**
+ * PeerTerm — File Transfer Handler
+ *
+ * Encapsulates all file upload protocol logic:
+ * - Routing file-start, file-chunk, file-end, file-cancel messages
+ * - Chunk validation and size enforcement
+ * - File reassembly and disk writes
+ * - Ack/error responses back to the client
+ */
+
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import { encrypt } from './crypto.js';
+import {
+  UPLOAD_MAX_FILE_SIZE,
+  UPLOAD_MAX_CHUNKS_PER_FILE,
+  UPLOAD_MAX_CONCURRENT,
+} from './config.js';
+
+/**
+ * @typedef {Object} SessionContext
+ * @property {CryptoKey|null} sharedKey    - Current E2E shared key
+ * @property {boolean}        readOnly     - Whether the session is read-only
+ * @property {Object|null}    ptyProcess   - The PTY process instance
+ * @property {function}       log          - Session-scoped info logger
+ * @property {function}       logDebug     - Session-scoped debug logger
+ * @property {function}       sendEncrypted - Send encrypted payload to client
+ */
+
+export class FileTransferHandler {
+  /**
+   * @param {SessionContext} ctx - Session context for callbacks and state access
+   */
+  constructor(ctx) {
+    this._ctx = ctx;
+
+    /** @type {Object.<string, {name: string, size: number, totalChunks: number, receivedSize: number, chunks: Map}>} */
+    this._incomingFiles = {};
+  }
+
+  /**
+   * Update the session context (e.g. after key re-exchange).
+   * @param {SessionContext} ctx
+   */
+  updateContext(ctx) {
+    this._ctx = ctx;
+  }
+
+  /**
+   * Clean up all in-progress transfers.
+   */
+  cleanup() {
+    this._incomingFiles = {};
+  }
+
+  /**
+   * Route a file transfer message to the appropriate handler.
+   *
+   * @param {Object} msg - Parsed file message with type, id, and payload fields
+   */
+  handleMessage(msg) {
+    // Defense-in-depth: reject all file operations in read-only sessions
+    if (this._ctx.readOnly) {
+      this._sendError(msg.id, 'File uploads are disabled in read-only mode');
+      return;
+    }
+
+    switch (msg.type) {
+      case 'file-start': {
+        // Validate required fields
+        if (!msg.id || !msg.name || msg.size === undefined || msg.totalChunks === undefined) {
+          this._sendError(msg.id, 'Invalid file-start message');
+          return;
+        }
+
+        if (msg.size > UPLOAD_MAX_FILE_SIZE) {
+          this._sendError(msg.id, `File exceeds maximum size of ${UPLOAD_MAX_FILE_SIZE / 1024 / 1024}MB`);
+          return;
+        }
+
+        if (msg.totalChunks > UPLOAD_MAX_CHUNKS_PER_FILE) {
+          this._sendError(msg.id, 'File requires too many chunks');
+          return;
+        }
+
+        if (Object.keys(this._incomingFiles).length >= UPLOAD_MAX_CONCURRENT) {
+          this._sendError(msg.id, 'Too many concurrent uploads');
+          return;
+        }
+
+        this._ctx.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,
+          receivedSize: 0,
+          chunks: new Map(),
+        };
+        break;
+      }
+      case 'file-chunk': {
+        const transfer = this._incomingFiles[msg.id];
+        if (!transfer) {
+          this._sendError(msg.id, 'Unknown transfer ID');
+          return;
+        }
+
+        const chunkData = Buffer.from(msg.data, 'base64');
+        
+        if (transfer.chunks.size >= transfer.totalChunks) {
+          this._sendError(msg.id, 'Too many chunks received');
+          delete this._incomingFiles[msg.id];
+          return;
+        }
+
+        if (transfer.receivedSize + chunkData.length > transfer.size) {
+          this._sendError(msg.id, 'Received size exceeds declared size');
+          delete this._incomingFiles[msg.id];
+          return;
+        }
+
+        transfer.chunks.set(msg.index, chunkData);
+        transfer.receivedSize += chunkData.length;
+        this._ctx.logDebug(`File chunk ${msg.index + 1}/${transfer.totalChunks} received for "${transfer.name}"`);
+        break;
+      }
+      case 'file-end': {
+        this._finalizeFile(msg.id);
+        break;
+      }
+      case 'file-cancel': {
+        if (this._incomingFiles[msg.id]) {
+          delete this._incomingFiles[msg.id];
+          this._ctx.log(`File upload cancelled by client: ${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._sendError(id, 'Unknown transfer ID');
+      return;
+    }
+
+    // Check all chunks are present
+    for (let i = 0; i < transfer.totalChunks; i++) {
+      if (!transfer.chunks.has(i)) {
+        this._ctx.log(`File "${transfer.name}" missing chunk ${i}`);
+        this._sendError(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');
+    // Sanitize filename to prevent path traversal (e.g., "../../../etc/passwd")
+    const baseName = path.basename(transfer.name);
+    if (!baseName || baseName === '.' || baseName === '..') {
+      this._sendError(id, 'Invalid filename');
+      delete this._incomingFiles[id];
+      return;
+    }
+    const savePath = path.join(uploadDir, baseName);
+
+    try {
+      await fs.promises.mkdir(uploadDir, { recursive: true });
+      await fs.promises.writeFile(savePath, fileData);
+
+      this._ctx.log(`File saved: ${savePath}`);
+
+      // Write green ANSI message into the PTY to show the save path
+      if (this._ctx.ptyProcess) {
+        this._ctx.ptyProcess.write(`\r\n\x1b[32m[PeerTerm] File saved: ${savePath}\x1b[0m\r\n`);
+      }
+
+      // Send ack to client
+      this._sendAck(id, transfer.name);
+    } catch (err) {
+      this._ctx.log(`Failed to save file "${transfer.name}": ${err.message}`);
+      this._sendError(id, `Save failed: ${err.message}`);
+    }
+
+    delete this._incomingFiles[id];
+  }
+
+  /**
+   * Send file-ack to the client confirming successful file save.
+   */
+  async _sendAck(id, name) {
+    if (!this._ctx.sharedKey) return;
+    try {
+      const ackJson = JSON.stringify({ type: 'file-ack', id, name });
+      const payload = await encrypt(this._ctx.sharedKey, ackJson);
+      this._ctx.sendEncrypted(payload);
+    } catch (err) {
+      this._ctx.log(`Failed to send file-ack: ${err.message}`);
+    }
+  }
+
+  /**
+   * Send file-error to the client with an error message.
+   */
+  async _sendError(id, msg) {
+    if (!this._ctx.sharedKey) return;
+    try {
+      const errJson = JSON.stringify({ type: 'file-error', id, msg });
+      const payload = await encrypt(this._ctx.sharedKey, errJson);
+      this._ctx.sendEncrypted(payload);
+    } catch (err) {
+      this._ctx.log(`Failed to send file-error: ${err.message}`);
+    }
+  }
+}