peer-term 1.0.0

package/src/logger.js

@@ -0,0 +1,102 @@
+/**
+ * PeerTerm — Logger Module
+ *
+ * Structured logger with three levels: INFO, WARN, ERROR.
+ * - Timestamps: [HH:MM:SS]
+ * - Error logs written to ~/.peerterm/logs/error.log
+ * - --verbose flag enables DEBUG level
+ * - Stack traces only go to file, never to terminal
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const LOG_DIR = path.join(os.homedir(), '.peerterm', 'logs');
+const ERROR_LOG_PATH = path.join(LOG_DIR, 'error.log');
+
+let verboseMode = false;
+
+/**
+ * Ensure the log directory exists.
+ */
+function ensureLogDir() {
+  try {
+    fs.mkdirSync(LOG_DIR, { recursive: true });
+  } catch {
+    // Silent — if we can't create the log dir, we just skip file logging
+  }
+}
+
+/**
+ * Format current time as HH:MM:SS.
+ */
+function timestamp() {
+  const now = new Date();
+  const hh = String(now.getHours()).padStart(2, '0');
+  const mm = String(now.getMinutes()).padStart(2, '0');
+  const ss = String(now.getSeconds()).padStart(2, '0');
+  return `${hh}:${mm}:${ss}`;
+}
+
+/**
+ * Append an error entry to ~/.peerterm/logs/error.log.
+ */
+function writeToErrorLog(message, stack) {
+  try {
+    ensureLogDir();
+    const ts = new Date().toISOString();
+    const entry = `[${ts}] ${message}\n${stack ? stack + '\n' : ''}\n`;
+    fs.appendFileSync(ERROR_LOG_PATH, entry);
+  } catch {
+    // Silent — don't crash because of logging
+  }
+}
+
+const logger = {
+  /**
+   * Enable or disable verbose (DEBUG) mode.
+   */
+  setVerbose(enabled) {
+    verboseMode = enabled;
+  },
+
+  /**
+   * INFO — always shown. Key events the user should see.
+   */
+  info(msg) {
+    console.log(`  [${timestamp()}] INFO  ${msg}`);
+  },
+
+  /**
+   * WARN — always shown. Non-fatal issues.
+   */
+  warn(msg) {
+    console.log(`  [${timestamp()}] WARN  ${msg}`);
+  },
+
+  /**
+   * ERROR — always shown in terminal (human-readable message only).
+   * Stack trace is written to ~/.peerterm/logs/error.log.
+   */
+  error(msg, err) {
+    console.error(`  [${timestamp()}] ERROR ${msg}`);
+    if (err && err.stack) {
+      writeToErrorLog(msg, err.stack);
+    } else {
+      writeToErrorLog(msg);
+    }
+  },
+
+  /**
+   * DEBUG — only shown when --verbose is enabled.
+   */
+  debug(msg) {
+    if (verboseMode) {
+      console.log(`  [${timestamp()}] DEBUG ${msg}`);
+    }
+  },
+};
+
+export default logger;
+export { writeToErrorLog, ERROR_LOG_PATH };

