handmux 0.23.0 → 0.25.0

package/src/browser/siteVersion.js

@@ -1,124 +0,0 @@
-export const DEFAULT_SITE_VERSION = 'mobile';
-export const SITE_VERSIONS = new Set(['mobile', 'desktop']);
-
-export function normalizeSiteVersion(value, fallback = DEFAULT_SITE_VERSION) {
-  if (value == null || value === '') return fallback;
-  return SITE_VERSIONS.has(value) ? value : null;
-}
-
-function versionFrom(ua, pattern, fallback = '120.0.0.0') {
-  return ua.match(pattern)?.[1] || fallback;
-}
-
-function identityPlatform(ua, mobile) {
-  if (/iPhone|iPad|iPod/i.test(ua)) return { navigator: 'iPhone', clientHint: 'iOS' };
-  if (/Android/i.test(ua)) return { navigator: 'Linux armv8l', clientHint: 'Android' };
-  if (/Windows/i.test(ua)) return { navigator: 'Win32', clientHint: 'Windows' };
-  if (/Macintosh|Mac OS X/i.test(ua)) return { navigator: 'MacIntel', clientHint: 'macOS' };
-  return mobile
-    ? { navigator: 'Linux armv8l', clientHint: 'Android' }
-    : { navigator: 'Linux x86_64', clientHint: 'Linux' };
-}
-
-function isMobileUserAgent(ua) {
-  return /Android|Mobile|iPhone|iPad|iPod/i.test(ua);
-}
-
-function transformedUserAgent(source, mobile) {
-  const ua = String(source || '');
-  if (ua && isMobileUserAgent(ua) === mobile) return ua;
-
-  const webkit = versionFrom(ua, /AppleWebKit\/([\d.]+)/i, '605.1.15');
-  const safari = versionFrom(ua, /Version\/([\d.]+)/i, '18.0');
-  if (/Safari\//i.test(ua) && !/(?:Chrome|CriOS|Chromium|Edg|OPR)\//i.test(ua)) {
-    return mobile
-      ? `Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/${webkit} (KHTML, like Gecko) Version/${safari} Mobile/15E148 Safari/${webkit}`
-      : `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/${webkit} (KHTML, like Gecko) Version/${safari} Safari/${webkit}`;
-  }
-
-  const firefox = ua.match(/Firefox\/([\d.]+)/i)?.[1];
-  if (firefox) {
-    return mobile
-      ? `Mozilla/5.0 (Android 10; Mobile; rv:${firefox}) Gecko/${firefox} Firefox/${firefox}`
-      : `Mozilla/5.0 (X11; Linux x86_64; rv:${firefox}) Gecko/20100101 Firefox/${firefox}`;
-  }
-
-  const chrome = versionFrom(ua, /(?:Chrome|CriOS|Chromium|Edg|OPR)\/([\d.]+)/i);
-  return mobile
-    ? `Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${chrome} Mobile Safari/537.36`
-    : `Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${chrome} Safari/537.36`;
-}
-
-export function siteVersionIdentity(siteVersion, sourceUserAgent = '') {
-  const version = normalizeSiteVersion(siteVersion);
-  if (!version) throw new Error('invalid browser site version');
-  const mobile = version === 'mobile';
-  const userAgent = transformedUserAgent(sourceUserAgent, mobile);
-  const platform = identityPlatform(userAgent, mobile);
-  return {
-    version,
-    mobile,
-    userAgent,
-    appVersion: userAgent.replace(/^Mozilla\//, ''),
-    platform: platform.navigator,
-    clientHintPlatform: platform.clientHint,
-    maxTouchPoints: mobile ? 5 : 0,
-  };
-}
-
-function headerKey(headers, name) {
-  const lower = name.toLowerCase();
-  return Object.keys(headers || {}).find((key) => key.toLowerCase() === lower) || lower;
-}
-
-function setHeader(headers, name, value) {
-  headers[headerKey(headers, name)] = value;
-}
-
-function deleteHeader(headers, name) {
-  const key = Object.keys(headers || {}).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
-  if (key) delete headers[key];
-}
-
-export function applySiteVersionHeaders(headers, identity) {
-  if (!headers || !identity) return headers;
-  setHeader(headers, 'user-agent', identity.userAgent);
-  setHeader(headers, 'sec-ch-ua-mobile', identity.mobile ? '?1' : '?0');
-  setHeader(headers, 'sec-ch-ua-platform', `"${identity.clientHintPlatform}"`);
-  for (const name of [
-    'sec-ch-ua-platform-version', 'sec-ch-ua-arch', 'sec-ch-ua-bitness',
-    'sec-ch-ua-model', 'sec-ch-ua-wow64', 'sec-ch-ua-full-version',
-    'sec-ch-ua-full-version-list',
-  ]) deleteHeader(headers, name);
-  return headers;
-}
-
-export function siteVersionNavigatorScript(identity) {
-  const encoded = JSON.stringify(identity).replaceAll('<', '\\u003c');
-  return `(() => {
-    const profile = ${encoded};
-    const define = (name, value) => {
-      try { Object.defineProperty(navigator, name, { configurable: true, get: () => value }); }
-      catch { /* the native value remains available */ }
-    };
-    define('userAgent', profile.userAgent);
-    define('appVersion', profile.appVersion);
-    define('platform', profile.platform);
-    define('maxTouchPoints', profile.maxTouchPoints);
-    const nativeData = navigator.userAgentData;
-    if (nativeData) {
-      const data = {
-        brands: nativeData.brands || [],
-        mobile: profile.mobile,
-        platform: profile.clientHintPlatform,
-        toJSON() { return { brands: this.brands, mobile: this.mobile, platform: this.platform }; },
-        async getHighEntropyValues(hints) {
-          let values = {};
-          try { values = await nativeData.getHighEntropyValues.call(nativeData, hints); } catch { /* optional API */ }
-          return { ...values, mobile: profile.mobile, platform: profile.clientHintPlatform };
-        },
-      };
-      define('userAgentData', data);
-    }
-  })();`;
-}

package/src/browser/targetPolicy.js

@@ -1,137 +0,0 @@
-import dns from 'node:dns/promises';
-import net from 'node:net';
-
-function ipv4Parts(address) {
-  const parts = address.split('.').map(Number);
-  return parts.length === 4 && parts.every((part) => Number.isInteger(part) && part >= 0 && part <= 255)
-    ? parts
-    : null;
-}
-
-function ipv6Words(address) {
-  const halves = address.split('::');
-  if (halves.length > 2) return null;
-  const parseHalf = (half) => {
-    if (!half) return [];
-    const words = [];
-    for (const token of half.split(':')) {
-      if (token.includes('.')) {
-        const parts = ipv4Parts(token);
-        if (!parts) return null;
-        words.push((parts[0] << 8) | parts[1], (parts[2] << 8) | parts[3]);
-      } else {
-        if (!/^[0-9a-f]{1,4}$/.test(token)) return null;
-        words.push(Number.parseInt(token, 16));
-      }
-    }
-    return words;
-  };
-  const left = parseHalf(halves[0]);
-  const right = parseHalf(halves[1] || '');
-  if (!left || !right) return null;
-  if (halves.length === 1) return left.length === 8 ? left : null;
-  const omitted = 8 - left.length - right.length;
-  if (omitted < 1) return null;
-  return [...left, ...Array(omitted).fill(0), ...right];
-}
-
-function mappedIpv4Parts(address) {
-  const words = ipv6Words(address);
-  if (!words
-    || words.slice(0, 5).some((word) => word !== 0)
-    || words[5] !== 0xffff) return null;
-  return [words[6] >> 8, words[6] & 0xff, words[7] >> 8, words[7] & 0xff];
-}
-
-function classifyIpv4(parts) {
-  if (parts[0] === 0) return 'unspecified';
-  if (parts[0] === 127) return 'loopback';
-  if (parts[0] === 169 && parts[1] === 254) return 'link-local';
-  if (parts[0] >= 224) return 'multicast';
-  return null;
-}
-
-export function classifyIp(raw) {
-  const address = String(raw || '').replace(/^\[|\]$/g, '').toLowerCase();
-  if (net.isIP(address) === 4) {
-    const parts = ipv4Parts(address);
-    return classifyIpv4(parts);
-  }
-  if (net.isIP(address) === 6) {
-    const mapped = mappedIpv4Parts(address);
-    if (mapped) return classifyIpv4(mapped);
-    if (address === '::') return 'unspecified';
-    if (address === '::1') return 'loopback';
-    if (/^fe[89ab]/.test(address)) return 'link-local';
-    if (address.startsWith('ff')) return 'multicast';
-    return null;
-  }
-  return null;
-}
-
-function effectivePort(url) {
-  if (url.port) return url.port;
-  return url.protocol === 'https:' ? '443' : '80';
-}
-
-export function createBrowserTargetPolicy({
-  topLevelUrl,
-  handmuxOrigin,
-  lookup = dns.lookup,
-} = {}) {
-  let topOrigin = new URL(topLevelUrl).origin;
-  let topAddressClass = null;
-  const appUrl = new URL(handmuxOrigin);
-  const appOrigin = appUrl.origin;
-  const appControlPort = effectivePort(appUrl);
-
-  return {
-    authorizeTopLevel(raw) {
-      const url = new URL(raw);
-      if (url.protocol !== 'http:' && url.protocol !== 'https:') throw new Error('browser URL must use http or https');
-      topOrigin = url.origin;
-      topAddressClass = null;
-    },
-
-    async check(raw) {
-      let url;
-      try { url = new URL(raw); } catch { return { allowed: false, reason: 'unsupported-protocol' }; }
-      if (url.protocol !== 'http:' && url.protocol !== 'https:') {
-        return { allowed: false, reason: 'unsupported-protocol' };
-      }
-      if (url.origin === appOrigin) return { allowed: false, reason: 'handmux-origin' };
-
-      const hostname = url.hostname.replace(/^\[|\]$/g, '');
-      let addresses;
-      if (net.isIP(hostname)) addresses = [{ address: hostname }];
-      else {
-        try { addresses = await lookup(hostname, { all: true, verbatim: true }); }
-        catch { return { allowed: false, reason: 'dns-failed' }; }
-      }
-      if (!addresses?.length) return { allowed: false, reason: 'dns-failed' };
-
-      const classifications = addresses.map((item) => classifyIp(item.address));
-      if (effectivePort(url) === appControlPort && classifications.some((reason) => reason === 'loopback')) {
-        return { allowed: false, reason: 'handmux-origin' };
-      }
-      if (url.origin === topOrigin && topAddressClass == null) {
-        if (classifications.every((reason) => reason === 'loopback')) topAddressClass = 'loopback';
-        else if (classifications.every((reason) => reason == null)) topAddressClass = 'ordinary';
-      }
-      const loopbackNavigationAllowed = url.origin === topOrigin
-        && topAddressClass === 'loopback'
-        && classifications.every((reason) => reason === 'loopback');
-      for (const reason of classifications) {
-        if (reason === 'loopback' && loopbackNavigationAllowed) continue;
-        if (reason) return { allowed: false, reason: reason === 'loopback' ? 'loopback-not-authorized' : reason };
-      }
-      return {
-        allowed: true,
-        addresses: addresses.map((item) => ({
-          address: item.address,
-          family: item.family || net.isIP(item.address),
-        })),
-      };
-    },
-  };
-}

package/src/browser/workerClient.js

@@ -1,253 +0,0 @@
-import http from 'node:http';
-import net from 'node:net';
-import { randomBytes } from 'node:crypto';
-import { fork } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { claimedBrowserRequest } from './publicProxy.js';
-import { BROWSER_INTERNAL_HEADER } from './protocol.js';
-import { createBrowserCoordinator } from './coordinator.js';
-
-const WORKER_FILE = fileURLToPath(new URL('./worker.js', import.meta.url));
-
-function forwardedHeaders(headers, internalToken, appToken, api) {
-  const out = { ...headers, [BROWSER_INTERNAL_HEADER]: internalToken };
-  if (api || out.authorization === `Bearer ${appToken}`) delete out.authorization;
-  delete out['proxy-authorization'];
-  return out;
-}
-
-export function createBrowserWorkerClient({
-  appToken,
-  previewDomain = null,
-  handmuxOrigin = 'http://127.0.0.1',
-  forkWorker = fork,
-  request = http.request,
-  connect = net.connect,
-  randomToken = () => randomBytes(32).toString('base64url'),
-  parentEnv = process.env,
-  setTimer = setTimeout,
-  clearTimer = clearTimeout,
-  readyTimeoutMs = 10_000,
-  stableAfterMs = 30_000,
-  requestTimeoutMs = 15_000,
-  stopTimeoutMs = 3_000,
-} = {}) {
-  const internalToken = randomToken();
-  let child = null;
-  let port = null;
-  let generation = 0;
-  let stopping = false;
-  let restartDelay = 250;
-  let restartTimer = null;
-  let readyTimer = null;
-  let stableTimer = null;
-  const activeSockets = new Set();
-  const workerEnv = {};
-  for (const name of [
-    'PATH', 'HOME', 'USER', 'LOGNAME', 'SHELL', 'TMPDIR', 'TMP', 'TEMP',
-    'LANG', 'LC_ALL', 'TZ', 'NODE_EXTRA_CA_CERTS', 'SSL_CERT_FILE', 'SSL_CERT_DIR',
-    'HTTP_PROXY', 'HTTPS_PROXY', 'ALL_PROXY', 'NO_PROXY',
-    'http_proxy', 'https_proxy', 'all_proxy', 'no_proxy',
-  ]) {
-    if (parentEnv[name] != null) workerEnv[name] = parentEnv[name];
-  }
-
-  const clearReadyTimer = () => {
-    if (readyTimer != null) clearTimer(readyTimer);
-    readyTimer = null;
-  };
-  const clearStableTimer = () => {
-    if (stableTimer != null) clearTimer(stableTimer);
-    stableTimer = null;
-  };
-  const scheduleRestart = () => {
-    if (stopping || restartTimer != null) return;
-    const delay = restartDelay;
-    restartDelay = Math.min(restartDelay * 2, 5_000);
-    restartTimer = setTimer(() => {
-      restartTimer = null;
-      if (!stopping) start();
-    }, delay);
-  };
-  const start = () => {
-    let spawned;
-    try {
-      spawned = forkWorker(WORKER_FILE, [], {
-        env: {
-          ...workerEnv,
-          HANDMUX_BROWSER_INTERNAL_TOKEN: internalToken,
-          HANDMUX_BROWSER_CONTROL_ORIGIN: handmuxOrigin,
-          ...(previewDomain ? { HANDMUX_PREVIEW_DOMAIN: previewDomain } : {}),
-        },
-        stdio: ['ignore', 'inherit', 'inherit', 'ipc'],
-      });
-    } catch {
-      child = null;
-      port = null;
-      scheduleRestart();
-      return;
-    }
-    child = spawned;
-    port = null;
-    readyTimer = setTimer(() => {
-      if (child === spawned && port == null) spawned.kill('SIGTERM');
-    }, readyTimeoutMs);
-    spawned.on('message', (message) => {
-      if (child !== spawned || message?.type !== 'handmux-browser-ready' || !Number.isInteger(message.port)) return;
-      port = message.port;
-      generation += 1;
-      clearReadyTimer();
-      clearStableTimer();
-      stableTimer = setTimer(() => {
-        stableTimer = null;
-        if (child === spawned && port != null) restartDelay = 250;
-      }, stableAfterMs);
-    });
-    const finalize = () => {
-      if (child !== spawned) return;
-      child = null;
-      port = null;
-      generation += 1;
-      clearReadyTimer();
-      clearStableTimer();
-      for (const socket of activeSockets) socket.destroy();
-      activeSockets.clear();
-      scheduleRestart();
-    };
-    spawned.once('error', () => {
-      if (child !== spawned) return;
-      try { spawned.kill('SIGTERM'); } catch { /* already gone */ }
-      finalize();
-    });
-    spawned.once('exit', finalize);
-    spawned.once('close', finalize);
-  };
-
-  const unavailable = (res, status) => res.status(status).json({ error: 'browser unavailable' });
-  const proxyHttp = (api) => (req, res, next) => {
-    if (!api && !claimedBrowserRequest(req)) return next();
-    const targetPort = port;
-    if (!targetPort) return unavailable(res, api ? 503 : 502);
-    const upstream = request({
-      hostname: '127.0.0.1',
-      port: targetPort,
-      method: req.method,
-      path: req.originalUrl || req.url,
-      headers: forwardedHeaders(req.headers, internalToken, appToken, api),
-    }, (incoming) => {
-      res.writeHead(incoming.statusCode || 502, incoming.headers);
-      incoming.pipe(res);
-      res.once('close', () => { if (!res.writableEnded) incoming.destroy(); });
-    });
-    if (api) upstream.setTimeout?.(requestTimeoutMs, () => upstream.destroy(new Error('browser worker request timeout')));
-    const abort = () => upstream.destroy();
-    req.once('aborted', abort);
-    res.once('close', () => { if (!res.writableEnded) abort(); });
-    upstream.once('error', () => {
-      if (!res.headersSent) unavailable(res, api ? 503 : 502);
-      else res.destroy();
-    });
-    req.pipe(upstream);
-  };
-
-  const onUpgrade = (req, socket, head) => {
-    if (!claimedBrowserRequest(req)) return false;
-    const targetPort = port;
-    if (!targetPort) { socket.destroy(); return true; }
-    const upstream = connect({ host: '127.0.0.1', port: targetPort });
-    activeSockets.add(socket);
-    activeSockets.add(upstream);
-    const cleanup = () => {
-      activeSockets.delete(socket);
-      activeSockets.delete(upstream);
-    };
-    upstream.once('connect', () => {
-      const headers = forwardedHeaders(req.headers, internalToken, appToken, false);
-      const lines = [`${req.method || 'GET'} ${req.url} HTTP/${req.httpVersion || '1.1'}`];
-      for (const [name, value] of Object.entries(headers)) {
-        if (Array.isArray(value)) for (const item of value) lines.push(`${name}: ${item}`);
-        else if (value != null) lines.push(`${name}: ${value}`);
-      }
-      upstream.write(`${lines.join('\r\n')}\r\n\r\n`);
-      if (head?.length) upstream.write(head);
-      socket.pipe(upstream).pipe(socket);
-    });
-    upstream.once('error', () => socket.destroy());
-    socket.once('error', () => upstream.destroy());
-    upstream.once('close', cleanup);
-    socket.once('close', cleanup);
-    return true;
-  };
-
-  const proxyRequest = ({ req, method, path, body }) => new Promise((resolve) => {
-    const targetPort = port;
-    if (!targetPort) return resolve(null);
-    const payload = body === undefined ? null : Buffer.from(JSON.stringify(body));
-    const headers = forwardedHeaders(req.headers, internalToken, appToken, true);
-    if (payload) {
-      headers['content-type'] = 'application/json';
-      headers['content-length'] = String(payload.length);
-    } else {
-      delete headers['content-length'];
-      delete headers['content-type'];
-    }
-    const upstream = request({ hostname: '127.0.0.1', port: targetPort, method, path, headers }, (incoming) => {
-      const chunks = [];
-      incoming.on('data', (chunk) => chunks.push(chunk));
-      incoming.on('end', () => resolve({
-        status: incoming.statusCode || 502,
-        headers: incoming.headers,
-        body: Buffer.concat(chunks),
-      }));
-    });
-    upstream.setTimeout?.(requestTimeoutMs, () => upstream.destroy(new Error('browser worker request timeout')));
-    upstream.once('error', () => resolve(null));
-    req.once('aborted', () => upstream.destroy());
-    upstream.end(payload || undefined);
-  });
-
-  const apiHandler = createBrowserCoordinator({
-    proxyRequest,
-    getStatus: () => ({ ready: port != null, generation }),
-  });
-
-  if (previewDomain) start();
-  let closePromise = null;
-  return {
-    apiHandler,
-    publicHandler: proxyHttp(false),
-    onUpgrade,
-    close() {
-      if (!closePromise) {
-        stopping = true;
-        apiHandler.close();
-        if (restartTimer != null) clearTimer(restartTimer);
-        restartTimer = null;
-        clearReadyTimer();
-        clearStableTimer();
-        for (const socket of activeSockets) socket.destroy();
-        activeSockets.clear();
-        const current = child;
-        if (!current) closePromise = Promise.resolve();
-        else closePromise = new Promise((resolve) => {
-          let finished = false;
-          let forceTimer = setTimer(() => {
-            forceTimer = null;
-            current.kill('SIGKILL');
-          }, stopTimeoutMs);
-          const finish = () => {
-            if (finished) return;
-            finished = true;
-            if (forceTimer != null) clearTimer(forceTimer);
-            resolve();
-          };
-          current.once('error', finish);
-          current.once('exit', finish);
-          current.once('close', finish);
-          try { current.kill('SIGTERM'); } catch { finish(); }
-        });
-      }
-      return closePromise;
-    },
-  };
-}

package/src/browser/workerServer.js

@@ -1,98 +0,0 @@
-import http from 'node:http';
-import express from 'express';
-import { tokenEquals } from '../auth.js';
-import { createBrowserPreviewManager } from './manager.js';
-import { createBrowserBootstrapStore } from './bootstrap.js';
-import { createBrowserPublicProxy } from './publicProxy.js';
-import { browserRoutes } from './routes.js';
-import { BROWSER_INTERNAL_HEADER } from './protocol.js';
-
-function isLoopback(address) {
-  return address === '127.0.0.1' || address === '::1' || String(address || '').startsWith('::ffff:127.');
-}
-
-function authenticated(req, token) {
-  const provided = req.headers[BROWSER_INTERNAL_HEADER];
-  return isLoopback(req.socket?.remoteAddress)
-    && typeof provided === 'string'
-    && tokenEquals(provided, token);
-}
-
-export async function createBrowserWorkerServer({
-  internalToken,
-  previewDomain = null,
-  handmuxOrigin = 'http://127.0.0.1',
-  browser: suppliedBrowser = null,
-  managerFactory = createBrowserPreviewManager,
-  browserPublicFactory = createBrowserPublicProxy,
-  host = '127.0.0.1',
-  port = 0,
-} = {}) {
-  if (!internalToken) throw new Error('browser worker internal token required');
-  const browserBootstrap = createBrowserBootstrapStore();
-  const browser = suppliedBrowser || await managerFactory({
-    handmuxOrigin,
-    previewDomain,
-    browserBootstrap,
-  });
-  const browserPublic = browserPublicFactory({ browser, browserBootstrap });
-  const app = express();
-
-  app.use((req, res, next) => {
-    if (!authenticated(req, internalToken)) return res.status(401).json({ error: 'browser worker unauthorized' });
-    delete req.headers[BROWSER_INTERNAL_HEADER];
-    next();
-  });
-  app.get('/_browser-worker/health', (_req, res) => res.json({ ok: true }));
-  app.use(
-    '/api/browser-proxy',
-    express.json(),
-    browserRoutes({ browser, previewDomain, browserBootstrap }),
-  );
-  app.use(browserPublic.handler);
-
-  const server = http.createServer(app);
-  const sockets = new Set();
-  server.on('connection', (socket) => {
-    sockets.add(socket);
-    socket.once('close', () => sockets.delete(socket));
-  });
-  server.on('upgrade', (req, socket, head) => {
-    if (!authenticated(req, internalToken)) {
-      socket.end('HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n');
-      return;
-    }
-    delete req.headers[BROWSER_INTERNAL_HEADER];
-    if (!browserPublic.onUpgrade(req, socket, head)) socket.destroy();
-  });
-
-  await new Promise((resolve, reject) => {
-    const onError = (error) => { server.off('listening', onListening); reject(error); };
-    const onListening = () => { server.off('error', onError); resolve(); };
-    server.once('error', onError);
-    server.once('listening', onListening);
-    server.listen(port, host);
-  });
-
-  let closePromise = null;
-  return {
-    host,
-    port: server.address().port,
-    server,
-    browser,
-    close() {
-      if (!closePromise) {
-        closePromise = (async () => {
-          const stopped = new Promise((resolve) => server.close(resolve));
-          server.closeIdleConnections?.();
-          for (const socket of sockets) socket.destroy();
-          try { await browser.close?.(); } finally {
-            server.closeAllConnections?.();
-            await stopped;
-          }
-        })();
-      }
-      return closePromise;
-    },
-  };
-}