localpov 0.1.0

package/dist/utils/inject.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInjectScript = getInjectScript;
+/**
+ * Returns the JavaScript snippet to inject into HTML pages.
+ * This script captures:
+ *   - Console output (error, warn, log, info)
+ *   - Network requests (fetch + XHR) with status, timing, response bodies for errors
+ *   - Unhandled errors and promise rejections
+ *   - Screenshots on demand (via html2canvas or canvas capture)
+ *
+ * Sends everything to the LocalPOV server via WebSocket.
+ */
+function getInjectScript(wsUrl) {
+    // Minified-ish but readable. Runs in the user's browser.
+    return `
+<script data-localpov-inject>
+(function() {
+  if (window.__localpov_injected) return;
+  window.__localpov_injected = true;
+
+  var WS_URL = ${JSON.stringify(wsUrl)};
+  var ws = null;
+  var queue = [];
+  var MAX_QUEUE = 100;
+
+  function connect() {
+    try {
+      ws = new WebSocket(WS_URL);
+      ws.onopen = function() {
+        while (queue.length) ws.send(queue.shift());
+      };
+      ws.onclose = function() {
+        ws = null;
+        setTimeout(connect, 3000);
+      };
+      ws.onerror = function() { ws = null; };
+    } catch(e) {}
+  }
+  connect();
+
+  function send(data) {
+    var msg = JSON.stringify(data);
+    if (ws && ws.readyState === 1) {
+      ws.send(msg);
+    } else if (queue.length < MAX_QUEUE) {
+      queue.push(msg);
+    }
+  }
+
+  // ── Console capture ──
+  var origConsole = {};
+  ['error','warn','log','info','debug'].forEach(function(level) {
+    origConsole[level] = console[level];
+    console[level] = function() {
+      origConsole[level].apply(console, arguments);
+      var args = Array.prototype.slice.call(arguments);
+      var message = args.map(function(a) {
+        if (a instanceof Error) return a.message + '\\n' + (a.stack || '');
+        if (typeof a === 'object') {
+          try { return JSON.stringify(a, null, 2).slice(0, 1000); } catch(e) { return String(a); }
+        }
+        return String(a);
+      }).join(' ');
+      send({
+        type: 'console',
+        level: level,
+        message: message.slice(0, 2000),
+        url: location.href,
+        ts: Date.now()
+      });
+    };
+  });
+
+  // ── Unhandled errors ──
+  window.addEventListener('error', function(e) {
+    send({
+      type: 'error',
+      message: e.message || String(e),
+      source: (e.filename || '') + ':' + (e.lineno || 0) + ':' + (e.colno || 0),
+      stack: e.error && e.error.stack ? e.error.stack : null,
+      url: location.href,
+      ts: Date.now()
+    });
+  });
+
+  window.addEventListener('unhandledrejection', function(e) {
+    var msg = e.reason instanceof Error ? e.reason.message : String(e.reason || 'Unhandled promise rejection');
+    var stack = e.reason instanceof Error ? e.reason.stack : null;
+    send({
+      type: 'error',
+      message: msg,
+      stack: stack,
+      source: 'unhandledrejection',
+      url: location.href,
+      ts: Date.now()
+    });
+  });
+
+  // ── Fetch capture ──
+  var origFetch = window.fetch;
+  if (origFetch) {
+    window.fetch = function(input, init) {
+      var url = typeof input === 'string' ? input : (input && input.url ? input.url : String(input));
+      var method = (init && init.method) || (input && input.method) || 'GET';
+      var startTime = Date.now();
+
+      // Skip localpov's own requests
+      if (url.indexOf('__localpov__') !== -1) return origFetch.apply(this, arguments);
+
+      return origFetch.apply(this, arguments).then(function(response) {
+        var entry = {
+          type: 'network',
+          method: method.toUpperCase(),
+          url: url.slice(0, 500),
+          status: response.status,
+          statusText: response.statusText,
+          duration: Date.now() - startTime,
+          ts: Date.now()
+        };
+
+        // Capture response body for errors
+        if (response.status >= 400) {
+          response.clone().text().then(function(body) {
+            entry.responseBody = body.slice(0, 5000);
+            send(entry);
+          }).catch(function() { send(entry); });
+        } else {
+          send(entry);
+        }
+        return response;
+      }).catch(function(err) {
+        send({
+          type: 'network',
+          method: method.toUpperCase(),
+          url: url.slice(0, 500),
+          status: 0,
+          error: err.message || 'Network error',
+          duration: Date.now() - startTime,
+          ts: Date.now()
+        });
+        throw err;
+      });
+    };
+  }
+
+  // ── XHR capture ──
+  var origXHROpen = XMLHttpRequest.prototype.open;
+  var origXHRSend = XMLHttpRequest.prototype.send;
+
+  XMLHttpRequest.prototype.open = function(method, url) {
+    this.__lpov = { method: method, url: String(url).slice(0, 500), startTime: 0 };
+    return origXHROpen.apply(this, arguments);
+  };
+
+  XMLHttpRequest.prototype.send = function() {
+    var xhr = this;
+    if (xhr.__lpov) {
+      // Skip localpov's own requests
+      if (xhr.__lpov.url.indexOf('__localpov__') !== -1) {
+        return origXHRSend.apply(this, arguments);
+      }
+      xhr.__lpov.startTime = Date.now();
+      xhr.addEventListener('loadend', function() {
+        var entry = {
+          type: 'network',
+          method: (xhr.__lpov.method || 'GET').toUpperCase(),
+          url: xhr.__lpov.url,
+          status: xhr.status,
+          statusText: xhr.statusText,
+          duration: Date.now() - xhr.__lpov.startTime,
+          ts: Date.now()
+        };
+        if (xhr.status >= 400) {
+          entry.responseBody = String(xhr.responseText || '').slice(0, 5000);
+        }
+        send(entry);
+      });
+      xhr.addEventListener('error', function() {
+        send({
+          type: 'network',
+          method: (xhr.__lpov.method || 'GET').toUpperCase(),
+          url: xhr.__lpov.url,
+          status: 0,
+          error: 'XHR network error',
+          duration: Date.now() - xhr.__lpov.startTime,
+          ts: Date.now()
+        });
+      });
+    }
+    return origXHRSend.apply(this, arguments);
+  };
+
+  // ── Screenshot on demand ──
+  // Server can request a screenshot via WS message { type: 'take-screenshot' }
+  function takeScreenshot() {
+    // Try html2canvas if loaded, otherwise use basic canvas capture
+    if (window.html2canvas) {
+      window.html2canvas(document.body, { useCORS: true, logging: false, scale: 0.5 }).then(function(canvas) {
+        send({ type: 'screenshot', data: canvas.toDataURL('image/jpeg', 0.6), ts: Date.now() });
+      }).catch(function() {
+        fallbackScreenshot();
+      });
+    } else {
+      fallbackScreenshot();
+    }
+  }
+
+  function fallbackScreenshot() {
+    // Inject html2canvas dynamically on first screenshot request
+    var script = document.createElement('script');
+    script.src = 'https://cdn.jsdelivr.net/npm/html2canvas@1.4.1/dist/html2canvas.min.js';
+    script.onload = function() {
+      window.html2canvas(document.body, { useCORS: true, logging: false, scale: 0.5 }).then(function(canvas) {
+        send({ type: 'screenshot', data: canvas.toDataURL('image/jpeg', 0.6), ts: Date.now() });
+      }).catch(function(e) {
+        send({ type: 'console', level: 'warn', message: 'LocalPOV: screenshot failed: ' + e.message, ts: Date.now() });
+      });
+    };
+    script.onerror = function() {
+      send({ type: 'console', level: 'warn', message: 'LocalPOV: could not load html2canvas for screenshots', ts: Date.now() });
+    };
+    document.head.appendChild(script);
+  }
+
+  // Listen for server commands
+  function setupWsListener() {
+    if (!ws) { setTimeout(setupWsListener, 1000); return; }
+    ws.addEventListener('message', function(e) {
+      try {
+        var cmd = JSON.parse(e.data);
+        if (cmd.type === 'take-screenshot') takeScreenshot();
+      } catch(err) {}
+    });
+  }
+  setupWsListener();
+
+})();
+</script>`;
+}
+//# sourceMappingURL=inject.js.map

