peer-term 1.3.10 → 1.4.1

package/src/prompts.js

@@ -0,0 +1,143 @@
+/**
+ * PeerTerm — Interactive Prompts
+ *
+ * Terminal prompts for session expiry and rejoin window configuration.
+ * Handles three modes: CLI flag, interactive TTY prompt, silent default.
+ */
+
+import readline from 'readline';
+import { parseDuration } from './utils.js';
+import { argv, expiryFlagPassed, rejoinFlagPassed } from './config.js';
+import logger from './logger.js';
+
+// ─── Generic Duration Prompt ─────────────────────────────────────────────────
+
+/**
+ * Prompt the user for a duration value in the terminal.
+ * Re-prompts on invalid input until a valid value is entered or Enter is pressed for default.
+ *
+ * @param {Object} opts
+ * @param {string} opts.label       - Main prompt question
+ * @param {string} opts.description - Additional context shown below the question
+ * @param {number} opts.defaultMs   - Default value in milliseconds
+ * @param {string} opts.defaultLabel - Human-readable default (e.g. "5 minutes")
+ * @param {number} opts.minMs       - Minimum allowed value in milliseconds
+ * @param {number} opts.maxMs       - Maximum allowed value in milliseconds
+ * @param {string} opts.minLabel    - Human-readable minimum (e.g. "2m")
+ * @param {string} opts.maxLabel    - Human-readable maximum (e.g. "24h")
+ * @returns {Promise<number>} Resolved duration in milliseconds
+ */
+function promptDuration({ label, description, defaultMs, defaultLabel, minMs, maxMs, minLabel, maxLabel }) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    const ask = () => {
+      console.log('');
+      console.log(`  ${label}`);
+      if (description) console.log(`  ${description}`);
+      console.log(`  Enter a value between ${minLabel} and ${maxLabel} (e.g. ${minLabel}, 30m, 2h)`);
+      console.log(`  Default is ${defaultLabel}. Press Enter to use default.`);
+      rl.question('  > ', (answer) => {
+        const input = answer.trim();
+
+        // Empty input — use default
+        if (!input) {
+          rl.close();
+          resolve(defaultMs);
+          return;
+        }
+
+        const parsed = parseDuration(input);
+        if (!parsed || parsed < minMs || parsed > maxMs) {
+          console.log(`  Invalid value. Please enter a time between ${minLabel} and ${maxLabel} (e.g. 5m, 1h).`);
+          ask();
+          return;
+        }
+
+        rl.close();
+        resolve(parsed);
+      });
+    };
+
+    ask();
+  });
+}
+
+// ─── Expiry ──────────────────────────────────────────────────────────────────
+
+/**
+ * Get the session code expiry — from flag, interactive prompt, or silent default.
+ *
+ * @returns {Promise<number>} Expiry in milliseconds
+ */
+export async function getExpiryInteractive() {
+  const DEFAULT_EXPIRY = 5 * 60 * 1000;       // 5 minutes
+  const MIN_EXPIRY     = 2 * 60 * 1000;       // 2 minutes
+  const MAX_EXPIRY     = 24 * 60 * 60 * 1000; // 24 hours
+
+  // If --expiry flag was explicitly passed, use it (validate and exit on error)
+  if (expiryFlagPassed) {
+    const parsed = parseDuration(argv.expiry);
+    if (!parsed || parsed < MIN_EXPIRY || parsed > MAX_EXPIRY) {
+      logger.error(`Invalid expiry: "${argv.expiry}". Must be between 2m and 24h.`);
+      process.exit(1);
+    }
+    return parsed;
+  }
+
+  // Non-interactive — use default silently
+  if (!process.stdin.isTTY) return DEFAULT_EXPIRY;
+
+  // Interactive prompt
+  return promptDuration({
+    label: 'How long should the session code be valid?',
+    description: null,
+    defaultMs: DEFAULT_EXPIRY,
+    defaultLabel: '5 minutes',
+    minMs: MIN_EXPIRY,
+    maxMs: MAX_EXPIRY,
+    minLabel: '2m',
+    maxLabel: '24h',
+  });
+}
+
+// ─── Rejoin Window ───────────────────────────────────────────────────────────
+
+/**
+ * Get the reconnection window — from flag, interactive prompt, or silent default.
+ *
+ * @returns {Promise<number>} Rejoin window in milliseconds
+ */
+export async function getRejoinInteractive() {
+  const DEFAULT_REJOIN = 5 * 60 * 1000;       // 5 minutes
+  const MIN_REJOIN     = 5 * 60 * 1000;       // 5 minutes
+  const MAX_REJOIN     = 6 * 60 * 60 * 1000;  // 6 hours
+
+  // If --rejoin flag was explicitly passed, use it
+  if (rejoinFlagPassed) {
+    const parsed = parseDuration(argv.rejoin);
+    if (!parsed || parsed < MIN_REJOIN || parsed > MAX_REJOIN) {
+      logger.error(`Invalid rejoin window: "${argv.rejoin}". Must be between 5m and 6h.`);
+      process.exit(1);
+    }
+    return parsed;
+  }
+
+  // Non-interactive — use default silently
+  if (!process.stdin.isTTY) return DEFAULT_REJOIN;
+
+  // Interactive prompt
+  return promptDuration({
+    label: 'How long should the reconnection window be?',
+    description: 'This is how long a disconnected client or host has to rejoin before the session ends.',
+    defaultMs: DEFAULT_REJOIN,
+    defaultLabel: '2 minutes',
+    minMs: MIN_REJOIN,
+    maxMs: MAX_REJOIN,
+    minLabel: '5m',
+    maxLabel: '6h',
+  });
+}