package/src/session-viewer.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+/**
+ * PeerTerm Session Viewer
+ *
+ * Opens in a new terminal window and connects to the host's PTY
+ * via a local TCP socket. Gives the host a direct terminal view.
+ */
+
+import net from 'net';
+
+const port = parseInt(process.argv[2], 10);
+
+if (!port || isNaN(port) || port < 1 || port > 65535) {
+  console.error('Usage: session-viewer.js <port>\nPort must be a number between 1 and 65535.');
+  process.exit(1);
+}
+
+function cleanup(code, msg) {
+  if (process.stdin.isTTY) process.stdin.setRawMode(false);
+  if (msg) {
+    if (code !== 0) console.error(msg);
+    else console.log(msg);
+  }
+  process.exit(code);
+}
+
+process.on('SIGINT', () => cleanup(0, '\n  Session terminated by signal.'));
+process.on('SIGTERM', () => cleanup(0, '\n  Session terminated by signal.'));
+
+function formatResizeMessage(cols, rows) {
+  return `\x00${JSON.stringify({ type: 'resize', cols, rows })}\n`;
+}
+
+const client = net.connect({ port, host: '127.0.0.1' }, () => {
+  client.setTimeout(0); // Clear timeout once connected
+  // Send initial terminal size
+  const cols = process.stdout.isTTY ? (process.stdout.columns || 80) : 80;
+  const rows = process.stdout.isTTY ? (process.stdout.rows || 24) : 24;
+  client.write(formatResizeMessage(cols, rows));
+
+  // Enter raw mode
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+
+  // Host keystrokes → PTY
+  process.stdin.on('data', (data) => {
+    client.write(data);
+  });
+
+  // PTY output → host terminal
+  client.on('data', (data) => {
+    process.stdout.write(data);
+  });
+
+  // Forward terminal resize
+  if (process.stdout.isTTY) {
+    process.stdout.on('resize', () => {
+      const cols = process.stdout.columns || 80;
+      const rows = process.stdout.rows || 24;
+      client.write(formatResizeMessage(cols, rows));
+    });
+  }
+});
+client.setTimeout(5000);
+
+client.on('timeout', () => {
+  client.destroy();
+  cleanup(1, '  Connection timed out.');
+});
+
+client.on('close', () => {
+  cleanup(0, '\n  Session ended.');
+});
+
+client.on('error', (err) => {
+  cleanup(1, `  Connection failed: ${err.message}`);
+});

package/src/ui.js

