capdebug 0.2.0 → 0.3.0

package/dist/cli.js

@@ -0,0 +1,1868 @@
+'use strict';
+
+var child_process = require('child_process');
+var readline = require('readline');
+var http = require('http');
+var os = require('os');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline);
+var http__namespace = /*#__PURE__*/_interopNamespaceDefault(http);
+var os__namespace = /*#__PURE__*/_interopNamespaceDefault(os);
+
+class PairingHelper {
+  /**
+   * Creates a new pairing session with given TTL (default 5 minutes).
+   */
+  static createSession(ttlMs = 5 * 60 * 1e3) {
+    const now = Date.now();
+    return {
+      id: this.generateSessionId(),
+      createdAt: now,
+      expiresAt: now + ttlMs,
+      status: "waiting"
+    };
+  }
+  /**
+   * Generates a short, human-readable session ID (e.g. "K7P4-M2" or "7HQ2-9X").
+   */
+  static generateSessionId() {
+    const chars = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ";
+    const bytes = this.getRandomBytes(4);
+    let id = "";
+    for (let i = 0; i < 4; i++) {
+      id += chars[bytes[i] % chars.length];
+    }
+    const suffix = this.getRandomBytes(2);
+    id += "-" + chars[suffix[0] % chars.length] + chars[suffix[1] % chars.length];
+    return id;
+  }
+  /**
+   * Generates a cryptographically strong 128-bit random secret string.
+   */
+  static generateSecret() {
+    const bytes = this.getRandomBytes(16);
+    return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  /**
+   * Formats a web pairing URL where the secret is stored strictly in the URL fragment (#SECRET).
+   */
+  static formatPairingUrl(baseUrl, sessionId, secret) {
+    const cleanBase = baseUrl.replace(/\/+$/, "");
+    return `${cleanBase}/pair?s=${encodeURIComponent(sessionId)}#${secret}`;
+  }
+  /**
+   * Formats a Capacitor mobile deep link URL.
+   */
+  static formatDeepLinkUrl(sessionId, secret, signalingUrl) {
+    let url = `capdebug://pair?session=${encodeURIComponent(sessionId)}&secret=${encodeURIComponent(secret)}`;
+    if (signalingUrl) {
+      url += `&server=${encodeURIComponent(signalingUrl)}`;
+    }
+    return url;
+  }
+  /**
+   * Parses a web pairing URL or Capacitor deep-link URL into session and secret components.
+   */
+  static parseUrl(urlStr) {
+    if (!urlStr || typeof urlStr !== "string") return null;
+    try {
+      if (urlStr.startsWith("capdebug://")) {
+        const queryIdx = urlStr.indexOf("?");
+        if (queryIdx === -1) return null;
+        const search = urlStr.substring(queryIdx + 1);
+        const params = new URLSearchParams(search);
+        const sessionId2 = params.get("session") || params.get("s");
+        const secret2 = params.get("secret") || params.get("sec") || "";
+        const signalingUrl2 = params.get("server") || params.get("sig") || void 0;
+        if (sessionId2 && secret2) {
+          return { sessionId: sessionId2, secret: secret2, signalingUrl: signalingUrl2, rawUrl: urlStr };
+        }
+        return null;
+      }
+      const url = new URL(urlStr);
+      let sessionId = url.searchParams.get("s") || url.searchParams.get("session");
+      if (!sessionId && url.pathname.includes("/s/")) {
+        const parts = url.pathname.split("/s/");
+        if (parts[1]) {
+          sessionId = decodeURIComponent(parts[1].split("/")[0]);
+        }
+      }
+      let secret = url.hash.replace(/^#/, "");
+      if (!secret) {
+        secret = url.searchParams.get("secret") || url.searchParams.get("sec") || "";
+      }
+      const signalingUrl = url.searchParams.get("server") || `${url.protocol}//${url.host}`;
+      if (sessionId && secret) {
+        return {
+          sessionId: sessionId.trim(),
+          secret: secret.trim(),
+          signalingUrl,
+          rawUrl: urlStr
+        };
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  static getRandomBytes(length) {
+    const bytes = new Uint8Array(length);
+    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+      crypto.getRandomValues(bytes);
+    } else {
+      for (let i = 0; i < length; i++) {
+        bytes[i] = Math.floor(Math.random() * 256);
+      }
+    }
+    return bytes;
+  }
+}
+
+function getDesktopViewerHtml(options) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>CapDebug Remote Viewer</title>
+  <style>
+    :root {
+      --bg: #0b0f19;
+      --surface: #111827;
+      --surface-elevated: #1f293d;
+      --border: rgba(255, 255, 255, 0.08);
+      --border-focus: rgba(56, 189, 248, 0.5);
+      --accent: #38bdf8;
+      --accent-glow: rgba(56, 189, 248, 0.2);
+      --text: #f8fafc;
+      --text-muted: #94a3b8;
+      --text-dim: #64748b;
+      --green: #10b981;
+      --amber: #f59e0b;
+      --rose: #f43f5e;
+      --purple: #a855f7;
+      --blue: #3b82f6;
+    }
+    * { box-sizing: border-box; margin: 0; padding: 0; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; }
+    body {
+      background-color: var(--bg);
+      color: var(--text);
+      height: 100vh;
+      display: flex;
+      flex-direction: column;
+      overflow: hidden;
+    }
+
+    /* Header */
+    header {
+      background: var(--surface);
+      border-bottom: 1px solid var(--border);
+      padding: 12px 20px;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 16px;
+      flex-shrink: 0;
+    }
+    .brand-section {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+    }
+    .logo {
+      font-weight: 800;
+      font-size: 16px;
+      letter-spacing: -0.5px;
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      color: #fff;
+    }
+    .logo-badge {
+      background: rgba(56, 189, 248, 0.15);
+      color: var(--accent);
+      border: 1px solid rgba(56, 189, 248, 0.3);
+      padding: 2px 8px;
+      border-radius: 6px;
+      font-size: 11px;
+      font-weight: 700;
+      letter-spacing: 0.5px;
+    }
+    .status-badge {
+      display: inline-flex;
+      align-items: center;
+      gap: 6px;
+      padding: 4px 10px;
+      border-radius: 999px;
+      font-size: 12px;
+      font-weight: 600;
+      background: rgba(255, 255, 255, 0.05);
+      border: 1px solid var(--border);
+    }
+    .status-dot {
+      width: 8px;
+      height: 8px;
+      border-radius: 50%;
+      background: var(--text-dim);
+    }
+    .status-dot.waiting { background: var(--amber); box-shadow: 0 0 8px var(--amber); animation: pulse 1.5s infinite; }
+    .status-dot.connected { background: var(--green); box-shadow: 0 0 8px var(--green); }
+    .status-dot.failed { background: var(--rose); box-shadow: 0 0 8px var(--rose); }
+
+    @keyframes pulse {
+      0%, 100% { opacity: 1; transform: scale(1); }
+      50% { opacity: 0.4; transform: scale(1.3); }
+    }
+
+    .meta-metrics {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      font-size: 12px;
+      color: var(--text-muted);
+    }
+    .metric-pill {
+      background: rgba(255, 255, 255, 0.04);
+      border: 1px solid var(--border);
+      padding: 3px 8px;
+      border-radius: 6px;
+      display: flex;
+      align-items: center;
+      gap: 4px;
+    }
+    .metric-pill strong { color: var(--text); }
+
+    .header-actions {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+    .btn {
+      background: var(--surface-elevated);
+      color: var(--text);
+      border: 1px solid var(--border);
+      padding: 6px 12px;
+      border-radius: 8px;
+      font-size: 12px;
+      font-weight: 600;
+      cursor: pointer;
+      display: inline-flex;
+      align-items: center;
+      gap: 6px;
+      transition: all 0.15s;
+    }
+    .btn:hover {
+      background: rgba(255, 255, 255, 0.1);
+      border-color: rgba(255, 255, 255, 0.2);
+    }
+    .btn-primary {
+      background: linear-gradient(135deg, #0284c7, #38bdf8);
+      color: white;
+      border: none;
+    }
+    .btn-danger {
+      background: rgba(244, 63, 94, 0.15);
+      border-color: rgba(244, 63, 94, 0.3);
+      color: #fda4af;
+    }
+    .btn-danger:hover {
+      background: rgba(244, 63, 94, 0.3);
+    }
+
+    /* Subheader & Filters */
+    .controls-bar {
+      background: var(--surface);
+      border-bottom: 1px solid var(--border);
+      padding: 8px 20px;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 16px;
+      flex-shrink: 0;
+    }
+    .tabs-group {
+      display: flex;
+      align-items: center;
+      gap: 4px;
+      overflow-x: auto;
+    }
+    .tab-btn {
+      background: transparent;
+      border: none;
+      color: var(--text-muted);
+      padding: 6px 12px;
+      border-radius: 6px;
+      font-size: 13px;
+      font-weight: 600;
+      cursor: pointer;
+      transition: all 0.15s;
+      white-space: nowrap;
+    }
+    .tab-btn:hover {
+      color: var(--text);
+      background: rgba(255, 255, 255, 0.04);
+    }
+    .tab-btn.active {
+      color: var(--accent);
+      background: rgba(56, 189, 248, 0.12);
+    }
+
+    .filter-group {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+    .search-input {
+      background: var(--bg);
+      border: 1px solid var(--border);
+      color: var(--text);
+      padding: 6px 12px;
+      border-radius: 6px;
+      font-size: 12px;
+      width: 220px;
+      outline: none;
+      transition: border 0.15s;
+    }
+    .search-input:focus {
+      border-color: var(--border-focus);
+    }
+    .level-select {
+      background: var(--bg);
+      border: 1px solid var(--border);
+      color: var(--text);
+      padding: 6px 10px;
+      border-radius: 6px;
+      font-size: 12px;
+      outline: none;
+      cursor: pointer;
+    }
+
+    /* Main Container */
+    .main-content {
+      flex: 1;
+      display: flex;
+      overflow: hidden;
+      position: relative;
+    }
+
+    /* Waiting / Empty Overlay */
+    .overlay-banner {
+      position: absolute;
+      top: 0;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      background: rgba(11, 15, 25, 0.9);
+      backdrop-filter: blur(8px);
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      z-index: 50;
+      text-align: center;
+      padding: 24px;
+    }
+    .overlay-card {
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: 20px;
+      padding: 36px 32px;
+      max-width: 440px;
+      width: 100%;
+      box-shadow: 0 20px 50px rgba(0,0,0,0.5);
+    }
+    .overlay-card h2 {
+      font-size: 22px;
+      font-weight: 700;
+      margin-bottom: 8px;
+    }
+    .overlay-card p {
+      color: var(--text-muted);
+      font-size: 14px;
+      line-height: 1.5;
+      margin-bottom: 24px;
+    }
+    .session-code {
+      font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+      font-size: 20px;
+      font-weight: 700;
+      color: var(--accent);
+      background: rgba(56, 189, 248, 0.08);
+      border: 1px solid rgba(56, 189, 248, 0.25);
+      padding: 10px 16px;
+      border-radius: 12px;
+      margin-bottom: 20px;
+      display: inline-block;
+      letter-spacing: 2px;
+    }
+
+    /* Log Stream */
+    .logs-container {
+      flex: 1;
+      overflow-y: auto;
+      font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+      font-size: 12px;
+    }
+    .log-row {
+      display: flex;
+      align-items: flex-start;
+      gap: 12px;
+      padding: 8px 20px;
+      border-bottom: 1px solid rgba(255, 255, 255, 0.03);
+      transition: background 0.1s;
+      cursor: pointer;
+    }
+    .log-row:hover {
+      background: rgba(255, 255, 255, 0.02);
+    }
+    .log-row.selected {
+      background: rgba(56, 189, 248, 0.08);
+    }
+    .log-time {
+      color: var(--text-dim);
+      white-space: nowrap;
+      flex-shrink: 0;
+    }
+    .pill {
+      font-size: 10px;
+      font-weight: 700;
+      padding: 2px 6px;
+      border-radius: 4px;
+      text-transform: uppercase;
+      flex-shrink: 0;
+    }
+    .pill-source { background: rgba(255, 255, 255, 0.08); color: var(--text-muted); }
+    .pill-level-debug { background: rgba(148, 163, 184, 0.15); color: #cbd5e1; }
+    .pill-level-info { background: rgba(56, 189, 248, 0.15); color: #38bdf8; }
+    .pill-level-warn { background: rgba(245, 158, 11, 0.15); color: #f59e0b; }
+    .pill-level-error { background: rgba(244, 63, 94, 0.15); color: #f43f5e; }
+
+    .log-msg {
+      flex: 1;
+      word-break: break-word;
+      color: var(--text);
+    }
+    .log-duration {
+      color: var(--accent);
+      font-size: 11px;
+      margin-left: 8px;
+    }
+
+    /* Detail Inspector Pane */
+    .details-pane {
+      width: 420px;
+      border-left: 1px solid var(--border);
+      background: var(--surface);
+      display: flex;
+      flex-direction: column;
+      overflow: hidden;
+    }
+    .details-header {
+      padding: 12px 16px;
+      border-bottom: 1px solid var(--border);
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      font-weight: 600;
+      font-size: 13px;
+    }
+    .details-body {
+      flex: 1;
+      overflow-y: auto;
+      padding: 16px;
+    }
+    .json-tree {
+      background: var(--bg);
+      border: 1px solid var(--border);
+      border-radius: 8px;
+      padding: 12px;
+      font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+      font-size: 12px;
+      color: #cbd5e1;
+      white-space: pre-wrap;
+      word-break: break-all;
+    }
+
+    /* Diagnostics Drawer */
+    .diag-modal {
+      display: none;
+      position: fixed;
+      top: 50%;
+      left: 50%;
+      transform: translate(-50%, -50%);
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: 16px;
+      padding: 24px;
+      width: 500px;
+      max-width: 90vw;
+      box-shadow: 0 20px 60px rgba(0,0,0,0.7);
+      z-index: 100;
+    }
+    .diag-modal.show { display: block; }
+    .diag-grid {
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 12px;
+      margin-top: 16px;
+      font-size: 13px;
+    }
+    .diag-item {
+      background: var(--bg);
+      border: 1px solid var(--border);
+      padding: 10px 12px;
+      border-radius: 8px;
+    }
+    .diag-label { color: var(--text-dim); font-size: 11px; text-transform: uppercase; margin-bottom: 4px; }
+    .diag-val { font-weight: 600; color: var(--text); }
+  </style>
+</head>
+<body>
+
+  <!-- Top Bar -->
+  <header>
+    <div class="brand-section">
+      <div class="logo">
+        CapDebug
+        <span class="logo-badge">DESKTOP</span>
+      </div>
+      <div class="status-badge">
+        <span class="status-dot waiting" id="statusDot"></span>
+        <span id="statusText">Waiting for device...</span>
+      </div>
+    </div>
+
+    <div class="meta-metrics">
+      <div class="metric-pill">Device: <strong id="metricDevice">\u2014</strong></div>
+      <div class="metric-pill">Route: <strong id="metricRoute">\u2014</strong></div>
+      <div class="metric-pill">RTT: <strong id="metricRtt">\u2014</strong></div>
+      <div class="metric-pill">Events: <strong id="metricEvents">0</strong></div>
+      <div class="metric-pill" id="droppedPill" style="display:none; color:var(--amber);">Dropped: <strong id="metricDropped">0</strong></div>
+    </div>
+
+    <div class="header-actions">
+      <button class="btn" id="btnPause">\u23F8 Pause</button>
+      <button class="btn" id="btnClear">\u{1F9F9} Clear</button>
+      <button class="btn" id="btnSnapshot">\u{1F4F8} Snapshot</button>
+      <button class="btn" id="btnDiag">\u{1F4CA} Diag</button>
+    </div>
+  </header>
+
+  <!-- Subheader Filters -->
+  <div class="controls-bar">
+    <div class="tabs-group" id="tabsGroup">
+      <button class="tab-btn active" data-source="all">All</button>
+      <button class="tab-btn" data-source="console">Console</button>
+      <button class="tab-btn" data-source="errors">Errors</button>
+      <button class="tab-btn" data-source="network">Network</button>
+      <button class="tab-btn" data-source="native">Native</button>
+      <button class="tab-btn" data-source="custom">Custom</button>
+      <button class="tab-btn" data-source="bridge">Bridge</button>
+    </div>
+
+    <div class="filter-group">
+      <input type="text" class="search-input" id="searchInput" placeholder="Filter message or type...">
+      <select class="level-select" id="levelSelect">
+        <option value="all">All Levels</option>
+        <option value="debug">Debug</option>
+        <option value="info">Info</option>
+        <option value="warn">Warn</option>
+        <option value="error">Error</option>
+      </select>
+    </div>
+  </div>
+
+  <!-- Content -->
+  <div class="main-content">
+    <!-- Waiting Overlay -->
+    <div class="overlay-banner" id="waitingOverlay">
+      <div class="overlay-card">
+        <h2>Scan Terminal QR Code</h2>
+        <p>Point your mobile camera at the terminal to connect CapDebug via WebRTC DataChannel.</p>
+        <div class="session-code">${options.sessionId}</div>
+        <p style="font-size:12px; margin-bottom:0;">Session active for 5 minutes. Handshake will initiate automatically upon scan.</p>
+      </div>
+    </div>
+
+    <!-- Logs Container -->
+    <div class="logs-container" id="logsContainer"></div>
+
+    <!-- Details Pane -->
+    <div class="details-pane" id="detailsPane" style="display:none;">
+      <div class="details-header">
+        <span>Event Details</span>
+        <button class="btn" id="btnCloseDetails">\u2715</button>
+      </div>
+      <div class="details-body" id="detailsBody"></div>
+    </div>
+  </div>
+
+  <!-- Diagnostics Modal -->
+  <div class="diag-modal" id="diagModal">
+    <div style="display:flex; justify-content:space-between; align-items:center; margin-bottom:12px;">
+      <h3 style="font-size:16px;">WebRTC Diagnostics</h3>
+      <button class="btn" id="btnCloseDiag">\u2715</button>
+    </div>
+    <div class="diag-grid">
+      <div class="diag-item"><div class="diag-label">Session ID</div><div class="diag-val">${options.sessionId}</div></div>
+      <div class="diag-item"><div class="diag-label">Transport</div><div class="diag-val">WebRTC DataChannel</div></div>
+      <div class="diag-item"><div class="diag-label">ICE State</div><div class="diag-val" id="diagIceState">new</div></div>
+      <div class="diag-item"><div class="diag-label">Signaling State</div><div class="diag-val" id="diagSigState">stable</div></div>
+      <div class="diag-item"><div class="diag-label">Route Type</div><div class="diag-val" id="diagRoute">Unknown</div></div>
+      <div class="diag-item"><div class="diag-label">Candidate</div><div class="diag-val" id="diagCandidate">Host</div></div>
+      <div class="diag-item"><div class="diag-label">Protocol</div><div class="diag-val" id="diagProtocol">UDP</div></div>
+      <div class="diag-item"><div class="diag-label">Latency (RTT)</div><div class="diag-val" id="diagRtt">\u2014</div></div>
+      <div class="diag-item"><div class="diag-label">Events Received</div><div class="diag-val" id="diagReceived">0</div></div>
+      <div class="diag-item"><div class="diag-label">Dropped (Backpressure)</div><div class="diag-val" id="diagDropped">0</div></div>
+    </div>
+  </div>
+
+  <script>
+    (function() {
+      const sessionId = "${options.sessionId}";
+      const secret = "${options.secret}";
+      const signalingUrl = "${options.signalingUrl}";
+
+      let pc = null;
+      let eventsChannel = null;
+      let controlChannel = null;
+      let sse = null;
+
+      let events = [];
+      let selectedEvent = null;
+      let activeSourceFilter = 'all';
+      let activeLevelFilter = 'all';
+      let searchQuery = '';
+      let isPaused = false;
+      let totalReceived = 0;
+      let droppedCount = 0;
+      let rttMs = 0;
+      let pingInterval = null;
+
+      // DOM Elements
+      const statusDot = document.getElementById('statusDot');
+      const statusText = document.getElementById('statusText');
+      const metricDevice = document.getElementById('metricDevice');
+      const metricRoute = document.getElementById('metricRoute');
+      const metricRtt = document.getElementById('metricRtt');
+      const metricEvents = document.getElementById('metricEvents');
+      const metricDropped = document.getElementById('metricDropped');
+      const droppedPill = document.getElementById('droppedPill');
+      const waitingOverlay = document.getElementById('waitingOverlay');
+      const logsContainer = document.getElementById('logsContainer');
+      const detailsPane = document.getElementById('detailsPane');
+      const detailsBody = document.getElementById('detailsBody');
+      const btnCloseDetails = document.getElementById('btnCloseDetails');
+      const btnPause = document.getElementById('btnPause');
+      const btnClear = document.getElementById('btnClear');
+      const btnSnapshot = document.getElementById('btnSnapshot');
+      const btnDiag = document.getElementById('btnDiag');
+      const diagModal = document.getElementById('diagModal');
+      const btnCloseDiag = document.getElementById('btnCloseDiag');
+
+      // --- WebRTC Host Negotiation ---
+      function initSignaling() {
+        const sseUrl = signalingUrl + '/api/pair/events/' + encodeURIComponent(sessionId) + '?secret=' + encodeURIComponent(secret);
+        sse = new EventSource(sseUrl);
+
+        sse.onmessage = function(e) {
+          try {
+            const msg = JSON.parse(e.data);
+            handleSignaling(msg);
+          } catch(err) {
+            console.error('[Signaling] Parse error:', err);
+          }
+        };
+
+        sse.onerror = function() {
+          // SSE connection state
+        };
+      }
+
+      async function sendSignaling(msg) {
+        try {
+          await fetch(signalingUrl + '/api/pair/signal', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              sessionId: sessionId,
+              secret: secret,
+              sender: 'host',
+              ...msg
+            })
+          });
+        } catch(err) {
+          console.error('[Signaling] Send error:', err);
+        }
+      }
+
+      async function handleSignaling(msg) {
+        if (msg.type === 'peer-joined') {
+          // Peer scanned QR and joined signaling session!
+          // NOW we create RTCPeerConnection and offer (delayed handshake invariant)
+          statusText.innerText = 'Peer joined! Negotiating...';
+          await startWebRTCHandshake();
+        } else if (msg.type === 'answer') {
+          if (pc) {
+            await pc.setRemoteDescription(new RTCSessionDescription(msg.payload));
+          }
+        } else if (msg.type === 'ice-candidate') {
+          if (pc && msg.payload) {
+            try {
+              await pc.addIceCandidate(new RTCIceCandidate(msg.payload));
+            } catch(e) {
+              console.warn('ICE Candidate add error:', e);
+            }
+          }
+        } else if (msg.type === 'disconnect') {
+          setDisconnected();
+        }
+      }
+
+      async function startWebRTCHandshake() {
+        pc = new RTCPeerConnection({
+          iceServers: [
+            { urls: 'stun:stun.l.google.com:19302' },
+            { urls: 'stun:global.stun.twilio.com:3478' }
+          ]
+        });
+
+        pc.onicecandidate = function(event) {
+          if (event.candidate) {
+            sendSignaling({
+              type: 'ice-candidate',
+              payload: event.candidate.toJSON()
+            });
+          }
+        };
+
+        pc.onconnectionstatechange = function() {
+          document.getElementById('diagIceState').innerText = pc.iceConnectionState;
+          document.getElementById('diagSigState').innerText = pc.signalingState;
+
+          if (pc.connectionState === 'connected') {
+            setConnected();
+          } else if (pc.connectionState === 'failed' || pc.connectionState === 'closed') {
+            setDisconnected();
+          }
+        };
+
+        // Create DataChannels
+        eventsChannel = pc.createDataChannel('events', { ordered: true });
+        controlChannel = pc.createDataChannel('control', { ordered: true });
+
+        setupDataChannels();
+
+        const offer = await pc.createOffer();
+        await pc.setLocalDescription(offer);
+
+        await sendSignaling({
+          type: 'offer',
+          payload: offer
+        });
+      }
+
+      function setupDataChannels() {
+        eventsChannel.onopen = checkConnected;
+        controlChannel.onopen = checkConnected;
+
+        eventsChannel.onmessage = function(e) {
+          if (typeof e.data !== 'string') return;
+          try {
+            const parsed = JSON.parse(e.data);
+            if (parsed.type === 'event' && parsed.event) {
+              appendEvent(parsed.event);
+            } else if (parsed.type === 'events-batch' && Array.isArray(parsed.events)) {
+              parsed.events.forEach(appendEvent);
+            }
+          } catch(err) {
+            console.error('DataChannel parse error:', err);
+          }
+        };
+
+        controlChannel.onmessage = function(e) {
+          try {
+            const parsed = JSON.parse(e.data);
+            if (parsed.type === 'hello') {
+              metricDevice.innerText = parsed.payload?.deviceName || 'Mobile Device';
+              if (parsed.payload?.platform) {
+                metricDevice.innerText += ' (' + parsed.payload.platform + ')';
+              }
+              controlChannel.send(JSON.stringify({ v: 1, type: 'hello-ack' }));
+            } else if (parsed.type === 'pong') {
+              const pingTime = parsed.payload?.pingTimestamp || parsed.timestamp;
+              if (pingTime) {
+                rttMs = Math.max(1, Date.now() - pingTime);
+                metricRtt.innerText = rttMs + ' ms';
+                document.getElementById('diagRtt').innerText = rttMs + ' ms';
+              }
+            }
+          } catch(err) {
+            console.error('Control message error:', err);
+          }
+        };
+      }
+
+      function checkConnected() {
+        if (eventsChannel && eventsChannel.readyState === 'open' &&
+            controlChannel && controlChannel.readyState === 'open') {
+          setConnected();
+        }
+      }
+
+      function setConnected() {
+        statusDot.className = 'status-dot connected';
+        statusText.innerText = 'Connected';
+        waitingOverlay.style.display = 'none';
+
+        // Query Stats
+        updateStats();
+        if (!pingInterval) {
+          pingInterval = setInterval(function() {
+            if (controlChannel && controlChannel.readyState === 'open') {
+              controlChannel.send(JSON.stringify({ v: 1, type: 'ping', timestamp: Date.now() }));
+            }
+            updateStats();
+          }, 2000);
+        }
+      }
+
+      function setDisconnected() {
+        statusDot.className = 'status-dot failed';
+        statusText.innerText = 'Disconnected';
+        if (pingInterval) {
+          clearInterval(pingInterval);
+          pingInterval = null;
+        }
+      }
+
+      async function updateStats() {
+        if (!pc) return;
+        try {
+          const stats = await pc.getStats();
+          stats.forEach(function(report) {
+            if (report.type === 'candidate-pair' && (report.selected || report.state === 'succeeded')) {
+              const local = stats.get(report.localCandidateId);
+              if (local) {
+                const cType = local.candidateType || 'host';
+                document.getElementById('diagCandidate').innerText = cType;
+                document.getElementById('diagProtocol').innerText = local.protocol || 'UDP';
+                const route = cType === 'host' ? 'Direct / LAN' : (cType === 'relay' ? 'Relay / TURN' : 'STUN / WAN');
+                metricRoute.innerText = route;
+                document.getElementById('diagRoute').innerText = route;
+              }
+            }
+          });
+        } catch(e) {}
+      }
+
+      // --- UI & Event Rendering ---
+      function appendEvent(ev) {
+        if (isPaused) return;
+        totalReceived++;
+        events.push(ev);
+        metricEvents.innerText = totalReceived;
+        document.getElementById('diagReceived').innerText = totalReceived;
+
+        if (matchesFilter(ev)) {
+          renderLogRow(ev);
+        }
+      }
+
+      function matchesFilter(ev) {
+        if (activeSourceFilter !== 'all') {
+          if (activeSourceFilter === 'custom' && ev.source !== 'custom') return false;
+          if (activeSourceFilter !== 'custom' && ev.source !== activeSourceFilter) return false;
+        }
+        if (activeLevelFilter !== 'all' && ev.level !== activeLevelFilter) {
+          return false;
+        }
+        if (searchQuery) {
+          const q = searchQuery.toLowerCase();
+          const matchMsg = ev.message && ev.message.toLowerCase().includes(q);
+          const matchType = ev.type && ev.type.toLowerCase().includes(q);
+          if (!matchMsg && !matchType) return false;
+        }
+        return true;
+      }
+
+      function renderLogRow(ev) {
+        const row = document.createElement('div');
+        row.className = 'log-row';
+        row.dataset.id = ev.id;
+
+        const time = new Date(ev.timestamp).toLocaleTimeString();
+        const durationHtml = ev.duration ? '<span class="log-duration">(' + Math.round(ev.duration) + 'ms)</span>' : '';
+
+        row.innerHTML = '<span class="log-time">' + time + '</span>' +
+          '<span class="pill pill-source">' + (ev.source || 'web') + '</span>' +
+          '<span class="pill pill-level-' + (ev.level || 'info') + '">' + (ev.level || 'info') + '</span>' +
+          '<span class="log-msg"><strong>' + (ev.type ? ev.type + ': ' : '') + '</strong>' + escapeHtml(ev.message || '') + durationHtml + '</span>';
+
+        row.addEventListener('click', function() {
+          showDetails(ev, row);
+        });
+
+        logsContainer.appendChild(row);
+        logsContainer.scrollTop = logsContainer.scrollHeight;
+      }
+
+      function refreshLogs() {
+        logsContainer.innerHTML = '';
+        events.filter(matchesFilter).forEach(renderLogRow);
+      }
+
+      function showDetails(ev, rowElem) {
+        document.querySelectorAll('.log-row.selected').forEach(function(el) { el.classList.remove('selected'); });
+        if (rowElem) rowElem.classList.add('selected');
+
+        selectedEvent = ev;
+        detailsPane.style.display = 'flex';
+
+        detailsBody.innerHTML = '<div style="margin-bottom:12px;">' +
+          '<div style="font-size:11px; color:var(--text-dim); text-transform:uppercase;">Type</div>' +
+          '<div style="font-weight:700; font-size:14px; margin-top:2px;">' + (ev.type || 'generic') + '</div>' +
+          '</div>' +
+          '<div style="margin-bottom:12px;">' +
+          '<div style="font-size:11px; color:var(--text-dim); text-transform:uppercase;">Message</div>' +
+          '<div style="margin-top:2px; font-size:13px; color:#cbd5e1;">' + escapeHtml(ev.message || '') + '</div>' +
+          '</div>' +
+          '<div style="margin-bottom:12px;">' +
+          '<div style="font-size:11px; color:var(--text-dim); text-transform:uppercase;">Payload Data</div>' +
+          '<pre class="json-tree">' + escapeHtml(JSON.stringify(ev.data || {}, null, 2)) + '</pre>' +
+          '</div>';
+      }
+
+      function escapeHtml(str) {
+        return String(str)
+          .replace(/&/g, '&amp;')
+          .replace(/</g, '&lt;')
+          .replace(/>/g, '&gt;')
+          .replace(/"/g, '&quot;');
+      }
+
+      // --- Button Handlers ---
+      btnPause.addEventListener('click', function() {
+        isPaused = !isPaused;
+        btnPause.innerText = isPaused ? '\u25B6 Resume' : '\u23F8 Pause';
+        if (controlChannel && controlChannel.readyState === 'open') {
+          controlChannel.send(JSON.stringify({
+            v: 1,
+            type: 'control',
+            command: { type: isPaused ? 'pause' : 'resume' }
+          }));
+        }
+      });
+
+      btnClear.addEventListener('click', function() {
+        events = [];
+        logsContainer.innerHTML = '';
+        metricEvents.innerText = '0';
+        totalReceived = 0;
+        if (controlChannel && controlChannel.readyState === 'open') {
+          controlChannel.send(JSON.stringify({
+            v: 1,
+            type: 'control',
+            command: { type: 'clear' }
+          }));
+        }
+      });
+
+      btnSnapshot.addEventListener('click', function() {
+        if (controlChannel && controlChannel.readyState === 'open') {
+          controlChannel.send(JSON.stringify({
+            v: 1,
+            type: 'control',
+            command: { type: 'snapshot.request' }
+          }));
+        }
+      });
+
+      btnDiag.addEventListener('click', function() { diagModal.classList.add('show'); });
+      btnCloseDiag.addEventListener('click', function() { diagModal.classList.remove('show'); });
+      btnCloseDetails.addEventListener('click', function() { detailsPane.style.display = 'none'; });
+
+      // Tab filtering
+      document.getElementById('tabsGroup').addEventListener('click', function(e) {
+        if (e.target.classList.contains('tab-btn')) {
+          document.querySelectorAll('.tab-btn').forEach(function(btn) { btn.classList.remove('active'); });
+          e.target.classList.add('active');
+          activeSourceFilter = e.target.dataset.source;
+          refreshLogs();
+        }
+      });
+
+      // Search & Level
+      document.getElementById('searchInput').addEventListener('input', function(e) {
+        searchQuery = e.target.value;
+        refreshLogs();
+      });
+
+      document.getElementById('levelSelect').addEventListener('change', function(e) {
+        activeLevelFilter = e.target.value;
+        refreshLogs();
+      });
+
+      // Start SSE signaling listener
+      initSignaling();
+    })();
+  <\/script>
+</body>
+</html>`;
+}
+
+function getPairingPageHtml(options) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
+  <title>CapDebug Remote Pairing</title>
+  <style>
+    :root {
+      --bg: #090d16;
+      --card-bg: rgba(22, 30, 49, 0.85);
+      --border: rgba(255, 255, 255, 0.1);
+      --accent: #38bdf8;
+      --accent-glow: rgba(56, 189, 248, 0.25);
+      --text: #f1f5f9;
+      --text-muted: #94a3b8;
+      --green: #10b981;
+    }
+    * { box-sizing: border-box; margin: 0; padding: 0; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif; }
+    body {
+      background: radial-gradient(circle at top, #1e293b 0%, var(--bg) 100%);
+      color: var(--text);
+      min-height: 100vh;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      padding: 24px;
+      text-align: center;
+    }
+    .card {
+      background: var(--card-bg);
+      border: 1px solid var(--border);
+      border-radius: 24px;
+      padding: 32px 24px;
+      max-width: 400px;
+      width: 100%;
+      box-shadow: 0 20px 40px rgba(0,0,0,0.5), 0 0 40px var(--accent-glow);
+      backdrop-filter: blur(12px);
+      animation: fadeIn 0.4s ease-out;
+    }
+    @keyframes fadeIn {
+      from { opacity: 0; transform: translateY(16px); }
+      to { opacity: 1; transform: translateY(0); }
+    }
+    .logo-badge {
+      display: inline-flex;
+      align-items: center;
+      gap: 8px;
+      padding: 6px 14px;
+      background: rgba(56, 189, 248, 0.12);
+      border: 1px solid rgba(56, 189, 248, 0.3);
+      border-radius: 999px;
+      color: var(--accent);
+      font-weight: 700;
+      font-size: 13px;
+      letter-spacing: 0.5px;
+      margin-bottom: 20px;
+    }
+    .pulse-dot {
+      width: 8px;
+      height: 8px;
+      border-radius: 50%;
+      background: var(--accent);
+      box-shadow: 0 0 10px var(--accent);
+      animation: pulse 1.5s infinite;
+    }
+    @keyframes pulse {
+      0%, 100% { transform: scale(1); opacity: 1; }
+      50% { transform: scale(1.6); opacity: 0.6; }
+    }
+    h1 {
+      font-size: 24px;
+      font-weight: 800;
+      margin-bottom: 8px;
+      letter-spacing: -0.5px;
+    }
+    p {
+      color: var(--text-muted);
+      font-size: 14px;
+      line-height: 1.5;
+      margin-bottom: 24px;
+    }
+    .session-pill {
+      font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+      background: rgba(0,0,0,0.4);
+      border: 1px solid var(--border);
+      padding: 10px 16px;
+      border-radius: 12px;
+      font-size: 18px;
+      font-weight: 700;
+      color: #38bdf8;
+      letter-spacing: 2px;
+      margin-bottom: 24px;
+      display: inline-block;
+    }
+    .btn {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      width: 100%;
+      padding: 14px 20px;
+      border-radius: 14px;
+      font-size: 15px;
+      font-weight: 600;
+      cursor: pointer;
+      text-decoration: none;
+      transition: all 0.2s;
+      border: none;
+      margin-bottom: 12px;
+    }
+    .btn-primary {
+      background: linear-gradient(135deg, #0284c7, #38bdf8);
+      color: white;
+      box-shadow: 0 4px 16px rgba(56, 189, 248, 0.35);
+    }
+    .btn-primary:active {
+      transform: scale(0.98);
+    }
+    .btn-secondary {
+      background: rgba(255, 255, 255, 0.06);
+      color: var(--text);
+      border: 1px solid var(--border);
+    }
+    .status-text {
+      font-size: 12px;
+      color: var(--text-muted);
+      margin-top: 16px;
+    }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <div class="logo-badge">
+      <span class="pulse-dot"></span>
+      CAPDEBUG REMOTE
+    </div>
+    <h1>Pairing with Desktop</h1>
+    <p>Opening CapDebug session on your device...</p>
+
+    <div class="session-pill" id="sessionDisplay">${options.sessionId}</div>
+
+    <a id="deepLinkBtn" href="#" class="btn btn-primary">Open in Capacitor App</a>
+    <button id="browserBtn" class="btn btn-secondary">Connect in Browser</button>
+
+    <div class="status-text" id="statusMessage">Redirecting to app...</div>
+  </div>
+
+  <script>
+    (function() {
+      const sessionId = "${options.sessionId}";
+      const signalingUrl = "${options.signalingUrl}";
+      const secret = window.location.hash ? window.location.hash.substring(1) : "";
+
+      const deepLinkUrl = "capdebug://pair?session=" + encodeURIComponent(sessionId) +
+        "&secret=" + encodeURIComponent(secret) +
+        "&signaling=" + encodeURIComponent(signalingUrl);
+
+      const deepLinkBtn = document.getElementById("deepLinkBtn");
+      const browserBtn = document.getElementById("browserBtn");
+      const statusMsg = document.getElementById("statusMessage");
+
+      deepLinkBtn.href = deepLinkUrl;
+
+      // Auto redirect to deep link after short pause
+      setTimeout(function() {
+        window.location.href = deepLinkUrl;
+      }, 400);
+
+      // Handle in-browser pairing if user stays on page
+      browserBtn.addEventListener("click", function() {
+        statusMsg.innerText = "Connecting browser session...";
+        browserBtn.disabled = true;
+        // In-browser mobile web session joining
+        if (window.opener || window.parent) {
+          window.postMessage({ type: "capdebug:pair", sessionId: sessionId, secret: secret }, "*");
+        }
+        statusMsg.innerText = "If using Capacitor app, tap 'Open in Capacitor App' above.";
+      });
+    })();
+  <\/script>
+</body>
+</html>`;
+}
+
+class CapDebugCliServer {
+  server = null;
+  sessions = /* @__PURE__ */ new Map();
+  port;
+  host;
+  constructor(options = {}) {
+    this.port = options.port || 4783;
+    this.host = options.host || "0.0.0.0";
+  }
+  getLanIp() {
+    const interfaces = os__namespace.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+      for (const iface of interfaces[name] || []) {
+        if (iface.family === "IPv4" && !iface.internal) {
+          return iface.address;
+        }
+      }
+    }
+    return "127.0.0.1";
+  }
+  getLocalViewerUrl() {
+    return `http://localhost:${this.port}`;
+  }
+  getMobilePairingUrl(sessionId, secret) {
+    const lanIp = this.getLanIp();
+    return PairingHelper.formatPairingUrl(
+      `http://${lanIp}:${this.port}`,
+      sessionId,
+      secret
+    );
+  }
+  createSession() {
+    const session = PairingHelper.createSession(5 * 60 * 1e3);
+    const secret = PairingHelper.generateSecret();
+    this.sessions.set(session.id, {
+      session,
+      secret,
+      subscribers: /* @__PURE__ */ new Set(),
+      peerJoined: false
+    });
+    return { session, secret };
+  }
+  getSession(id) {
+    const s = this.sessions.get(id);
+    if (!s) return void 0;
+    if (Date.now() > s.session.expiresAt) {
+      s.session.status = "expired";
+    }
+    return s;
+  }
+  async start() {
+    return new Promise((resolve, reject) => {
+      this.server = http__namespace.createServer((req, res) => {
+        this.handleRequest(req, res);
+      });
+      this.server.listen(this.port, this.host, () => {
+        const addr = this.server?.address();
+        const actualPort = typeof addr === "object" && addr ? addr.port : this.port;
+        this.port = actualPort;
+        resolve({ port: this.port, lanIp: this.getLanIp() });
+      });
+      this.server.on("error", (err) => {
+        reject(err);
+      });
+    });
+  }
+  stop() {
+    return new Promise((resolve) => {
+      for (const s of this.sessions.values()) {
+        for (const sub of s.subscribers) {
+          try {
+            sub.end();
+          } catch {
+          }
+        }
+        s.subscribers.clear();
+      }
+      if (this.server) {
+        this.server.close(() => {
+          this.server = null;
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+  handleRequest(req, res) {
+    const parsedUrl = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+    const pathname = parsedUrl.pathname;
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    if (pathname === "/" && req.method === "GET") {
+      const sessionId = parsedUrl.searchParams.get("s") || Array.from(this.sessions.keys())[0] || "";
+      const sessionInfo = this.getSession(sessionId) || Array.from(this.sessions.values())[0];
+      const html = getDesktopViewerHtml({
+        sessionId: sessionInfo ? sessionInfo.session.id : "",
+        secret: sessionInfo ? sessionInfo.secret : "",
+        signalingUrl: `http://localhost:${this.port}`
+      });
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(html);
+      return;
+    }
+    if (pathname === "/pair" && req.method === "GET") {
+      const sessionId = parsedUrl.searchParams.get("s") || "";
+      const lanIp = this.getLanIp();
+      const html = getPairingPageHtml({
+        sessionId,
+        signalingUrl: `http://${lanIp}:${this.port}`
+      });
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(html);
+      return;
+    }
+    if (pathname === "/api/pair/create" && req.method === "POST") {
+      const result = this.createSession();
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true, session: result.session, secret: result.secret }));
+      return;
+    }
+    if (pathname === "/api/pair/join" && req.method === "POST") {
+      this.readJsonBody(req, (err, body) => {
+        if (err || !body?.sessionId || !body?.secret) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: false, error: "Invalid join payload" }));
+          return;
+        }
+        const sessionInfo = this.getSession(body.sessionId);
+        if (!sessionInfo) {
+          res.writeHead(404, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: false, error: "Session not found" }));
+          return;
+        }
+        if (sessionInfo.session.status === "expired") {
+          res.writeHead(410, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: false, error: "Session expired" }));
+          return;
+        }
+        if (sessionInfo.secret !== body.secret) {
+          res.writeHead(403, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: false, error: "Invalid secret" }));
+          return;
+        }
+        sessionInfo.session.status = "peer-joined";
+        sessionInfo.peerJoined = true;
+        this.broadcast(sessionInfo, {
+          sessionId: sessionInfo.session.id,
+          secret: sessionInfo.secret,
+          type: "peer-joined",
+          sender: "peer"
+        });
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, session: sessionInfo.session }));
+      });
+      return;
+    }
+    if (pathname === "/api/pair/signal" && req.method === "POST") {
+      this.readJsonBody(req, (err, body) => {
+        if (err || !body?.sessionId || !body?.secret || !body?.type) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: false, error: "Invalid signal payload" }));
+          return;
+        }
+        const sessionInfo = this.getSession(body.sessionId);
+        if (!sessionInfo || sessionInfo.secret !== body.secret) {
+          res.writeHead(403, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: false, error: "Invalid session or secret" }));
+          return;
+        }
+        this.broadcast(sessionInfo, body);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true }));
+      });
+      return;
+    }
+    if (pathname.startsWith("/api/pair/events/") && req.method === "GET") {
+      const sessionId = pathname.replace("/api/pair/events/", "");
+      const secret = parsedUrl.searchParams.get("secret") || "";
+      const sessionInfo = this.getSession(sessionId);
+      if (!sessionInfo || secret && sessionInfo.secret !== secret) {
+        res.writeHead(403, { "Content-Type": "text/plain" });
+        res.end("Unauthorized");
+        return;
+      }
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+      });
+      res.write(": ok\n\n");
+      sessionInfo.subscribers.add(res);
+      req.on("close", () => {
+        sessionInfo.subscribers.delete(res);
+      });
+      return;
+    }
+    if (pathname.startsWith("/api/pair/status/") && req.method === "GET") {
+      const sessionId = pathname.replace("/api/pair/status/", "");
+      const sessionInfo = this.getSession(sessionId);
+      if (!sessionInfo) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: false, error: "Session not found" }));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true, session: sessionInfo.session }));
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("Not Found");
+  }
+  broadcast(sessionInfo, message) {
+    const data = `data: ${JSON.stringify(message)}
+
+`;
+    for (const sub of sessionInfo.subscribers) {
+      try {
+        sub.write(data);
+      } catch {
+        sessionInfo.subscribers.delete(sub);
+      }
+    }
+  }
+  readJsonBody(req, cb) {
+    let raw = "";
+    req.on("data", (chunk) => {
+      raw += chunk;
+      if (raw.length > 1024 * 1024) {
+        req.destroy();
+      }
+    });
+    req.on("end", () => {
+      try {
+        const parsed = JSON.parse(raw || "{}");
+        cb(null, parsed);
+      } catch (err) {
+        cb(err, null);
+      }
+    });
+    req.on("error", (err) => cb(err, null));
+  }
+}
+
+const EXP_TABLE = new Uint8Array(512);
+const LOG_TABLE = new Uint8Array(256);
+(function initGF() {
+  let x = 1;
+  for (let i = 0; i < 255; i++) {
+    EXP_TABLE[i] = x;
+    EXP_TABLE[i + 255] = x;
+    LOG_TABLE[x] = i;
+    x = x << 1 ^ (x >= 128 ? 285 : 0);
+  }
+})();
+function gfMul(x, y) {
+  if (x === 0 || y === 0) return 0;
+  return EXP_TABLE[LOG_TABLE[x] + LOG_TABLE[y]];
+}
+function polyMul(p, q) {
+  const result = new Array(p.length + q.length - 1).fill(0);
+  for (let i = 0; i < p.length; i++) {
+    for (let j = 0; j < q.length; j++) {
+      result[i + j] ^= gfMul(p[i], q[j]);
+    }
+  }
+  return result;
+}
+function rsGeneratorPoly(degree) {
+  let g = [1];
+  for (let i = 0; i < degree; i++) {
+    g = polyMul(g, [1, EXP_TABLE[i]]);
+  }
+  return g;
+}
+function rsCompute(data, ecCount) {
+  const gen = rsGeneratorPoly(ecCount);
+  const msg = new Array(data.length + ecCount).fill(0);
+  for (let i = 0; i < data.length; i++) {
+    msg[i] = data[i];
+  }
+  for (let i = 0; i < data.length; i++) {
+    const lead = msg[i];
+    if (lead !== 0) {
+      for (let j = 0; j < gen.length; j++) {
+        msg[i + j] ^= gfMul(gen[j], lead);
+      }
+    }
+  }
+  const out = new Uint8Array(ecCount);
+  for (let i = 0; i < ecCount; i++) {
+    out[i] = msg[data.length + i];
+  }
+  return out;
+}
+const QR_SPECS = [
+  { version: 2, size: 25, totalBytes: 44, dataBytes: 34, ecBytes: 10, alignPos: [6, 18] },
+  { version: 3, size: 29, totalBytes: 70, dataBytes: 55, ecBytes: 15, alignPos: [6, 22] },
+  { version: 4, size: 33, totalBytes: 100, dataBytes: 80, ecBytes: 20, alignPos: [6, 26] },
+  { version: 5, size: 37, totalBytes: 134, dataBytes: 108, ecBytes: 26, alignPos: [6, 30] },
+  { version: 6, size: 41, totalBytes: 172, dataBytes: 136, ecBytes: 36, alignPos: [6, 34] }
+];
+class TerminalQRCode {
+  /**
+   * Generates a 2D boolean grid (true = dark/black, false = light/white) for the given text.
+   */
+  static generateMatrix(text) {
+    const textBytes = new TextEncoder().encode(text);
+    const spec = QR_SPECS.find((s) => textBytes.length + 3 <= s.dataBytes) || QR_SPECS[QR_SPECS.length - 1];
+    const dataBits = [];
+    dataBits.push(0, 1, 0, 0);
+    const len = textBytes.length;
+    for (let i = 7; i >= 0; i--) {
+      dataBits.push(len >> i & 1);
+    }
+    for (let i = 0; i < len; i++) {
+      const b = textBytes[i];
+      for (let bit = 7; bit >= 0; bit--) {
+        dataBits.push(b >> bit & 1);
+      }
+    }
+    const totalDataBits = spec.dataBytes * 8;
+    for (let i = 0; i < 4 && dataBits.length < totalDataBits; i++) {
+      dataBits.push(0);
+    }
+    while (dataBits.length % 8 !== 0) {
+      dataBits.push(0);
+    }
+    const padBytes = [236, 17];
+    let padIdx = 0;
+    while (dataBits.length < totalDataBits) {
+      const pad = padBytes[padIdx % 2];
+      for (let bit = 7; bit >= 0; bit--) {
+        dataBits.push(pad >> bit & 1);
+      }
+      padIdx++;
+    }
+    const dataBytes = new Uint8Array(spec.dataBytes);
+    for (let i = 0; i < spec.dataBytes; i++) {
+      let b = 0;
+      for (let bit = 0; bit < 8; bit++) {
+        b = b << 1 | dataBits[i * 8 + bit];
+      }
+      dataBytes[i] = b;
+    }
+    const ecBytes = rsCompute(dataBytes, spec.ecBytes);
+    const finalCodewords = new Uint8Array(spec.totalBytes);
+    finalCodewords.set(dataBytes, 0);
+    finalCodewords.set(ecBytes, spec.dataBytes);
+    const size = spec.size;
+    const matrix = Array.from(
+      { length: size },
+      () => Array.from({ length: size }, () => null)
+    );
+    drawFinder(matrix, 0, 0);
+    drawFinder(matrix, size - 7, 0);
+    drawFinder(matrix, 0, size - 7);
+    for (let i = 8; i < size - 8; i++) {
+      const val = i % 2 === 0;
+      if (matrix[6][i] === null) matrix[6][i] = val;
+      if (matrix[i][6] === null) matrix[i][6] = val;
+    }
+    if (spec.alignPos.length > 0) {
+      for (const r of spec.alignPos) {
+        for (const c of spec.alignPos) {
+          if (r === 6 && c === 6 || r === 6 && c === size - 7 || r === size - 7 && c === 6) {
+            continue;
+          }
+          drawAlignment(matrix, r, c);
+        }
+      }
+    }
+    matrix[size - 8][8] = true;
+    reserveFormatInfo(matrix, size);
+    placeDataBits(matrix, size, finalCodewords);
+    applyMask(matrix, size);
+    writeFormatInfo(matrix, size, 30660);
+    return matrix.map((row) => row.map((cell) => cell === true));
+  }
+  /**
+   * Renders the matrix to terminal string using ANSI half-block characters (▀, ▄, █).
+   * 2 vertical rows are packed into 1 line of terminal output for high compactness.
+   */
+  static renderToString(text) {
+    const matrix = this.generateMatrix(text);
+    const size = matrix.length;
+    const quietZone = 2;
+    const fullSize = size + quietZone * 2;
+    const padded = Array.from(
+      { length: fullSize },
+      (_, r) => Array.from({ length: fullSize }, (_2, c) => {
+        const mr = r - quietZone;
+        const mc = c - quietZone;
+        if (mr >= 0 && mr < size && mc >= 0 && mc < size) {
+          return matrix[mr][mc];
+        }
+        return false;
+      })
+    );
+    const lines = [];
+    const reset = "\x1B[0m";
+    const bgWhiteFgBlack = "\x1B[47m\x1B[30m";
+    for (let r = 0; r < fullSize; r += 2) {
+      let line = bgWhiteFgBlack;
+      for (let c = 0; c < fullSize; c++) {
+        const topDark = padded[r][c];
+        const bottomDark = r + 1 < fullSize ? padded[r + 1][c] : false;
+        if (topDark && bottomDark) {
+          line += "\u2588";
+        } else if (topDark && !bottomDark) {
+          line += "\u2580";
+        } else if (!topDark && bottomDark) {
+          line += "\u2584";
+        } else {
+          line += " ";
+        }
+      }
+      line += reset;
+      lines.push(line);
+    }
+    return lines.join("\n");
+  }
+}
+function drawFinder(matrix, row, col) {
+  for (let r = -1; r <= 7; r++) {
+    for (let c = -1; c <= 7; c++) {
+      const mr = row + r;
+      const mc = col + c;
+      if (mr >= 0 && mr < matrix.length && mc >= 0 && mc < matrix.length) {
+        if (r === -1 || r === 7 || c === -1 || c === 7) {
+          matrix[mr][mc] = false;
+        } else if (r === 0 || r === 6 || c === 0 || c === 6) {
+          matrix[mr][mc] = true;
+        } else if (r === 1 || r === 5 || c === 1 || c === 5) {
+          matrix[mr][mc] = false;
+        } else {
+          matrix[mr][mc] = true;
+        }
+      }
+    }
+  }
+}
+function drawAlignment(matrix, centerR, centerC) {
+  for (let r = -2; r <= 2; r++) {
+    for (let c = -2; c <= 2; c++) {
+      const mr = centerR + r;
+      const mc = centerC + c;
+      if (matrix[mr][mc] !== null) continue;
+      if (Math.abs(r) === 2 || Math.abs(c) === 2 || r === 0 && c === 0) {
+        matrix[mr][mc] = true;
+      } else {
+        matrix[mr][mc] = false;
+      }
+    }
+  }
+}
+function reserveFormatInfo(matrix, size) {
+  for (let i = 0; i <= 8; i++) {
+    if (matrix[8][i] === null) matrix[8][i] = false;
+    if (matrix[i][8] === null) matrix[i][8] = false;
+    if (matrix[8][size - 1 - i] === null) matrix[8][size - 1 - i] = false;
+    if (matrix[size - 1 - i][8] === null) matrix[size - 1 - i][8] = false;
+  }
+}
+function placeDataBits(matrix, size, codewords) {
+  let bitIdx = 0;
+  const totalBits = codewords.length * 8;
+  let right = size - 1;
+  let upwards = true;
+  while (right > 0) {
+    if (right === 6) right--;
+    for (let i = 0; i < size; i++) {
+      const row = upwards ? size - 1 - i : i;
+      for (let colOffset = 0; colOffset < 2; colOffset++) {
+        const col = right - colOffset;
+        if (matrix[row][col] === null) {
+          let bitVal = false;
+          if (bitIdx < totalBits) {
+            const byte = codewords[Math.floor(bitIdx / 8)];
+            const bit = 7 - bitIdx % 8;
+            bitVal = (byte >> bit & 1) === 1;
+            bitIdx++;
+          }
+          matrix[row][col] = bitVal;
+        }
+      }
+    }
+    right -= 2;
+    upwards = !upwards;
+  }
+}
+function applyMask(matrix, size) {
+  for (let r = 0; r < size; r++) {
+    for (let c = 0; c < size; c++) {
+      if (isProtectedModule(r, c, size)) continue;
+      if ((r + c) % 2 === 0) {
+        matrix[r][c] = !matrix[r][c];
+      }
+    }
+  }
+}
+function isProtectedModule(r, c, size) {
+  if (r <= 8 && c <= 8) return true;
+  if (r <= 8 && c >= size - 8) return true;
+  if (r >= size - 8 && c <= 8) return true;
+  if (r === 6 || c === 6) return true;
+  return false;
+}
+function writeFormatInfo(matrix, size, formatBits) {
+  for (let i = 0; i < 15; i++) {
+    const bit = (formatBits >> 14 - i & 1) === 1;
+    if (i <= 5) {
+      matrix[8][i] = bit;
+    } else if (i === 6) {
+      matrix[8][7] = bit;
+    } else if (i === 7) {
+      matrix[8][8] = bit;
+    } else if (i === 8) {
+      matrix[7][8] = bit;
+    } else {
+      matrix[14 - i][8] = bit;
+    }
+    if (i < 8) {
+      matrix[size - 1 - i][8] = bit;
+    } else {
+      matrix[8][size - 15 + i] = bit;
+    }
+  }
+}
+
+async function runCli(argv = process.argv.slice(2)) {
+  let port = 4783;
+  let host = "0.0.0.0";
+  let shouldOpen = true;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--port" && argv[i + 1]) {
+      port = parseInt(argv[i + 1], 10) || 4783;
+      i++;
+    } else if (arg.startsWith("--port=")) {
+      port = parseInt(arg.split("=")[1], 10) || 4783;
+    } else if (arg === "--host" && argv[i + 1]) {
+      host = argv[i + 1];
+      i++;
+    } else if (arg === "--no-open") {
+      shouldOpen = false;
+    }
+  }
+  const server = new CapDebugCliServer({ port, host });
+  await server.start();
+  let sessionInfo = server.createSession();
+  let pairingUrl = server.getMobilePairingUrl(sessionInfo.session.id, sessionInfo.secret);
+  const viewerUrl = server.getLocalViewerUrl();
+  if (shouldOpen) {
+    openBrowser(viewerUrl);
+  }
+  let statusMessage = "Waiting for device...";
+  let countdownTimer = null;
+  function renderTerminalScreen() {
+    process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
+    const remainingSec = Math.max(0, Math.floor((sessionInfo.session.expiresAt - Date.now()) / 1e3));
+    const mins = String(Math.floor(remainingSec / 60)).padStart(2, "0");
+    const secs = String(remainingSec % 60).padStart(2, "0");
+    const qrRendered = TerminalQRCode.renderToString(pairingUrl);
+    console.log("\x1B[1m\x1B[36mCapDebug Remote\x1B[0m\n");
+    console.log(`Desktop viewer:
+\x1B[4m\x1B[34m${viewerUrl}\x1B[0m
+`);
+    console.log(`Scan to connect with mobile:
+`);
+    console.log(qrRendered);
+    console.log("");
+    console.log(`Session:    \x1B[1m\x1B[33m${sessionInfo.session.id}\x1B[0m`);
+    console.log(`Expires in: ${mins}:${secs}`);
+    console.log(`LAN URL:    ${pairingUrl.split("#")[0]}`);
+    console.log("");
+    console.log(`Status: \x1B[32m${statusMessage}\x1B[0m
+`);
+    console.log("Press:");
+    console.log("  \x1B[1mO\x1B[0m  Open desktop viewer in browser");
+    console.log("  \x1B[1mC\x1B[0m  Copy pairing URL to clipboard");
+    console.log("  \x1B[1mR\x1B[0m  Regenerate QR session");
+    console.log("  \x1B[1mQ\x1B[0m  Quit");
+  }
+  function setupCountdown() {
+    if (countdownTimer) clearInterval(countdownTimer);
+    countdownTimer = setInterval(() => {
+      const remainingSec = Math.floor((sessionInfo.session.expiresAt - Date.now()) / 1e3);
+      if (remainingSec <= 0) {
+        statusMessage = "\x1B[31mSession expired. Press R to regenerate.\x1B[0m";
+      }
+      renderTerminalScreen();
+    }, 1e3);
+  }
+  function regenerateSession() {
+    sessionInfo = server.createSession();
+    pairingUrl = server.getMobilePairingUrl(sessionInfo.session.id, sessionInfo.secret);
+    statusMessage = "Waiting for device...";
+    setupCountdown();
+    renderTerminalScreen();
+  }
+  if (process.stdin.isTTY) {
+    readline__namespace.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("keypress", (str, key) => {
+      if (key.ctrl && key.name === "c") {
+        cleanupAndExit();
+      }
+      const k = (str || key.name || "").toLowerCase();
+      if (k === "q") {
+        cleanupAndExit();
+      } else if (k === "o") {
+        openBrowser(viewerUrl);
+      } else if (k === "c") {
+        copyToClipboard(pairingUrl);
+        statusMessage = "Pairing URL copied to clipboard!";
+        renderTerminalScreen();
+      } else if (k === "r") {
+        regenerateSession();
+      }
+    });
+  }
+  async function cleanupAndExit() {
+    if (countdownTimer) clearInterval(countdownTimer);
+    console.log("\nStopping CapDebug Remote server...");
+    await server.stop();
+    process.exit(0);
+  }
+  process.on("SIGINT", cleanupAndExit);
+  process.on("SIGTERM", cleanupAndExit);
+  setupCountdown();
+  renderTerminalScreen();
+}
+function openBrowser(url) {
+  const startCmd = process.platform === "darwin" ? `open "${url}"` : process.platform === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
+  child_process.exec(startCmd, () => {
+  });
+}
+function copyToClipboard(text) {
+  const copyCmd = process.platform === "darwin" ? `printf "%s" "${text}" | pbcopy` : process.platform === "win32" ? `printf "%s" "${text}" | clip` : `printf "%s" "${text}" | xclip -selection clipboard 2>/dev/null || printf "%s" "${text}" | xsel -b 2>/dev/null`;
+  child_process.exec(copyCmd, () => {
+  });
+}
+
+exports.runCli = runCli;
+//# sourceMappingURL=cli.js.map