package/src/ui.js

@@ -11,6 +11,7 @@
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import qrcode from 'qrcode-terminal';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -47,9 +48,10 @@ export function printBanner() {
  * @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, rejoinWindow, mode, shell, startPath, shareUrl }) {
+export async function printSessionBox({ code, expiry, rejoinWindow, mode, shell, startPath, shareUrl }) {
   const spacedCode = code.split('').join(' ');
   const url = shareUrl || 'https://peerterm.dev';
+  const joinUrl = `${url}?code=${code}`;
 
   // Truncate long shell paths to keep box readable
   const shellDisplay = shell.length > 24 ? '...' + shell.slice(-21) : shell;
@@ -90,6 +92,28 @@ export function printSessionBox({ code, expiry, rejoinWindow, mode, shell, start
   console.log(`  │${emptyLine}│`);
   console.log(`  └${hr}┘`);
   console.log('');
+
+  // Render QR code for instant scan-to-join
+  try {
+    const qrString = await new Promise((resolve) => {
+      qrcode.generate(joinUrl, { small: true }, (qr) => {
+        resolve(qr);
+      });
+    });
+
+    console.log('  Scan to join:');
+    console.log('');
+    // Indent each QR line for alignment with the box
+    const qrLines = qrString.split('\n');
+    for (const line of qrLines) {
+      if (line.length > 0) console.log(`    ${line}`);
+    }
+    console.log('');
+    console.log(`  Or open: ${joinUrl}`);
+    console.log('');
+  } catch {
+    // QR generation failed — not critical, code is still shown in the box
+  }
 }
 
 // ─── Help Text ───────────────────────────────────────────────────────────────

package/src/utils.js

@@ -0,0 +1,113 @@
+/**
+ * PeerTerm — Utility Functions
+ *
+ * Generic helpers with no domain dependencies:
+ * - Duration parsing and formatting
+ * - Path resolution (tilde expansion, start path validation)
+ * - Shell detection
+ */
+
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import logger from './logger.js';
+
+// ─── Duration Parsing ────────────────────────────────────────────────────────
+
+/**
+ * Parse a human-readable duration string into milliseconds.
+ * Accepted formats: "30s", "5m", "1h" (case-insensitive).
+ *
+ * @param {string} str - Duration string
+ * @returns {number|null} Duration in milliseconds, or null if invalid
+ */
+export function parseDuration(str) {
+  const match = str.match(/^(\d+)(s|m|h)$/i);
+  if (!match) return null;
+  const value = parseInt(match[1], 10);
+  const unit = match[2].toLowerCase();
+  switch (unit) {
+    case 's': return value * 1000;
+    case 'm': return value * 60 * 1000;
+    case 'h': return value * 60 * 60 * 1000;
+    default:  return null;
+  }
+}
+
+/**
+ * Format a duration in milliseconds to a human-readable string.
+ *
+ * @param {number} ms - Duration in milliseconds
+ * @returns {string} Formatted string (e.g. "5 minute(s)")
+ */
+export function formatDuration(ms) {
+  if (ms >= 3600000) return `${Math.round(ms / 3600000)} hour(s)`;
+  if (ms >= 60000) return `${Math.round(ms / 60000)} minute(s)`;
+  return `${Math.round(ms / 1000)} second(s)`;
+}
+
+// ─── Path Resolution ─────────────────────────────────────────────────────────
+
+/**
+ * Expand a leading ~ to the user's home directory.
+ *
+ * @param {string} inputPath
+ * @returns {string}
+ */
+export function expandTilde(inputPath) {
+  if (inputPath.startsWith('~/') || inputPath === '~') {
+    return inputPath.replace(/^~/, process.env.HOME || process.env.USERPROFILE || '.');
+  }
+  return inputPath;
+}
+
+/**
+ * Resolve and validate a starting directory path.
+ * Falls back to the user's home directory if no path is provided.
+ * Exits the process if the path doesn't exist or isn't a directory.
+ *
+ * @param {string|undefined} inputPath
+ * @returns {string} Resolved absolute path
+ */
+export function resolveStartPath(inputPath) {
+  if (!inputPath) return process.env.HOME || process.env.USERPROFILE || process.cwd();
+
+  const resolved = path.resolve(expandTilde(inputPath));
+
+  if (!fs.existsSync(resolved)) {
+    logger.error(`Path does not exist: ${resolved}`);
+    process.exit(1);
+  }
+
+  const stat = fs.statSync(resolved);
+  if (!stat.isDirectory()) {
+    logger.error(`Path is not a directory: ${resolved}`);
+    process.exit(1);
+  }
+
+  return resolved;
+}
+
+// ─── Shell Detection ─────────────────────────────────────────────────────────
+
+/**
+ * Detect the user's default shell.
+ * Checks $SHELL, Windows COMSPEC, /etc/passwd, and falls back to bash/powershell.
+ *
+ * @returns {string} Shell executable path or name
+ */
+export function detectShell() {
+  const platform = os.platform();
+  if (process.env.SHELL) return process.env.SHELL;
+  if (platform === 'win32') return process.env.COMSPEC || 'powershell.exe';
+  try {
+    const passwd = fs.readFileSync('/etc/passwd', 'utf-8');
+    const username = os.userInfo().username;
+    const line = passwd.split('\n').find((l) => l.startsWith(username + ':'));
+    if (line) {
+      const shell = line.split(':').pop().trim();
+      if (shell) return shell;
+    }
+  } catch {}
+  return platform === 'win32' ? 'powershell.exe' : 'bash';
+}

package/src/viewer.js

@@ -0,0 +1,259 @@
+/**
+ * PeerTerm — Local Viewer Server
+ *
+ * Token-authenticated TCP server that opens a new terminal window
+ * for the host to view the shared session locally.
+ *
+ * Cross-platform terminal opener (Windows, macOS, Linux).
+ */
+
+import crypto from 'crypto';
+import net from 'net';
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { execFile, spawn } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export class ViewerServer {
+  /**
+   * @param {Object} opts
+   * @param {string}   opts.code        - Session code (for window title)
+   * @param {function} opts.log         - Info logger
+   * @param {function} opts.logDebug    - Debug logger
+   * @param {function} opts.onResize    - Called with (cols, rows) when viewer resizes
+   * @param {function} opts.onKeystroke - Called with (data) for host keystrokes → PTY
+   */
+  constructor({ code, log, logDebug, onResize, onKeystroke }) {
+    this._code = code;
+    this._log = log;
+    this._logDebug = logDebug;
+    this._onResize = onResize;
+    this._onKeystroke = onKeystroke;
+
+    this._server = null;
+    this._socket = null;
+    this._token = null;
+  }
+
+  /**
+   * The active viewer socket (if connected and authenticated).
+   * Used by Session to mirror PTY output to the local viewer.
+   * @type {net.Socket|null}
+   */
+  get socket() {
+    return this._socket;
+  }
+
+  /**
+   * Start the TCP viewer server on a random port and open a terminal window.
+   */
+  start() {
+    // Generate a random nonce for viewer authentication
+    this._token = crypto.randomBytes(16).toString('hex');
+
+    this._server = net.createServer((socket) => {
+      // Close any existing viewer connection before accepting a new one
+      if (this._socket) {
+        this._logDebug('Replacing existing viewer connection.');
+        this._socket.removeAllListeners();
+        try { this._socket.destroy(); } catch {}
+      }
+
+      // ── Token authentication gate ──────────────────────────────────
+      // The first data packet must be the viewer token followed by a newline.
+      // Reject the connection if no valid token arrives within 2 seconds.
+      let authenticated = false;
+      let authBuf = '';
+
+      const authTimeout = setTimeout(() => {
+        if (!authenticated) {
+          this._logDebug('Viewer auth timeout — closing connection.');
+          try { socket.destroy(); } catch {}
+        }
+      }, 2000);
+
+      const onAuthData = (data) => {
+        authBuf += data.toString();
+        const newlineIdx = authBuf.indexOf('\n');
+        if (newlineIdx === -1) {
+          // Accumulated too much data without a newline — reject
+          if (authBuf.length > 256) {
+            clearTimeout(authTimeout);
+            this._logDebug('Viewer auth buffer overflow — closing connection.');
+            try { socket.destroy(); } catch {}
+          }
+          return;
+        }
+
+        const token = authBuf.slice(0, newlineIdx).trim();
+        const remaining = authBuf.slice(newlineIdx + 1);
+        clearTimeout(authTimeout);
+        socket.removeListener('data', onAuthData);
+
+        if (token !== this._token) {
+          this._logDebug('Viewer auth failed — wrong token.');
+          try { socket.destroy(); } catch {}
+          return;
+        }
+
+        // Authenticated — promote to active viewer
+        authenticated = true;
+        this._socket = socket;
+        this._log('Host viewer connected (authenticated).');
+
+        // Install the real data handler
+        let recvBuf = '';
+
+        // Process any leftover data that arrived after the token line
+        if (remaining.length > 0) {
+          handleViewerData(remaining);
+        }
+
+        socket.on('data', (chunk) => handleViewerData(chunk.toString()));
+
+        const handleViewerData = (chunk) => {
+          // Control messages start with \x00{
+          if (recvBuf.length > 0 || chunk.startsWith('\x00{')) {
+            recvBuf += chunk;
+            let nlIdx;
+            while ((nlIdx = recvBuf.indexOf('\n')) !== -1) {
+              const line = recvBuf.slice(0, nlIdx).trim();
+              recvBuf = recvBuf.slice(nlIdx + 1);
+
+              if (line.startsWith('\x00')) {
+                try {
+                  const msg = JSON.parse(line.slice(1));
+                  if (msg.type === 'resize' &&
+                      Number.isInteger(msg.cols) && msg.cols > 0 &&
+                      Number.isInteger(msg.rows) && msg.rows > 0) {
+                    this._onResize(msg.cols, msg.rows);
+                    this._logDebug(`Viewer resized to ${msg.cols}x${msg.rows}`);
+                  }
+                } catch {}
+              } else {
+                this._onKeystroke(line + '\n');
+              }
+            }
+            // Flush any non-control data left in the buffer
+            if (recvBuf.length > 0 && !recvBuf.startsWith('\x00')) {
+              this._onKeystroke(recvBuf);
+              recvBuf = '';
+            }
+            return;
+          }
+
+          // Host keystrokes → PTY (host always has access)
+          this._onKeystroke(chunk);
+        };
+
+        socket.on('close', () => {
+          this._socket = null;
+          this._logDebug('Host viewer disconnected.');
+        });
+
+        socket.on('error', () => {
+          this._socket = null;
+        });
+      };
+
+      socket.on('data', onAuthData);
+
+      socket.on('error', () => {
+        clearTimeout(authTimeout);
+      });
+    });
+
+    this._server.listen(0, '127.0.0.1', () => {
+      const port = this._server.address().port;
+      this._logDebug(`Viewer server on port ${port}`);
+      this._openTerminal(port, this._token);
+    });
+
+    this._server.on('error', (err) => {
+      this._log(`Viewer server error: ${err.message}`);
+      this._server = null;
+    });
+  }
+
+  /**
+   * Write data to the viewer socket (for mirroring PTY output).
+   *
+   * @param {string|Buffer} data
+   */
+  write(data) {
+    if (this._socket) {
+      try { this._socket.write(data); } catch {}
+    }
+  }
+
+  /**
+   * Clean up the viewer server and socket.
+   */
+  destroy() {
+    if (this._socket) {
+      try { this._socket.destroy(); } catch {}
+      this._socket = null;
+    }
+    if (this._server) {
+      try { this._server.close(); } catch {}
+      this._server = null;
+    }
+  }
+
+  /**
+   * Open a new terminal window connected to the viewer server.
+   * @private
+   */
+  _openTerminal(port, token) {
+    if (!/^[A-Za-z0-9_-]+$/.test(this._code)) {
+      this._log('Invalid session code format. Aborting viewer terminal.');
+      return;
+    }
+
+    const viewerScript = path.join(__dirname, 'session-viewer.js');
+    const platform = os.platform();
+    const portStr = String(port);
+    const nodeArgs = [viewerScript, portStr, this._code, token];
+
+    if (platform === 'win32') {
+      // spawn with 'cmd' to open a new window; arguments are passed as an
+      // array so the install path is never interpreted by the shell.
+      spawn('cmd', ['/c', 'start', `PeerTerm - ${this._code}`, 'cmd', '/c', 'node', ...nodeArgs], {
+        stdio: 'ignore',
+        detached: true,
+        windowsHide: false,
+      }).unref();
+    } else if (platform === 'darwin') {
+      // osascript receives the AppleScript source as a single -e argument;
+      // node args are baked into the script string, but execFile does NOT
+      // invoke a shell so the outer path cannot break out.
+      const script = `tell app "Terminal" to do script "node '${viewerScript.replace(/'/g, "'\\''")}' ${portStr} ${this._code} ${token}"`;
+      execFile('osascript', ['-e', script], { stdio: 'ignore' }, () => {});
+    } else {
+      // Linux: try common terminal emulators in order, falling through on
+      // failure.  Each call uses execFile (no shell), so paths with
+      // metacharacters are safe.
+      const tryTerminals = [
+        ['x-terminal-emulator', ['-e', 'node', ...nodeArgs]],
+        ['gnome-terminal', ['--', 'node', ...nodeArgs]],
+        ['xterm', ['-e', 'node', ...nodeArgs]],
+      ];
+
+      const tryNext = (index) => {
+        if (index >= tryTerminals.length) {
+          this._log('Could not open any terminal emulator for viewer.');
+          return;
+        }
+        const [cmd, args] = tryTerminals[index];
+        execFile(cmd, args, { stdio: 'ignore' }, (err) => {
+          if (err) tryNext(index + 1);
+        });
+      };
+      tryNext(0);
+    }
+    this._log('Opening terminal viewer...');
+  }
+}