@@ -0,0 +1,137 @@
+/**
+ * PeerTerm — CLI UI Module
+ *
+ * Handles all terminal output formatting:
+ * - ASCII art banner
+ * - Session code display box
+ * - Help text
+ * - Version display
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// ─── ASCII Banner ────────────────────────────────────────────────────────────
+
+const BANNER = `
+  ██████╗ ███████╗███████╗██████╗ ████████╗███████╗██████╗ ███╗   ███╗
+  ██╔══██╗██╔════╝██╔════╝██╔══██╗╚══██╔══╝██╔════╝██╔══██╗████╗ ████║
+  ██████╔╝█████╗  █████╗  ██████╔╝   ██║   █████╗  ██████╔╝██╔████╔██║
+  ██╔═══╝ ██╔══╝  ██╔══╝  ██╔══██╗   ██║   ██╔══╝  ██╔══██╗██║╚██╔╝██║
+  ██║     ███████╗███████╗██║  ██║   ██║   ███████╗██║  ██║██║ ╚═╝ ██║
+  ╚═╝     ╚══════╝╚══════╝╚═╝  ╚═╝   ╚═╝   ╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝
+                      Terminal sharing. Instant. Encrypted.`;
+
+/**
+ * Print the startup ASCII art banner.
+ */
+export function printBanner() {
+  console.log(BANNER);
+  console.log('');
+}
+
+// ─── Session Code Box ────────────────────────────────────────────────────────
+
+/**
+ * Print the bordered session information box.
+ *
+ * @param {Object} opts
+ * @param {string} opts.code     - 6-digit session code
+ * @param {string} opts.expiry   - Formatted expiry string (e.g. "5 minute(s)")
+ * @param {string} opts.mode     - "Read-Write" or "Read-Only"
+ * @param {string} opts.shell    - Shell path (e.g. "/bin/zsh")
+ * @param {string} [opts.startPath] - Starting directory for the session
+ * @param {string} [opts.shareUrl] - URL to share (e.g. "https://peerterm.dev")
+ */
+export function printSessionBox({ code, expiry, mode, shell, startPath, shareUrl }) {
+  const spacedCode = code.split('').join(' ');
+  const url = shareUrl || 'https://peerterm.dev';
+
+  // Truncate long shell paths to keep box readable
+  const shellDisplay = shell.length > 24 ? '...' + shell.slice(-21) : shell;
+
+  // Truncate long start paths similarly
+  const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+  let pathDisplay = startPath || homeDir;
+  if (homeDir && pathDisplay.startsWith(homeDir)) {
+    pathDisplay = '~' + pathDisplay.slice(homeDir.length);
+  }
+  if (pathDisplay.length > 30) pathDisplay = '...' + pathDisplay.slice(-27);
+
+  // Calculate dynamic box width based on longest content
+  const infoLines = [
+    `   Session Code:  ${spacedCode}`,
+    `   Expires in:    ${expiry}`,
+    `   Mode:          ${mode}`,
+    `   Shell:         ${shellDisplay}`,
+    `   Path:          ${pathDisplay}`,
+  ];
+  const shareLine = `   Share at: ${url}`;
+  const allLines = [...infoLines, shareLine];
+  const maxLen = Math.max(...allLines.map(l => l.length), 35);
+  const innerWidth = maxLen + 3; // padding on right
+
+  const hr = '─'.repeat(innerWidth);
+  const emptyLine = ' '.repeat(innerWidth);
+
+  console.log('');
+  console.log(`  ┌${hr}┐`);
+  console.log(`  │${emptyLine}│`);
+  for (const line of infoLines) {
+    console.log(`  │${line.padEnd(innerWidth)}│`);
+  }
+  console.log(`  │${emptyLine}│`);
+  console.log(`  │${shareLine.padEnd(innerWidth)}│`);
+  console.log(`  │${emptyLine}│`);
+  console.log(`  └${hr}┘`);
+  console.log('');
+}
+
+// ─── Help Text ───────────────────────────────────────────────────────────────
+
+const HELP_TEXT = `
+Usage: peer-term [options]
+
+Options:
+  --expiry <time>     Session expiry time (e.g. 5m, 30s, 1h)  [default: 5m]
+  --readonly          Share in view-only mode
+  --path <dir>        Starting directory for the terminal session  [default: home]
+  --relay <url>       Custom relay server URL
+  --verbose           Enable debug logging
+  --help              Show this help message
+  --version           Print version number
+
+Examples:
+  peer-term                        Start session with defaults
+  peer-term --expiry 10m           Custom expiry
+  peer-term --readonly             View-only session
+  peer-term --path ~/projects      Start in ~/projects
+  peer-term --verbose              Debug logs
+  peer-term --relay wss://custom   Use custom relay server
+`;
+
+/**
+ * Print CLI help text.
+ */
+export function printHelp() {
+  console.log(HELP_TEXT);
+}
+
+// ─── Version ─────────────────────────────────────────────────────────────────
+
+/**
+ * Print the version number from package.json.
+ */
+export function printVersion() {
+  try {
+    const pkgPath = path.join(__dirname, '..', 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    console.log(`peer-term v${pkg.version}`);
+  } catch {
+    console.log('peer-term (version unknown)');
+  }
+}

package/src/webrtc.js

@@ -0,0 +1,309 @@
+/**
+ * PeerTerm — Host-side WebRTC Module
+ *
+ * Manages a WebRTC PeerConnection + DataChannel for direct local P2P
+ * terminal data transfer when host and client are on the same LAN.
+ *
+ * Key design points:
+ *   - iceServers: [] — no STUN/TURN, only local candidates
+ *   - ICE candidate parsing detects "typ host" for same-LAN detection
+ *   - 3-second ICE gathering timeout, 5-second DataChannel open timeout
+ *   - Emits 'open', 'close', 'message' events for Session integration
+ *   - Encrypted data flows unchanged — just a different transport
+ */
+
+import nodeDataChannel from 'node-datachannel';
+
+// Private IP ranges (same LAN indicators)
+const LOCAL_IP_REGEX = /^(192\.168\.|10\.|172\.(1[6-9]|2[0-9]|3[01])\.)/;
+
+// Timeouts
+const ICE_TIMEOUT_MS = 3000;
+const DC_OPEN_TIMEOUT_MS = 5000;
+
+export class HostWebRTC {
+  constructor(logFn) {
+    this._log = logFn || (() => {});
+    this._pc = null;
+    this._dc = null;
+    this._sendSignal = null;
+    this._sameLAN = false;
+    this._peerSameLAN = false;
+    this._dcOpen = false;
+    this._closed = false;
+
+    // Event callbacks
+    this._onOpenCb = null;
+    this._onCloseCb = null;
+    this._onMessageCb = null;
+
+    // Timeout handles
+    this._iceTimer = null;
+    this._dcTimer = null;
+  }
+
+  /**
+   * Start WebRTC negotiation — create offer and begin ICE gathering.
+   * @param {Function} sendSignal — sends { type: 'signal', payload } via relay WS
+   */
+  initiate(sendSignal) {
+    this._sendSignal = sendSignal;
+
+    try {
+      this._log('[WebRTC] Initiating peer connection...');
+
+      this._pc = new nodeDataChannel.PeerConnection('host', {
+        iceServers: [],
+        // Disable mDNS candidates to get raw local IPs
+        enableIceUdpMux: true,
+      });
+
+      // ─── ICE candidate handling ──────────────────────────────────────
+      this._pc.onLocalCandidate((candidate, mid) => {
+        if (this._closed) return;
+
+        // Parse candidate type
+        const candidateStr = candidate;
+        this._checkLocalCandidate(candidateStr);
+
+        this._sendSignal({
+          type: 'signal',
+          payload: { kind: 'ice', candidate: candidateStr, mid },
+        });
+      });
+
+      this._pc.onStateChange((state) => {
+        this._log(`[WebRTC] Connection state: ${state}`);
+        if (state === 'disconnected' || state === 'failed' || state === 'closed') {
+          this._handleClose();
+        }
+      });
+
+      this._pc.onGatheringStateChange((state) => {
+        this._log(`[WebRTC] ICE gathering state: ${state}`);
+      });
+
+      // ─── Create DataChannel ──────────────────────────────────────────
+      this._dc = this._pc.createDataChannel('terminal');
+
+      this._dc.onOpen(() => {
+        if (this._closed) return;
+        this._clearTimers();
+        this._dcOpen = true;
+        this._log('[WebRTC] DataChannel open — relay bypassed');
+        if (this._onOpenCb) this._onOpenCb();
+      });
+
+      this._dc.onClosed(() => {
+        if (this._closed) return;
+        this._log('[WebRTC] DataChannel closed');
+        this._handleClose();
+      });
+
+      this._dc.onError((err) => {
+        this._log(`[WebRTC] DataChannel error: ${err}`);
+      });
+
+      this._dc.onMessage((msg) => {
+        if (this._closed || !this._onMessageCb) return;
+        // msg can be string or Buffer
+        const data = typeof msg === 'string' ? msg : msg.toString();
+        this._onMessageCb(data);
+      });
+
+      // ─── Create SDP offer ────────────────────────────────────────────
+      this._pc.setLocalDescription();
+
+      // Wait a tick for the description to be set, then send
+      setTimeout(() => {
+        if (this._closed) return;
+        const desc = this._pc.localDescription();
+        if (desc) {
+          this._sendSignal({
+            type: 'signal',
+            payload: { kind: 'offer', sdp: desc.sdp, sdpType: desc.type },
+          });
+        }
+      }, 100);
+
+      // ─── ICE timeout — 3 seconds ────────────────────────────────────
+      this._iceTimer = setTimeout(() => {
+        if (this._closed || this._dcOpen) return;
+        if (!this._sameLAN || !this._peerSameLAN) {
+          this._log('[WebRTC] Not on same LAN — using relay');
+          this._sendSignal({
+            type: 'signal',
+            payload: { kind: 'webrtc-abort' },
+          });
+          this.close();
+        } else {
+          // Same LAN confirmed — wait for DataChannel to open
+          this._log('[WebRTC] Same LAN detected — waiting for DataChannel...');
+          this._dcTimer = setTimeout(() => {
+            if (this._closed || this._dcOpen) return;
+            this._log('[WebRTC] DataChannel open timeout — falling back to relay');
+            this._sendSignal({
+              type: 'signal',
+              payload: { kind: 'webrtc-abort' },
+            });
+            this.close();
+          }, DC_OPEN_TIMEOUT_MS);
+        }
+      }, ICE_TIMEOUT_MS);
+
+    } catch (err) {
+      this._log(`[WebRTC] Init failed: ${err.message}`);
+      this.close();
+    }
+  }
+
+  /**
+   * Handle incoming signal messages from the peer (via relay).
+   */
+  handleSignal(payload) {
+    if (this._closed || !this._pc) return;
+
+    try {
+      switch (payload.kind) {
+        case 'answer':
+          this._pc.setRemoteDescription(payload.sdp, payload.sdpType || 'answer');
+          break;
+
+        case 'ice':
+          if (payload.candidate) {
+            this._checkRemoteCandidate(payload.candidate);
+            this._pc.addRemoteCandidate(payload.candidate, payload.mid || '0');
+          }
+          break;
+
+        case 'webrtc-abort':
+          this._log('[WebRTC] Peer aborted WebRTC — using relay');
+          this.close();
+          break;
+
+        default:
+          break;
+      }
+    } catch (err) {
+      this._log(`[WebRTC] Signal handling error: ${err.message}`);
+    }
+  }
+
+  /**
+   * Send data over the DataChannel.
+   * @param {string} data — encrypted base64 blob
+   */
+  send(data) {
+    if (!this._dcOpen || !this._dc || this._closed) return false;
+    try {
+      this._dc.sendMessage(data);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Returns true if the DataChannel is open and active.
+   */
+  isActive() {
+    return this._dcOpen && !this._closed;
+  }
+
+  // ─── Event registration ──────────────────────────────────────────────────
+
+  onOpen(cb) { this._onOpenCb = cb; }
+  onClose(cb) { this._onCloseCb = cb; }
+  onMessage(cb) { this._onMessageCb = cb; }
+
+  // ─── Cleanup ─────────────────────────────────────────────────────────────
+
+  close() {
+    if (this._closed) return;
+    this._closed = true;
+    this._dcOpen = false;
+    this._clearTimers();
+
+    try {
+      if (this._dc) {
+        this._dc.close();
+        this._dc = null;
+      }
+    } catch {}
+
+    try {
+      if (this._pc) {
+        this._pc.close();
+        this._pc = null;
+      }
+    } catch {}
+  }
+
+  // ─── Private helpers ─────────────────────────────────────────────────────
+
+  _clearTimers() {
+    if (this._iceTimer) { clearTimeout(this._iceTimer); this._iceTimer = null; }
+    if (this._dcTimer) { clearTimeout(this._dcTimer); this._dcTimer = null; }
+  }
+
+  _handleClose() {
+    if (this._closed) return;
+    const wasOpen = this._dcOpen;
+    this._dcOpen = false;
+    this._closed = true;
+    this._clearTimers();
+
+    if (wasOpen && this._onCloseCb) {
+      this._onCloseCb();
+    }
+  }
+
+  /**
+   * Check a local ICE candidate for "typ host" (local IP).
+   */
+  _checkLocalCandidate(candidateStr) {
+    if (this._sameLAN) return;
+    if (this._isHostCandidate(candidateStr)) {
+      this._sameLAN = true;
+      this._log('[WebRTC] Local host-type ICE candidate found');
+    }
+  }
+
+  /**
+   * Check a remote ICE candidate for "typ host" (peer's local IP).
+   */
+  _checkRemoteCandidate(candidateStr) {
+    if (this._peerSameLAN) return;
+    if (this._isHostCandidate(candidateStr)) {
+      this._peerSameLAN = true;
+      this._log('[WebRTC] Remote host-type ICE candidate found');
+    }
+  }
+
+  /**
+   * Parse ICE candidate string to check if it's a "host" type
+   * with a local/private IP address.
+   */
+  _isHostCandidate(candidateStr) {
+    if (!candidateStr) return false;
+    // ICE candidate format: candidate:... typ host ...
+    const typMatch = candidateStr.match(/typ\s+(\S+)/);
+    if (!typMatch) return false;
+    const candidateType = typMatch[1];
+    if (candidateType !== 'host') return false;
+
+    // Optionally verify it's a private IP
+    const ipMatch = candidateStr.match(/(\d+\.\d+\.\d+\.\d+)/);
+    if (ipMatch && LOCAL_IP_REGEX.test(ipMatch[1])) {
+      return true;
+    }
+
+    // IPv6 link-local (fe80::) also counts as local
+    if (candidateStr.includes('fe80::')) {
+      return true;
+    }
+
+    // If it says "typ host" but we can't parse the IP, still treat as host
+    return true;
+  }
+}