npm - nikcli-remote - Versions diffs - 1.0.9 → 1.0.11 - Mend

nikcli-remote 1.0.9 → 1.0.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/dist/chunk-5ANLFHJV.js +1145 -0
package/dist/chunk-GI5RMYH6.js +37 -0
package/dist/index.cjs +4683 -6082
package/dist/index.d.cts +98 -60
package/dist/index.d.ts +98 -60
package/dist/index.js +228 -7
package/dist/{localtunnel-XT32JGNN.js → localtunnel-6DCQIYU6.js} +1 -1
package/dist/server-VOW4RWJA.js +7 -0
package/package.json +1 -1
package/src/index.ts +57 -12
package/src/server.ts +113 -108
package/src/tunnel.ts +24 -0
package/dist/chunk-3IFHAOGG.js +0 -2747
package/dist/chunk-MCKGQKYU.js +0 -15
package/dist/server-MBJQBTJF.js +0 -7

package/dist/chunk-5ANLFHJV.js ADDED Viewed

@@ -0,0 +1,1145 @@
+import {
+  __esm,
+  __export,
+  __toCommonJS
+} from "./chunk-GI5RMYH6.js";
+// src/web-client.ts
+var web_client_exports = {};
+__export(web_client_exports, {
+  getWebClient: () => getWebClient
+});
+function getWebClient() {
+  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">
+  <meta name="apple-mobile-web-app-capable" content="yes">
+  <meta name="mobile-web-app-capable" content="yes">
+  <meta name="theme-color" content="#0d1117">
+  <title>NikCLI Remote</title>
+  <style>
+    :root {
+      --bg: #0d1117;
+      --bg-secondary: #161b22;
+      --fg: #e6edf3;
+      --fg-muted: #8b949e;
+      --accent: #58a6ff;
+      --success: #3fb950;
+      --warning: #d29922;
+      --error: #f85149;
+      --border: #30363d;
+      --font-mono: 'SF Mono', 'Fira Code', 'Consolas', monospace;
+    }
+    * {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+      -webkit-tap-highlight-color: transparent;
+    }
+    html, body {
+      height: 100%;
+      background: var(--bg);
+      color: var(--fg);
+      font-family: var(--font-mono);
+      font-size: 14px;
+      overflow: hidden;
+      touch-action: manipulation;
+    }
+    #app {
+      display: flex;
+      flex-direction: column;
+      height: 100%;
+      height: 100dvh;
+    }
+    /* Header */
+    #header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 12px 16px;
+      background: var(--bg-secondary);
+      border-bottom: 1px solid var(--border);
+      flex-shrink: 0;
+    }
+    #header h1 {
+      font-size: 16px;
+      font-weight: 600;
+      color: var(--accent);
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+    #header h1::before {
+      content: '';
+      width: 10px;
+      height: 10px;
+      background: var(--accent);
+      border-radius: 2px;
+    }
+    #status {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      font-size: 12px;
+      color: var(--fg-muted);
+    }
+    #status-dot {
+      width: 8px;
+      height: 8px;
+      border-radius: 50%;
+      background: var(--error);
+      transition: background 0.3s;
+    }
+    #status-dot.connected {
+      background: var(--success);
+    }
+    #status-dot.connecting {
+      background: var(--warning);
+      animation: pulse 1s infinite;
+    }
+    @keyframes pulse {
+      0%, 100% { opacity: 1; }
+      50% { opacity: 0.5; }
+    }
+    /* Terminal */
+    #terminal-container {
+      flex: 1;
+      overflow: hidden;
+      position: relative;
+    }
+    #terminal {
+      height: 100%;
+      padding: 12px;
+      overflow-y: auto;
+      overflow-x: hidden;
+      font-size: 13px;
+      line-height: 1.5;
+      white-space: pre-wrap;
+      word-break: break-all;
+      -webkit-overflow-scrolling: touch;
+    }
+    #terminal::-webkit-scrollbar {
+      width: 6px;
+    }
+    #terminal::-webkit-scrollbar-track {
+      background: var(--bg);
+    }
+    #terminal::-webkit-scrollbar-thumb {
+      background: var(--border);
+      border-radius: 3px;
+    }
+    .cursor {
+      display: inline-block;
+      width: 8px;
+      height: 16px;
+      background: var(--fg);
+      animation: blink 1s step-end infinite;
+      vertical-align: text-bottom;
+    }
+    @keyframes blink {
+      50% { opacity: 0; }
+    }
+    /* Notifications */
+    #notifications {
+      position: fixed;
+      top: 60px;
+      left: 12px;
+      right: 12px;
+      z-index: 1000;
+      pointer-events: none;
+    }
+    .notification {
+      background: var(--bg-secondary);
+      border: 1px solid var(--border);
+      border-radius: 8px;
+      padding: 12px 16px;
+      margin-bottom: 8px;
+      animation: slideIn 0.3s ease;
+      pointer-events: auto;
+      box-shadow: 0 4px 12px rgba(0,0,0,0.4);
+    }
+    .notification.success { border-left: 3px solid var(--success); }
+    .notification.error { border-left: 3px solid var(--error); }
+    .notification.warning { border-left: 3px solid var(--warning); }
+    .notification.info { border-left: 3px solid var(--accent); }
+    .notification h4 {
+      font-size: 14px;
+      font-weight: 600;
+      margin-bottom: 4px;
+    }
+    .notification p {
+      font-size: 12px;
+      color: var(--fg-muted);
+    }
+    @keyframes slideIn {
+      from { transform: translateY(-20px); opacity: 0; }
+      to { transform: translateY(0); opacity: 1; }
+    }
+    /* Quick Keys */
+    #quickkeys {
+      display: grid;
+      grid-template-columns: repeat(6, 1fr);
+      gap: 6px;
+      padding: 8px 12px;
+      background: var(--bg-secondary);
+      border-top: 1px solid var(--border);
+      flex-shrink: 0;
+    }
+    .qkey {
+      background: var(--bg);
+      border: 1px solid var(--border);
+      border-radius: 6px;
+      padding: 10px 4px;
+      color: var(--fg);
+      font-size: 11px;
+      font-family: var(--font-mono);
+      text-align: center;
+      cursor: pointer;
+      user-select: none;
+      transition: background 0.1s, transform 0.1s;
+    }
+    .qkey:active {
+      background: var(--border);
+      transform: scale(0.95);
+    }
+    .qkey.wide {
+      grid-column: span 2;
+    }
+    .qkey.accent {
+      background: var(--accent);
+      border-color: var(--accent);
+      color: #fff;
+    }
+    /* Input */
+    #input-container {
+      padding: 12px;
+      background: var(--bg-secondary);
+      border-top: 1px solid var(--border);
+      flex-shrink: 0;
+    }
+    #input-row {
+      display: flex;
+      gap: 8px;
+    }
+    #input {
+      flex: 1;
+      background: var(--bg);
+      border: 1px solid var(--border);
+      border-radius: 8px;
+      padding: 12px 14px;
+      color: var(--fg);
+      font-family: var(--font-mono);
+      font-size: 16px;
+      outline: none;
+      transition: border-color 0.2s;
+    }
+    #input:focus {
+      border-color: var(--accent);
+    }
+    #input::placeholder {
+      color: var(--fg-muted);
+    }
+    #send {
+      background: var(--accent);
+      color: #fff;
+      border: none;
+      border-radius: 8px;
+      padding: 12px 20px;
+      font-size: 14px;
+      font-weight: 600;
+      font-family: var(--font-mono);
+      cursor: pointer;
+      transition: opacity 0.2s, transform 0.1s;
+    }
+    #send:active {
+      opacity: 0.8;
+      transform: scale(0.98);
+    }
+    /* Auth Screen */
+    #auth-screen {
+      position: fixed;
+      inset: 0;
+      background: var(--bg);
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      gap: 20px;
+      z-index: 2000;
+    }
+    #auth-screen.hidden {
+      display: none;
+    }
+    .spinner {
+      width: 40px;
+      height: 40px;
+      border: 3px solid var(--border);
+      border-top-color: var(--accent);
+      border-radius: 50%;
+      animation: spin 1s linear infinite;
+    }
+    @keyframes spin {
+      to { transform: rotate(360deg); }
+    }
+    #auth-screen p {
+      color: var(--fg-muted);
+      font-size: 14px;
+    }
+    #auth-screen .error {
+      color: var(--error);
+    }
+    /* Safe area padding for notched devices */
+    @supports (padding: env(safe-area-inset-bottom)) {
+      #input-container {
+        padding-bottom: calc(12px + env(safe-area-inset-bottom));
+      }
+    }
+    /* Landscape adjustments */
+    @media (max-height: 500px) {
+      #quickkeys {
+        grid-template-columns: repeat(12, 1fr);
+        padding: 6px 8px;
+      }
+      .qkey {
+        padding: 8px 2px;
+        font-size: 10px;
+      }
+      #terminal {
+        font-size: 12px;
+      }
+    }
+  </style>
+</head>
+<body>
+  <div id="app">
+    <div id="auth-screen">
+      <div class="spinner"></div>
+      <p id="auth-status">Connecting to NikCLI...</p>
+    </div>
+    <header id="header">
+      <h1>NikCLI Remote</h1>
+      <div id="status">
+        <span id="status-dot" class="connecting"></span>
+        <span id="status-text">Connecting</span>
+      </div>
+    </header>
+    <div id="terminal-container">
+      <div id="terminal"></div>
+    </div>
+    <div id="notifications"></div>
+    <div id="quickkeys">
+      <button class="qkey" data-key="\\t">Tab</button>
+      <button class="qkey" data-key="\\x1b[A">\u2191</button>
+      <button class="qkey" data-key="\\x1b[B">\u2193</button>
+      <button class="qkey" data-key="\\x1b[D">\u2190</button>
+      <button class="qkey" data-key="\\x1b[C">\u2192</button>
+      <button class="qkey" data-key="\\x1b">Esc</button>
+      <button class="qkey" data-key="\\x03">^C</button>
+      <button class="qkey" data-key="\\x04">^D</button>
+      <button class="qkey" data-key="\\x1a">^Z</button>
+      <button class="qkey" data-key="\\x0c">^L</button>
+      <button class="qkey wide accent" data-key="\\r">Enter \u23CE</button>
+    </div>
+    <div id="input-container">
+      <div id="input-row">
+        <input type="text" id="input" placeholder="Type command..." autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false">
+        <button id="send">Send</button>
+      </div>
+    </div>
+  </div>
+  <script>
+    (function() {
+      'use strict';
+      // Parse URL params
+      const params = new URLSearchParams(location.search);
+      const token = params.get('t');
+      const sessionId = params.get('s');
+      // DOM elements
+      const terminal = document.getElementById('terminal');
+      const input = document.getElementById('input');
+      const sendBtn = document.getElementById('send');
+      const statusDot = document.getElementById('status-dot');
+      const statusText = document.getElementById('status-text');
+      const authScreen = document.getElementById('auth-screen');
+      const authStatus = document.getElementById('auth-status');
+      const notifications = document.getElementById('notifications');
+      // State
+      let ws = null;
+      let reconnectAttempts = 0;
+      const maxReconnectAttempts = 5;
+      let terminalEnabled = true;
+      // Connect to WebSocket
+      function connect() {
+        const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
+        ws = new WebSocket(protocol + '//' + location.host);
+        ws.onopen = function() {
+          setStatus('connecting', 'Authenticating...');
+          ws.send(JSON.stringify({ type: 'auth', token: token }));
+        };
+        ws.onmessage = function(event) {
+          try {
+            const msg = JSON.parse(event.data);
+            handleMessage(msg);
+          } catch (e) {
+            console.error('Parse error:', e);
+          }
+        };
+        ws.onclose = function() {
+          setStatus('disconnected', 'Disconnected');
+          if (reconnectAttempts < maxReconnectAttempts) {
+            reconnectAttempts++;
+            const delay = Math.min(2000 * reconnectAttempts, 10000);
+            setTimeout(connect, delay);
+          } else {
+            authStatus.textContent = 'Connection failed. Refresh to retry.';
+            authStatus.classList.add('error');
+            authScreen.classList.remove('hidden');
+          }
+        };
+        ws.onerror = function() {
+          console.error('WebSocket error');
+        };
+      }
+      // Handle incoming message
+      function handleMessage(msg) {
+        switch (msg.type) {
+          case 'auth:required':
+            // Already sent auth on open
+            break;
+          case 'auth:success':
+            authScreen.classList.add('hidden');
+            setStatus('connected', 'Connected');
+            reconnectAttempts = 0;
+            terminalEnabled = msg.payload?.terminalEnabled !== false;
+            if (terminalEnabled) {
+              appendOutput('\\x1b[32mConnected to NikCLI\\x1b[0m\\n\\n');
+            }
+            break;
+          case 'auth:failed':
+            authStatus.textContent = 'Authentication failed';
+            authStatus.classList.add('error');
+            break;
+          case 'terminal:output':
+            if (msg.payload?.data) {
+              appendOutput(msg.payload.data);
+            }
+            break;
+          case 'terminal:exit':
+            appendOutput('\\n\\x1b[33m[Process exited with code ' + (msg.payload?.code || 0) + ']\\x1b[0m\\n');
+            break;
+          case 'notification':
+            showNotification(msg.payload);
+            break;
+          case 'session:end':
+            appendOutput('\\n\\x1b[31m[Session ended]\\x1b[0m\\n');
+            setStatus('disconnected', 'Session ended');
+            break;
+          case 'pong':
+            // Heartbeat response
+            break;
+          default:
+            console.log('Unknown message:', msg.type);
+        }
+      }
+      // Append text to terminal with ANSI support
+      function appendOutput(text) {
+        // Simple ANSI to HTML conversion
+        const html = ansiToHtml(text);
+        terminal.innerHTML += html;
+        terminal.scrollTop = terminal.scrollHeight;
+      }
+      // Basic ANSI to HTML
+      function ansiToHtml(text) {
+        const ansiColors = {
+          '30': '#6e7681', '31': '#f85149', '32': '#3fb950', '33': '#d29922',
+          '34': '#58a6ff', '35': '#bc8cff', '36': '#76e3ea', '37': '#e6edf3',
+          '90': '#6e7681', '91': '#f85149', '92': '#3fb950', '93': '#d29922',
+          '94': '#58a6ff', '95': '#bc8cff', '96': '#76e3ea', '97': '#ffffff'
+        };
+        let result = '';
+        let currentStyle = '';
+        const parts = text.split(/\\x1b\\[([0-9;]+)m/);
+        for (let i = 0; i < parts.length; i++) {
+          if (i % 2 === 0) {
+            // Text content
+            result += escapeHtml(parts[i]);
+          } else {
+            // ANSI code
+            const codes = parts[i].split(';');
+            for (const code of codes) {
+              if (code === '0') {
+                if (currentStyle) {
+                  result += '</span>';
+                  currentStyle = '';
+                }
+              } else if (code === '1') {
+                currentStyle = 'font-weight:bold;';
+                result += '<span style="' + currentStyle + '">';
+              } else if (ansiColors[code]) {
+                if (currentStyle) result += '</span>';
+                currentStyle = 'color:' + ansiColors[code] + ';';
+                result += '<span style="' + currentStyle + '">';
+              }
+            }
+          }
+        }
+        if (currentStyle) result += '</span>';
+        return result;
+      }
+      // Escape HTML
+      function escapeHtml(text) {
+        return text
+          .replace(/&/g, '&amp;')
+          .replace(/</g, '&lt;')
+          .replace(/>/g, '&gt;')
+          .replace(/"/g, '&quot;')
+          .replace(/\\n/g, '<br>')
+          .replace(/ /g, '&nbsp;');
+      }
+      // Set connection status
+      function setStatus(state, text) {
+        statusDot.className = state === 'connected' ? 'connected' :
+                              state === 'connecting' ? 'connecting' : '';
+        statusText.textContent = text;
+      }
+      // Send data to terminal
+      function send(data) {
+        if (ws && ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: 'terminal:input', data: data }));
+        }
+      }
+      // Show notification
+      function showNotification(n) {
+        if (!n) return;
+        const el = document.createElement('div');
+        el.className = 'notification ' + (n.type || 'info');
+        el.innerHTML = '<h4>' + escapeHtml(n.title || 'Notification') + '</h4>' +
+                       '<p>' + escapeHtml(n.body || '') + '</p>';
+        notifications.appendChild(el);
+        setTimeout(function() { el.remove(); }, 5000);
+      }
+      // Event: Send button
+      sendBtn.onclick = function() {
+        if (input.value) {
+          send(input.value + '\\r');
+          input.value = '';
+        }
+        input.focus();
+      };
+      // Event: Enter key in input
+      input.onkeydown = function(e) {
+        if (e.key === 'Enter') {
+          e.preventDefault();
+          sendBtn.click();
+        }
+      };
+      // Event: Quick keys
+      document.querySelectorAll('.qkey').forEach(function(btn) {
+        btn.onclick = function() {
+          const key = btn.dataset.key;
+          const decoded = key
+            .replace(/\\\\x([0-9a-f]{2})/gi, function(_, hex) {
+              return String.fromCharCode(parseInt(hex, 16));
+            })
+            .replace(/\\\\t/g, '\\t')
+            .replace(/\\\\r/g, '\\r')
+            .replace(/\\\\n/g, '\\n');
+          send(decoded);
+          input.focus();
+        };
+      });
+      // Heartbeat
+      setInterval(function() {
+        if (ws && ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: 'ping' }));
+        }
+      }, 25000);
+      // Handle resize
+      function sendResize() {
+        if (ws && ws.readyState === WebSocket.OPEN) {
+          const cols = Math.floor(terminal.clientWidth / 8);
+          const rows = Math.floor(terminal.clientHeight / 18);
+          ws.send(JSON.stringify({ type: 'terminal:resize', cols: cols, rows: rows }));
+        }
+      }
+      window.addEventListener('resize', sendResize);
+      setTimeout(sendResize, 1000);
+      // Start connection
+      if (token) {
+        connect();
+      } else {
+        authStatus.textContent = 'Invalid session URL';
+        authStatus.classList.add('error');
+      }
+    })();
+  </script>
+</body>
+</html>`;
+}
+var init_web_client = __esm({
+  "src/web-client.ts"() {
+    "use strict";
+  }
+});
+// src/server.ts
+import { EventEmitter } from "events";
+import { createServer } from "http";
+import { WebSocketServer, WebSocket } from "ws";
+import crypto from "crypto";
+import os from "os";
+// src/types.ts
+var DEFAULT_CONFIG = {
+  port: 0,
+  host: "0.0.0.0",
+  enableTunnel: true,
+  tunnelProvider: "localtunnel",
+  maxConnections: 5,
+  heartbeatInterval: 3e4,
+  shell: "/bin/bash",
+  cols: 80,
+  rows: 24,
+  enableTerminal: true,
+  sessionTimeout: 0
+};
+var MessageTypes = {
+  // Auth
+  AUTH_REQUIRED: "auth:required",
+  AUTH: "auth",
+  AUTH_SUCCESS: "auth:success",
+  AUTH_FAILED: "auth:failed",
+  // Terminal
+  TERMINAL_OUTPUT: "terminal:output",
+  TERMINAL_INPUT: "terminal:input",
+  TERMINAL_RESIZE: "terminal:resize",
+  TERMINAL_EXIT: "terminal:exit",
+  TERMINAL_CLEAR: "terminal:clear",
+  // Notifications
+  NOTIFICATION: "notification",
+  // Heartbeat
+  PING: "ping",
+  PONG: "pong",
+  // Session
+  SESSION_INFO: "session:info",
+  SESSION_END: "session:end",
+  // Commands (NikCLI specific)
+  COMMAND: "command",
+  COMMAND_RESULT: "command:result",
+  // Agent events
+  AGENT_START: "agent:start",
+  AGENT_PROGRESS: "agent:progress",
+  AGENT_COMPLETE: "agent:complete",
+  AGENT_ERROR: "agent:error"
+};
+// src/server.ts
+var RemoteServer = class extends EventEmitter {
+  config;
+  httpServer = null;
+  wss = null;
+  clients = /* @__PURE__ */ new Map();
+  session = null;
+  heartbeatTimer = null;
+  sessionTimeoutTimer = null;
+  isRunning = false;
+  sessionSecret;
+  // stdin/stdout proxy state
+  originalStdoutWrite = null;
+  originalStdinOn = null;
+  constructor(config = {}) {
+    super();
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.sessionSecret = config.sessionSecret || this.generateSecret();
+  }
+  /**
+   * Generate a random secret
+   */
+  generateSecret() {
+    return crypto.randomBytes(16).toString("hex");
+  }
+  /**
+   * Start the remote server - creates WebSocket server that proxies stdin/stdout
+   */
+  async start(options = {}) {
+    if (this.isRunning) {
+      throw new Error("Server already running");
+    }
+    const sessionId = this.generateSessionId();
+    this.httpServer = createServer((req, res) => this.handleHttpRequest(req, res));
+    this.wss = new WebSocketServer({ server: this.httpServer });
+    this.setupWebSocketHandlers();
+    const port = await new Promise((resolve, reject) => {
+      this.httpServer.listen(this.config.port, this.config.host, () => {
+        const addr = this.httpServer.address();
+        resolve(typeof addr === "object" ? addr?.port || 0 : 0);
+      });
+      this.httpServer.on("error", reject);
+    });
+    const localIp = this.getLocalIP();
+    const localUrl = `http://${localIp}:${port}`;
+    this.session = {
+      id: sessionId,
+      name: options.name || `nikcli-${sessionId}`,
+      qrCode: "",
+      qrUrl: `${localUrl}?s=${sessionId}&t=${this.sessionSecret}`,
+      localUrl,
+      status: "waiting",
+      connectedDevices: [],
+      startedAt: /* @__PURE__ */ new Date(),
+      lastActivity: /* @__PURE__ */ new Date(),
+      port
+    };
+    if (options.processForStreaming) {
+      this.setupStdioProxy(options.processForStreaming.stdout, options.processForStreaming.stdin);
+    }
+    this.startHeartbeat();
+    if (this.config.sessionTimeout > 0) {
+      this.startSessionTimeout();
+    }
+    this.session.status = "waiting";
+    this.isRunning = true;
+    this.emit("started", this.session);
+    return this.session;
+  }
+  /**
+   * Setup stdin/stdout proxy to forward to WebSocket clients
+   */
+  setupStdioProxy(stdout, stdin) {
+    const originalWrite = stdout.write.bind(stdout);
+    stdout.write = ((data, encoding, cb) => {
+      const result = originalWrite(data, encoding, cb);
+      const text = data instanceof Buffer ? data.toString() : data;
+      const cleaned = this.cleanOutputForMobile(text);
+      this.broadcastToAll({ type: MessageTypes.TERMINAL_OUTPUT, payload: { data: cleaned } });
+      return result;
+    });
+    this.wss?.on("connection", (ws) => {
+      ws.on("message", (rawData) => {
+        try {
+          const msg = JSON.parse(rawData.toString());
+          if (msg.type === MessageTypes.TERMINAL_INPUT && msg.data) {
+            const inputData = Buffer.from(msg.data);
+            stdin.emit("data", inputData);
+          }
+        } catch {
+        }
+      });
+    });
+  }
+  /**
+   * Clean output for mobile display - remove ANSI codes and TUI artifacts
+   */
+  cleanOutputForMobile(text) {
+    let cleaned = text.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/\r/g, "").replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
+    return cleaned;
+  }
+  /**
+   * Stop the server
+   */
+  async stop() {
+    if (!this.isRunning) return;
+    this.isRunning = false;
+    if (this.originalStdoutWrite && this.session) {
+    }
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.sessionTimeoutTimer) {
+      clearTimeout(this.sessionTimeoutTimer);
+      this.sessionTimeoutTimer = null;
+    }
+    this.broadcastToAll({ type: MessageTypes.SESSION_END, payload: {} });
+    for (const client of this.clients.values()) {
+      client.ws.close(1e3, "Server shutting down");
+    }
+    this.clients.clear();
+    if (this.wss) {
+      this.wss.close();
+      this.wss = null;
+    }
+    if (this.httpServer) {
+      await new Promise((resolve) => {
+        this.httpServer.close(() => resolve());
+      });
+      this.httpServer = null;
+    }
+    if (this.session) {
+      this.session.status = "stopped";
+    }
+    this.emit("stopped");
+  }
+  /**
+   * Broadcast message to all authenticated clients
+   */
+  broadcastToAll(message) {
+    const data = JSON.stringify({
+      type: message.type,
+      payload: message.payload,
+      timestamp: message.timestamp || Date.now()
+    });
+    for (const client of this.clients.values()) {
+      if (client.authenticated && client.ws.readyState === WebSocket.OPEN) {
+        client.ws.send(data);
+      }
+    }
+  }
+  /**
+   * Public broadcast method for compatibility
+   */
+  broadcast(message) {
+    this.broadcastToAll(message);
+  }
+  /**
+   * Send notification to clients
+   */
+  notify(notification) {
+    this.broadcastToAll({
+      type: MessageTypes.NOTIFICATION,
+      payload: notification
+    });
+  }
+  /**
+   * Get current session
+   */
+  getSession() {
+    return this.session;
+  }
+  /**
+   * Check if server is running
+   */
+  isActive() {
+    return this.isRunning && this.session?.status !== "stopped";
+  }
+  /**
+   * Get connected client count
+   */
+  getConnectedCount() {
+    let count = 0;
+    for (const client of this.clients.values()) {
+      if (client.authenticated) count++;
+    }
+    return count;
+  }
+  /**
+   * Write data to all connected clients (for manual output streaming)
+   */
+  writeToClients(data) {
+    this.broadcastToAll({ type: MessageTypes.TERMINAL_OUTPUT, payload: { data } });
+  }
+  /**
+   * Alias for writeToClients - for compatibility
+   */
+  writeToTerminal(data) {
+    this.writeToClients(data);
+  }
+  /**
+   * Resize terminal (for compatibility - not used in direct streaming mode)
+   */
+  resizeTerminal(cols, rows) {
+  }
+  /**
+   * Setup WebSocket handlers
+   */
+  setupWebSocketHandlers() {
+    this.wss.on("connection", (ws, req) => {
+      const clientId = this.generateClientId();
+      const client = {
+        id: clientId,
+        ws,
+        authenticated: false,
+        device: {
+          id: clientId,
+          userAgent: req.headers["user-agent"],
+          ip: req.socket.remoteAddress,
+          connectedAt: /* @__PURE__ */ new Date(),
+          lastActivity: /* @__PURE__ */ new Date()
+        },
+        lastPing: Date.now()
+      };
+      if (this.clients.size >= this.config.maxConnections) {
+        ws.close(1013, "Max connections reached");
+        return;
+      }
+      this.clients.set(clientId, client);
+      ws.send(JSON.stringify({ type: MessageTypes.AUTH_REQUIRED, timestamp: Date.now() }));
+      ws.on("message", (data) => {
+        try {
+          const message = JSON.parse(data.toString());
+          this.handleClientMessage(client, message);
+        } catch {
+        }
+      });
+      ws.on("close", () => {
+        this.clients.delete(clientId);
+        if (this.session && client.authenticated) {
+          this.session.connectedDevices = this.session.connectedDevices.filter(
+            (d) => d.id !== clientId
+          );
+          if (this.session.connectedDevices.length === 0) {
+            this.session.status = "waiting";
+          }
+          this.emit("client:disconnected", client.device);
+        }
+      });
+      ws.on("error", (error) => {
+        this.emit("client:error", clientId, error);
+      });
+      ws.on("pong", () => {
+        client.lastPing = Date.now();
+      });
+    });
+  }
+  /**
+   * Handle client message
+   */
+  handleClientMessage(client, message) {
+    client.device.lastActivity = /* @__PURE__ */ new Date();
+    if (this.session) {
+      this.session.lastActivity = /* @__PURE__ */ new Date();
+    }
+    if (this.config.sessionTimeout > 0) {
+      this.resetSessionTimeout();
+    }
+    switch (message.type) {
+      case MessageTypes.AUTH:
+        this.handleAuth(client, message.token);
+        break;
+      case MessageTypes.TERMINAL_INPUT:
+        break;
+      case MessageTypes.TERMINAL_RESIZE:
+        this.emit("message", client, message);
+        break;
+      case MessageTypes.PING:
+        client.ws.send(JSON.stringify({ type: MessageTypes.PONG, timestamp: Date.now() }));
+        break;
+      default:
+        this.emit("message", client, message);
+    }
+  }
+  /**
+   * Handle authentication
+   */
+  handleAuth(client, token) {
+    if (token === this.sessionSecret) {
+      client.authenticated = true;
+      if (this.session) {
+        this.session.connectedDevices.push(client.device);
+        this.session.status = "connected";
+      }
+      client.ws.send(
+        JSON.stringify({
+          type: MessageTypes.AUTH_SUCCESS,
+          payload: {
+            sessionId: this.session?.id
+          },
+          timestamp: Date.now()
+        })
+      );
+      this.emit("client:connected", client.device);
+    } else {
+      client.ws.send(JSON.stringify({ type: MessageTypes.AUTH_FAILED, timestamp: Date.now() }));
+      setTimeout(() => client.ws.close(1008, "Authentication failed"), 100);
+    }
+  }
+  /**
+   * Handle HTTP request
+   */
+  handleHttpRequest(req, res) {
+    const url = new URL(req.url || "/", `http://${req.headers.host}`);
+    const path = url.pathname;
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    if (path === "/" || path === "/index.html") {
+      const { getWebClient: getWebClient2 } = (init_web_client(), __toCommonJS(web_client_exports));
+      res.writeHead(200, {
+        "Content-Type": "text/html; charset=utf-8",
+        "Content-Security-Policy": "default-src 'self' 'unsafe-inline' 'unsafe-eval' https: data: ws: wss:"
+      });
+      res.end(getWebClient2());
+      return;
+    }
+    if (path === "/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok", session: this.session?.id }));
+      return;
+    }
+    if (path === "/api/session") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          id: this.session?.id,
+          name: this.session?.name,
+          status: this.session?.status,
+          connectedDevices: this.session?.connectedDevices.length
+        })
+      );
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("Not Found");
+  }
+  /**
+   * Start heartbeat
+   */
+  startHeartbeat() {
+    this.heartbeatTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [id, client] of this.clients) {
+        if (now - client.lastPing > this.config.heartbeatInterval * 2) {
+          client.ws.terminate();
+          this.clients.delete(id);
+        } else if (client.ws.readyState === WebSocket.OPEN) {
+          client.ws.ping();
+        }
+      }
+    }, this.config.heartbeatInterval);
+  }
+  /**
+   * Start session timeout
+   */
+  startSessionTimeout() {
+    this.sessionTimeoutTimer = setTimeout(() => {
+      if (this.session?.connectedDevices.length === 0) {
+        this.stop();
+      }
+    }, this.config.sessionTimeout);
+  }
+  /**
+   * Reset session timeout
+   */
+  resetSessionTimeout() {
+    if (this.sessionTimeoutTimer) {
+      clearTimeout(this.sessionTimeoutTimer);
+    }
+    if (this.config.sessionTimeout > 0) {
+      this.startSessionTimeout();
+    }
+  }
+  /**
+   * Get local IP
+   */
+  getLocalIP() {
+    const interfaces = os.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";
+  }
+  /**
+   * Generate session ID
+   */
+  generateSessionId() {
+    return crypto.randomBytes(4).toString("hex");
+  }
+  /**
+   * Generate client ID
+   */
+  generateClientId() {
+    return "c_" + crypto.randomBytes(4).toString("hex");
+  }
+};
+export {
+  DEFAULT_CONFIG,
+  MessageTypes,
+  getWebClient,
+  init_web_client,
+  RemoteServer
+};