package/dist/utils/inject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject.js","sourceRoot":"","sources":["../../src/utils/inject.ts"],"names":[],"mappings":";;AAUA,0CAkOC;AA5OD;;;;;;;;;GASG;AACH,SAAgB,eAAe,CAAC,KAAa;IAC3C,yDAAyD;IACzD,OAAO;;;;;;iBAMQ,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAyN5B,CAAC;AACX,CAAC"}

package/dist/utils/network.d.ts

@@ -0,0 +1,7 @@
+interface IPResult {
+    name: string;
+    address: string;
+}
+export declare function getLocalIP(): string;
+export declare function getAllIPs(): IPResult[];
+export {};

package/dist/utils/network.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalIP = getLocalIP;
+exports.getAllIPs = getAllIPs;
+const os_1 = __importDefault(require("os"));
+function getLocalIP() {
+    const interfaces = os_1.default.networkInterfaces();
+    const candidates = [];
+    for (const [name, addrs] of Object.entries(interfaces)) {
+        if (!addrs)
+            continue;
+        for (const addr of addrs) {
+            if (addr.family === 'IPv4' && !addr.internal) {
+                candidates.push({
+                    name,
+                    address: addr.address,
+                    priority: name.match(/^(Wi-Fi|Ethernet|en0|wlan0|eth0|wlp)/i) ? 0 : 1,
+                });
+            }
+        }
+    }
+    candidates.sort((a, b) => a.priority - b.priority);
+    return candidates.length > 0 ? candidates[0].address : '127.0.0.1';
+}
+function getAllIPs() {
+    const interfaces = os_1.default.networkInterfaces();
+    const results = [];
+    for (const [name, addrs] of Object.entries(interfaces)) {
+        if (!addrs)
+            continue;
+        for (const addr of addrs) {
+            if (addr.family === 'IPv4' && !addr.internal) {
+                results.push({ name, address: addr.address });
+            }
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=network.js.map

package/dist/utils/network.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"network.js","sourceRoot":"","sources":["../../src/utils/network.ts"],"names":[],"mappings":";;;;;AAaA,gCAmBC;AAED,8BAcC;AAhDD,4CAAoB;AAapB,SAAgB,UAAU;IACxB,MAAM,UAAU,GAAG,YAAE,CAAC,iBAAiB,EAAE,CAAC;IAC1C,MAAM,UAAU,GAAkB,EAAE,CAAC;IAErC,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;QACvD,IAAI,CAAC,KAAK;YAAE,SAAS;QACrB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAC7C,UAAU,CAAC,IAAI,CAAC;oBACd,IAAI;oBACJ,OAAO,EAAE,IAAI,CAAC,OAAO;oBACrB,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,uCAAuC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;iBACtE,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC;IAED,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC;IACnD,OAAO,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC;AACrE,CAAC;AAED,SAAgB,SAAS;IACvB,MAAM,UAAU,GAAG,YAAE,CAAC,iBAAiB,EAAE,CAAC;IAC1C,MAAM,OAAO,GAAe,EAAE,CAAC;IAE/B,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;QACvD,IAAI,CAAC,KAAK;YAAE,SAAS;QACrB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAC7C,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;YAChD,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/utils/proxy.d.ts

@@ -0,0 +1,24 @@
+import http from 'http';
+import { TerminalCapture } from '../collectors/terminal';
+import { BrowserCapture } from '../collectors/browser-capture';
+interface AppInfo {
+    port: number;
+    framework: string;
+}
+interface CreateServerOptions {
+    targetPort: number;
+    listenPort: number;
+    getApps?: () => AppInfo[];
+    onLog?: (level: string, message: string | number) => void;
+    onReady?: () => void;
+    terminal?: TerminalCapture | null;
+    browserCapture?: BrowserCapture | null;
+}
+interface ProxyServer {
+    server: http.Server;
+    readonly currentTarget: number;
+    setTarget(port: number): void;
+    close(): void;
+}
+export declare function createServer({ targetPort, listenPort, getApps, onLog, onReady, terminal, browserCapture }: CreateServerOptions): ProxyServer;
+export {};

package/dist/utils/proxy.js

@@ -0,0 +1,363 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = createServer;
+const http_1 = __importDefault(require("http"));
+const http_proxy_1 = __importDefault(require("http-proxy"));
+const ws_1 = __importDefault(require("ws"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const inject_1 = require("./inject");
+const DASHBOARD_PREFIX = '/__localpov__';
+const DASHBOARD_DIR = path_1.default.join(__dirname, '..', '..', 'dashboard');
+const MIME = {
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'application/javascript',
+    '.css': 'text/css',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.json': 'application/json',
+};
+const IFRAME_BLOCKED = ['x-frame-options', 'content-security-policy', 'content-security-policy-report-only'];
+function parseCookies(str) {
+    const out = {};
+    for (const part of (str || '').split(';')) {
+        const idx = part.indexOf('=');
+        if (idx < 0)
+            continue;
+        const k = part.slice(0, idx).trim();
+        const v = part.slice(idx + 1).trim();
+        try {
+            out[k] = decodeURIComponent(v);
+        }
+        catch {
+            out[k] = v;
+        }
+    }
+    return out;
+}
+function createServer({ targetPort, listenPort, getApps, onLog, onReady, terminal, browserCapture }) {
+    let defaultTarget = targetPort;
+    const proxy = http_proxy_1.default.createProxyServer({ ws: true, xfwd: true, changeOrigin: true });
+    const injectWsUrl = `ws://\${req_host}:${listenPort}/__localpov__/ws/browser`;
+    const injectSnippet = (0, inject_1.getInjectScript)(injectWsUrl.replace('${req_host}', '"+location.hostname+"'));
+    proxy.on('proxyRes', (proxyRes, req, res) => {
+        for (const h of IFRAME_BLOCKED)
+            delete proxyRes.headers[h];
+        const ct = proxyRes.headers['content-type'] || '';
+        if (!ct.includes('text/html'))
+            return;
+        const origWrite = res.write;
+        const origEnd = res.end;
+        const chunks = [];
+        delete proxyRes.headers['content-length'];
+        res.write = function (chunk) {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            return true;
+        };
+        res.end = function (chunk) {
+            if (chunk)
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            let body = Buffer.concat(chunks).toString('utf8');
+            if (body.includes('</head>')) {
+                body = body.replace('</head>', injectSnippet + '</head>');
+            }
+            else if (body.includes('</body>')) {
+                body = body.replace('</body>', injectSnippet + '</body>');
+            }
+            else if (body.includes('<html') || body.includes('<!DOCTYPE') || body.includes('<!doctype')) {
+                body += injectSnippet;
+            }
+            origWrite.call(res, body, 'utf8');
+            origEnd.call(res);
+            return res;
+        };
+    });
+    let _lastProxyError = '';
+    let _lastProxyErrorTime = 0;
+    proxy.on('error', (err, req, res) => {
+        // Suppress repeated identical errors (e.g. ECONNREFUSED spam when target is down)
+        const now = Date.now();
+        if (err.message === _lastProxyError && now - _lastProxyErrorTime < 5000) {
+            // Skip logging, still serve error page
+        }
+        else {
+            _lastProxyError = err.message;
+            _lastProxyErrorTime = now;
+            if (onLog)
+                onLog('error', `Proxy error: ${err.message}`);
+        }
+        if (res && 'writeHead' in res && !('headersSent' in res && res.headersSent)) {
+            res.writeHead(502, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end(errorPage(defaultTarget));
+        }
+    });
+    function resolvePort(req) {
+        const urlObj = new URL(req.url || '/', 'http://localhost');
+        const cookies = parseCookies(req.headers.cookie);
+        const _port = urlObj.searchParams.get('_port');
+        if (_port) {
+            const p = parseInt(_port, 10);
+            if (p > 0 && p < 65536)
+                return p;
+        }
+        if (cookies.lpov_port) {
+            const p = parseInt(cookies.lpov_port, 10);
+            if (p > 0 && p < 65536)
+                return p;
+        }
+        return defaultTarget;
+    }
+    function setPortCookie(res, port, extraHeaders) {
+        const headers = Object.assign({}, extraHeaders || {});
+        headers['Set-Cookie'] = `lpov_port=${port}; Path=/; SameSite=Strict`;
+        return headers;
+    }
+    const termClients = new Set();
+    const browserClients = new Set();
+    const server = http_1.default.createServer((req, res) => {
+        const urlObj = new URL(req.url || '/', 'http://localhost');
+        if (urlObj.pathname === '/__localpov__/api/apps') {
+            const cookies = parseCookies(req.headers.cookie);
+            const sessionPort = parseInt(cookies.lpov_port, 10) || defaultTarget;
+            return json(res, { apps: getApps ? getApps() : [], currentTarget: sessionPort });
+        }
+        if (urlObj.pathname === '/__localpov__/api/switch') {
+            const port = parseInt(urlObj.searchParams.get('port') || '', 10);
+            if (port > 0 && port < 65536) {
+                if (onLog)
+                    onLog('switch', port);
+                res.writeHead(200, setPortCookie(res, port, {
+                    'Content-Type': 'application/json',
+                    'Cache-Control': 'no-cache',
+                }));
+                return res.end(JSON.stringify({ ok: true, target: port }));
+            }
+            return json(res, { error: 'Invalid port' }, 400);
+        }
+        if (urlObj.pathname === '/__localpov__/api/ping') {
+            return json(res, { ok: true, uptime: process.uptime() | 0 });
+        }
+        if (urlObj.pathname === '/__localpov__/api/terminal') {
+            if (terminal) {
+                return json(res, terminal.getStatus());
+            }
+            return json(res, { running: false, command: null });
+        }
+        if (urlObj.pathname === '/__localpov__/api/browser') {
+            if (!browserCapture)
+                return json(res, { console: [], network: [], summary: null });
+            const source = urlObj.searchParams.get('source') || 'summary';
+            if (source === 'console') {
+                return json(res, { entries: browserCapture.getConsoleEntries({ limit: 100 }) });
+            }
+            if (source === 'network') {
+                return json(res, { entries: browserCapture.getNetworkEntries({ limit: 100 }) });
+            }
+            return json(res, browserCapture.getSummary());
+        }
+        if (urlObj.pathname === '/__localpov__/api/health') {
+            const mem = process.memoryUsage();
+            return json(res, {
+                memory: Math.round((1 - os_1.default.freemem() / os_1.default.totalmem()) * 100),
+                heapMB: Math.round(mem.heapUsed / 1024 / 1024),
+                uptime: Math.floor(process.uptime()),
+                platform: process.platform,
+                node: process.version,
+                wsClients: { browser: browserClients.size, terminal: termClients.size },
+            });
+        }
+        if (urlObj.pathname === '/__localpov__/api/debug') {
+            if (process.env.NODE_ENV === 'production' && !process.env.LOCALPOV_DEBUG) {
+                return json(res, { error: 'Not found' }, 404);
+            }
+            return json(res, {
+                defaultTarget,
+                dashboardReady: fs_1.default.existsSync(path_1.default.join(DASHBOARD_DIR, 'index.html')),
+                platform: process.platform,
+                nodeVersion: process.version,
+                apps: getApps ? getApps() : [],
+            });
+        }
+        if (urlObj.pathname.startsWith(DASHBOARD_PREFIX)) {
+            return serveDashboard(urlObj.pathname, res);
+        }
+        // Serve an empty favicon to prevent 502 spam when target is down
+        if (urlObj.pathname === '/favicon.ico') {
+            res.writeHead(204);
+            return res.end();
+        }
+        const port = resolvePort(req);
+        if (urlObj.searchParams.get('_port')) {
+            const cleanUrl = (req.url || '/').replace(/[?&]_port=\d+/, '').replace(/\?$/, '') || '/';
+            res.writeHead(302, setPortCookie(res, port, { Location: cleanUrl }));
+            return res.end();
+        }
+        proxy.web(req, res, { target: `http://127.0.0.1:${port}` });
+    });
+    const termWss = new ws_1.default.Server({ noServer: true });
+    const MAX_WS_CLIENTS = 50;
+    const browserWss = new ws_1.default.Server({ noServer: true });
+    if (terminal) {
+        terminal.on('data', (data) => {
+            const msg = JSON.stringify({ type: 'data', stream: data.type, text: data.text, ts: data.ts });
+            for (const ws of termClients) {
+                if (ws.readyState === ws_1.default.OPEN)
+                    ws.send(msg);
+            }
+        });
+    }
+    server.on('upgrade', (req, socket, head) => {
+        const upgradeUrl = new URL(req.url || '/', 'http://localhost');
+        if (upgradeUrl.pathname === '/__localpov__/ws/browser') {
+            if (browserClients.size >= MAX_WS_CLIENTS) {
+                socket.write('HTTP/1.1 429 Too Many Connections\r\n\r\n');
+                socket.destroy();
+                return;
+            }
+            browserWss.handleUpgrade(req, socket, head, (ws) => {
+                browserClients.add(ws);
+                ws.on('message', (data) => {
+                    if (browserCapture) {
+                        try {
+                            const str = data.toString();
+                            if (str.length > 65536)
+                                return;
+                            browserCapture.handleMessage(str);
+                        }
+                        catch (e) {
+                            const msg = e instanceof Error ? e.message : String(e);
+                            if (onLog)
+                                onLog('warn', `Browser WS message error: ${msg}`);
+                        }
+                    }
+                });
+                ws.on('close', () => browserClients.delete(ws));
+                ws.on('error', (e) => {
+                    if (onLog)
+                        onLog('warn', `Browser WS error: ${e.message}`);
+                    browserClients.delete(ws);
+                });
+            });
+            return;
+        }
+        if (upgradeUrl.pathname === '/__localpov__/ws/terminal') {
+            if (termClients.size >= MAX_WS_CLIENTS) {
+                socket.write('HTTP/1.1 429 Too Many Connections\r\n\r\n');
+                socket.destroy();
+                return;
+            }
+            termWss.handleUpgrade(req, socket, head, (ws) => {
+                termClients.add(ws);
+                if (terminal) {
+                    const history = terminal.getBuffer();
+                    ws.send(JSON.stringify({ type: 'history', lines: history }));
+                }
+                else {
+                    ws.send(JSON.stringify({ type: 'status', running: false }));
+                }
+                ws.on('message', (data) => {
+                    if (!terminal || !terminal.interactive)
+                        return;
+                    try {
+                        const str = data.toString();
+                        if (str.length > 4096)
+                            return;
+                        const msg = JSON.parse(str);
+                        if (msg.type === 'input' && typeof msg.text === 'string') {
+                            terminal.write(msg.text.slice(0, 1024));
+                        }
+                    }
+                    catch (e) {
+                        const eMsg = e instanceof Error ? e.message : String(e);
+                        if (onLog)
+                            onLog('warn', `Terminal WS message error: ${eMsg}`);
+                    }
+                });
+                ws.on('close', () => termClients.delete(ws));
+                ws.on('error', (e) => {
+                    if (onLog)
+                        onLog('warn', `Terminal WS error: ${e.message}`);
+                    termClients.delete(ws);
+                });
+            });
+            return;
+        }
+        if (req.url && req.url.startsWith(DASHBOARD_PREFIX))
+            return;
+        const port = resolvePort(req);
+        proxy.ws(req, socket, head, { target: `http://127.0.0.1:${port}` });
+    });
+    server.on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+            if (onLog)
+                onLog('fatal', `Port ${listenPort} already in use. Is another instance running?`);
+        }
+        if (onLog)
+            onLog('error', `Server error: ${err.message}`);
+    });
+    server.listen(listenPort, '0.0.0.0', () => { if (onReady)
+        onReady(); });
+    function serveDashboard(pathname, res) {
+        let filePath = pathname.replace(DASHBOARD_PREFIX, '') || '/';
+        if (filePath === '' || filePath === '/')
+            filePath = '/index.html';
+        const fullPath = path_1.default.join(DASHBOARD_DIR, filePath);
+        if (!fullPath.startsWith(DASHBOARD_DIR)) {
+            res.writeHead(403);
+            res.end();
+            return;
+        }
+        fs_1.default.readFile(fullPath, (err, data) => {
+            if (err) {
+                res.writeHead(404);
+                res.end('Not found');
+                return;
+            }
+            const ext = path_1.default.extname(filePath);
+            res.writeHead(200, { 'Content-Type': MIME[ext] || 'application/octet-stream', 'Cache-Control': 'no-cache' });
+            res.end(data);
+        });
+    }
+    function json(res, data, status = 200) {
+        res.writeHead(status, { 'Content-Type': 'application/json', 'Cache-Control': 'no-cache' });
+        res.end(JSON.stringify(data));
+    }
+    return {
+        server,
+        get currentTarget() { return defaultTarget; },
+        setTarget(port) { defaultTarget = port; },
+        close() {
+            for (const ws of browserClients) {
+                try {
+                    ws.close(1001, 'Server shutting down');
+                }
+                catch { }
+            }
+            for (const ws of termClients) {
+                try {
+                    ws.close(1001, 'Server shutting down');
+                }
+                catch { }
+            }
+            browserClients.clear();
+            termClients.clear();
+            server.close();
+            proxy.close();
+        },
+    };
+}
+function errorPage(port) {
+    return `<!DOCTYPE html><html><head><meta name="viewport" content="width=device-width,initial-scale=1">
+<style>*{margin:0;box-sizing:border-box}body{font-family:system-ui;min-height:100vh;display:flex;align-items:center;justify-content:center;padding:20px}
+.b{text-align:center;max-width:320px}h2{font-size:18px;margin-bottom:8px}p{font-size:14px;line-height:1.5;margin-bottom:6px;opacity:.7}
+code{background:#f0f0f0;padding:2px 8px;border-radius:4px;font-size:13px}
+button{margin-top:16px;padding:10px 28px;font-size:14px;border-radius:8px;border:1px solid #ddd;background:#fff;cursor:pointer;font-family:inherit}
+@media(prefers-color-scheme:dark){body{background:#0a0a0a;color:#eee}code{background:#1a1a1a}button{background:#1a1a1a;border-color:#333;color:#ccc}}</style>
+</head><body><div class="b"><h2>App not responding</h2><p><code>localhost:${port}</code></p><p>Is your dev server running?</p>
+<button onclick="location.reload()">Retry</button><script>setTimeout(()=>location.reload(),5000)</script></div></body></html>`;
+}
+//# sourceMappingURL=proxy.js.map