@livedesk/hub 0.1.73 → 0.1.75

package/src/console-upnp-gateway.mjs

@@ -0,0 +1,230 @@
+import dgram from 'node:dgram';
+import { execFile } from 'node:child_process';
+import { networkInterfaces, platform } from 'node:os';
+import { isIP } from 'node:net';
+
+export function isPrivateRouterIPv4(address) {
+  if (isIP(address) !== 4) return false;
+  const [a, b] = address.split('.').map(Number);
+  return a === 10 || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168);
+}
+
+export function isPublicRouterIPv4(address) {
+  if (isIP(address) !== 4 || isPrivateRouterIPv4(address)) return false;
+  const [a, b, c] = address.split('.').map(Number);
+  return a > 0 && a < 224 && a !== 127 && !(a === 169 && b === 254)
+    && !(a === 100 && b >= 64 && b <= 127)
+    && !(a === 192 && b === 0 && [0, 2].includes(c))
+    && !(a === 198 && [18, 19, 51].includes(b)) && !(a === 203 && b === 0 && c === 113);
+}
+
+function command(file, args, signal) {
+  return new Promise((resolve, reject) => {
+    execFile(file, args, { signal, timeout: 1800, maxBuffer: 16 * 1024, windowsHide: true },
+      (error, stdout) => error ? reject(new Error('router-route-unavailable')) : resolve(stdout));
+  });
+}
+
+export function parseDefaultRouterRoute(os, output, interfaces = networkInterfaces()) {
+  let address, localAddress;
+  if (os === 'win32') {
+    const data = JSON.parse(output);
+    address = data.gateway;
+    localAddress = data.address;
+  } else if (os === 'linux') {
+    const data = JSON.parse(output)?.[0];
+    address = data?.gateway;
+    localAddress = data?.prefsrc;
+  } else if (os === 'darwin') {
+    address = output.match(/^\s*gateway:\s*(\S+)\s*$/m)?.[1];
+    const device = output.match(/^\s*interface:\s*(\S+)\s*$/m)?.[1];
+    localAddress = interfaces[device]?.find(item => item.family === 'IPv4' && !item.internal)?.address;
+  }
+  const local = Object.values(interfaces).flat().some(item => (
+    item?.family === 'IPv4' && !item.internal && item.address === localAddress
+  ));
+  if (!local || !isPrivateRouterIPv4(address) || !isPrivateRouterIPv4(localAddress)) {
+    throw new Error('router-route-unavailable');
+  }
+  return { address, localAddress };
+}
+
+async function resolveRoute(signal) {
+  const os = platform();
+  let output;
+  if (os === 'win32') {
+    // Fixed command, no caller text or shell interpolation. Find-NetRoute reads
+    // the selected route; it sends no traffic to this reference destination.
+    output = await command('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command',
+      "$r = Find-NetRoute -RemoteIPAddress 1.1.1.1; $a = $r | Where-Object { $_.IPAddress } | Select-Object -First 1; $g = $r | Where-Object { $_.NextHop } | Select-Object -First 1; @{ address=$a.IPAddress; gateway=$g.NextHop } | ConvertTo-Json -Compress"], signal);
+  } else if (os === 'linux') output = await command('ip', ['-j', 'route', 'get', '1.1.1.1'], signal);
+  else if (os === 'darwin') output = await command('/sbin/route', ['-n', 'get', '1.1.1.1'], signal);
+  else throw new Error('router-platform-unavailable');
+  return parseDefaultRouterRoute(os, output);
+}
+
+export function routerUrl(value, gateway, base) {
+  const url = new URL(value, base);
+  if (url.protocol !== 'http:' || url.hostname !== gateway || url.username || url.password || url.hash) {
+    throw new Error('router-control-url-invalid');
+  }
+  return url;
+}
+
+async function discoverLocation(route, signal) {
+  signal.throwIfAborted();
+  const socket = dgram.createSocket('udp4');
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (error, location) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal.removeEventListener('abort', abort);
+      try { socket.close(); } catch { /* no bound UDP handle remains */ }
+      error ? reject(error) : resolve(location);
+    };
+    const abort = () => finish(new Error('router-discovery-cancelled'));
+    const timer = setTimeout(() => finish(new Error('router-discovery-unavailable')), 1200);
+    signal.addEventListener('abort', abort, { once: true });
+    socket.once('error', () => finish(new Error('router-discovery-unavailable')));
+    socket.on('message', (message, source) => {
+      if (source.address !== route.address || message.length > 8192) return;
+      const location = message.toString().match(/^location:\s*(\S+)\s*$/im)?.[1];
+      if (!location) return;
+      try { finish(null, routerUrl(location, route.address)); } catch { /* ignore unrelated SSDP */ }
+    });
+    socket.bind(0, route.localAddress, () => {
+      if (settled) return;
+      socket.setMulticastTTL(1);
+      socket.send(Buffer.from('M-SEARCH * HTTP/1.1\r\nHOST: 239.255.255.250:1900\r\nMAN: "ssdp:discover"\r\nMX: 1\r\nST: urn:schemas-upnp-org:device:InternetGatewayDevice:1\r\n\r\n'),
+        1900, '239.255.255.250', error => { if (error) finish(new Error('router-discovery-unavailable')); });
+    });
+  });
+}
+
+export function upnpField(xml, name) {
+  return xml.match(new RegExp(`<(?:[\\w-]+:)?${name}\\b[^>]*>\\s*([^<]*)\\s*</(?:[\\w-]+:)?${name}>`))?.[1]?.trim();
+}
+
+async function boundedText(response, limit) {
+  const reader = response.body?.getReader();
+  if (!reader) throw new Error('router-response-invalid');
+  let bytes = 0;
+  const chunks = [];
+  try {
+    while (true) {
+      const next = await reader.read();
+      if (next.done) break;
+      bytes += next.value.byteLength;
+      if (bytes > limit) {
+        await reader.cancel().catch(() => {});
+        throw new Error('router-response-too-large');
+      }
+      chunks.push(next.value);
+    }
+    return Buffer.concat(chunks, bytes).toString('utf8');
+  } finally { reader.releaseLock(); }
+}
+
+export function parseUpnpService(document, location, gateway) {
+  if (document.length > 64 * 1024 || /<!DOCTYPE|<!ENTITY/i.test(document)) throw new Error('router-description-invalid');
+  const base = upnpField(document, 'URLBase') || location;
+  routerUrl(base, gateway);
+  for (const match of document.matchAll(/<(?:[\w-]+:)?service>([\s\S]*?)<\/(?:[\w-]+:)?service>/g)) {
+    const service = upnpField(match[1], 'serviceType');
+    const control = upnpField(match[1], 'controlURL');
+    if (/^urn:schemas-upnp-org:service:WAN(?:IP|PPP)Connection:[12]$/.test(service || '') && control) {
+      return { service, control: routerUrl(control, gateway, base) };
+    }
+  }
+  throw new Error('router-service-unavailable');
+}
+
+export function createUpnpSoapGateway(route, endpoint, fetchImpl = fetch) {
+  const controlUrl = routerUrl(endpoint.control, route.address);
+  async function soap(action, fields, signal) {
+    signal.throwIfAborted();
+    const escape = value => String(value).replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&apos;' })[c]);
+    const xml = Object.entries(fields).map(([key, value]) => `<${key}>${escape(value)}</${key}>`).join('');
+    const response = await fetchImpl(controlUrl, {
+      method: 'POST', redirect: 'error', signal,
+      headers: { 'Content-Type': 'text/xml; charset="utf-8"', SOAPAction: `"${endpoint.service}#${action}"` },
+      body: `<?xml version="1.0"?><s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"><s:Body><u:${action} xmlns:u="${endpoint.service}">${xml}</u:${action}></s:Body></s:Envelope>`
+    });
+    const body = await boundedText(response, 8192);
+    const error = Number(upnpField(body, 'errorCode') || 0);
+    if (error === 714 && action === 'GetSpecificPortMappingEntry') return null;
+    if (!response.ok || error || !body.includes(`${action}Response`)) throw new Error('router-request-rejected');
+    return body;
+  }
+  const identity = port => ({ NewRemoteHost: '', NewExternalPort: port, NewProtocol: 'UDP' });
+  return {
+    ...route,
+    async requirePublicWan(signal) {
+      const address = upnpField(await soap('GetExternalIPAddress', {}, signal), 'NewExternalIPAddress');
+      if (!isPublicRouterIPv4(address)) {
+        throw new Error('router-public-address-unavailable');
+      }
+      return address;
+    },
+    async read(port, signal) {
+      const body = await soap('GetSpecificPortMappingEntry', identity(port), signal);
+      return body === null ? null : {
+        localAddress: upnpField(body, 'NewInternalClient'),
+        port: Number(upnpField(body, 'NewInternalPort')),
+        description: upnpField(body, 'NewPortMappingDescription'),
+        leaseSeconds: Number(upnpField(body, 'NewLeaseDuration')),
+        enabled: upnpField(body, 'NewEnabled') === '1'
+      };
+    },
+    async add(port, internalPort, description, signal) {
+      await soap('AddPortMapping', { ...identity(port), NewInternalPort: internalPort,
+        NewInternalClient: route.localAddress, NewEnabled: 1,
+        NewPortMappingDescription: description, NewLeaseDuration: 120 }, signal);
+    },
+    async remove(port, signal) { await soap('DeletePortMapping', identity(port), signal); }
+  };
+}
+
+export async function discoverConsoleUpnpGateway(signal) {
+  const route = await resolveRoute(signal);
+  const location = await discoverLocation(route, signal);
+  const response = await fetch(location, { redirect: 'error', signal });
+  if (!response.ok) throw new Error('router-description-unavailable');
+  const endpoint = parseUpnpService(await boundedText(response, 64 * 1024), location, route.address);
+  const gateway = createUpnpSoapGateway(route, endpoint);
+  gateway.publicAddress = await gateway.requirePublicWan(signal);
+  return gateway;
+}
+
+// Reserve an OS-assigned socket before exposing a port at the router. The
+// caller closes this exact reservation immediately before native ICE binds it.
+export function reserveConsoleIceSocket(route, signal, port = 0) {
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const socket = dgram.createSocket('udp4');
+    let settled = false;
+    let closePromise;
+    const close = () => closePromise ||= new Promise(done => {
+      try { socket.close(done); } catch { done(); }
+    });
+    const failed = error => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener('abort', failed);
+      void close();
+      const failure = new Error('router-socket-reservation-unavailable');
+      if (error?.code === 'EADDRINUSE') failure.code = 'EADDRINUSE';
+      reject(failure);
+    };
+    socket.on('error', failed);
+    signal.addEventListener('abort', failed, { once: true });
+    socket.bind(port, route.localAddress, () => {
+      if (settled || signal.aborted) { void close(); return; }
+      settled = true;
+      signal.removeEventListener('abort', failed);
+      resolve({ port: socket.address().port, close });
+    });
+  });
+}

package/src/plan-device-access.test.mjs

@@ -15,7 +15,7 @@ const clients = [6, 3, 1, 5, 2, 4].map(slotNumber => ({
 }));
 
 test('Hub and browser choose the same stable Free, Plus, Pro, and Team device owners', () => {
-  for (const limit of [5, 15, 50, Number.POSITIVE_INFINITY]) {
+  for (const limit of [5, 20, 50, Number.POSITIVE_INFINITY]) {
     assert.deepEqual(
       stableHubPlanAllowedDeviceIds(clients, limit),
       stableBrowserPlanAllowedDeviceIds(clients, limit)
@@ -27,15 +27,21 @@ test('Hub and browser choose the same stable Free, Plus, Pro, and Team device ow
   );
 });
 
-test('Plus stops at 15 Clients, Pro stops at 50, and Team remains unbounded', () => {
+test('Plus stops at 20 Clients, Pro stops at 50, and Team remains unbounded', () => {
   const manyClients = Array.from({ length: 51 }, (_, index) => ({
     deviceId: `client-${index + 1}`,
     slotNumber: index + 1,
     connected: true
   }));
 
-  assert.equal(createPlanDeviceAccessSnapshot(manyClients, 15).allowedDeviceIds.length, 15);
-  assert.equal(createPlanDeviceAccessSnapshot(manyClients, 15).blockedDeviceIds.length, 36);
+  assert.equal(createPlanDeviceAccessSnapshot(manyClients, 20).allowedDeviceIds.length, 20);
+  assert.equal(createPlanDeviceAccessSnapshot(manyClients, 20).blockedDeviceIds.length, 31);
+  const plus = createPlanDeviceAccessSnapshot(manyClients, 20);
+  assert.equal(plus.allowedDeviceIdSet.has('client-20'), true);
+  assert.equal(plus.allowedDeviceIdSet.has('client-21'), false);
+  assert.deepEqual(partitionPlanDeviceIds(['client-20', 'client-21'], plus), {
+    allowedDeviceIds: ['client-20'], blockedDeviceIds: ['client-21']
+  });
   assert.equal(createPlanDeviceAccessSnapshot(manyClients, 50).allowedDeviceIds.length, 50);
   assert.deepEqual(createPlanDeviceAccessSnapshot(manyClients, 50).blockedDeviceIds, ['client-51']);
   assert.equal(

package/src/server.js

@@ -178,7 +178,7 @@ const atlasPool = new Mode4AtlasPool({
 const inputClients = new Set();
 const audioClients = new Set();
 const FREE_DEVICE_LIMIT = 5;
-const PLUS_DEVICE_LIMIT = 15;
+const PLUS_DEVICE_LIMIT = 20;
 const PRO_DEVICE_LIMIT = 50;
 const LICENSE_VERIFY_MAX_AGE_MS = 6 * 60 * 60 * 1000;
 const ROLE_TRANSITION_EXIT_CODE = 43;
@@ -1880,6 +1880,9 @@ hubConsoleDirect = createHubConsoleDirect({
   deviceId: runtimeDeviceId,
   httpBaseUrl: `http://127.0.0.1:${httpPort}`,
   stunUrls: hubConsoleDirectStunUrls,
+  icePortRange: process.env.LIVEDESK_CONSOLE_ICE_PORT_RANGE,
+  isRouterMappingEnabled: () => runtimeRole === 'hub'
+    && liveDeskSettingsStore.getCached()?.connection?.temporaryRouterMapping === true,
   getAccessToken: () => getRuntimeAccessToken(),
   getWorkspaceAccess: () => runtimeWorkspaceAccess,
   consoleProxyToken
@@ -5152,7 +5155,10 @@ app.patch('/api/settings', async (req, res) => {
     const revision = body.revision === undefined ? undefined : Number(body.revision);
     const patch = { ...body };
     delete patch.revision;
-    const record = await liveDeskSettingsStore.update(patch, revision);
+    const record = await liveDeskSettingsStore.update(patch, revision);
+    if (patch.connection?.temporaryRouterMapping === false) {
+      await hubConsoleDirect?.releaseRouterMappings();
+    }
     if (patch.agent && Object.prototype.hasOwnProperty.call(patch.agent, 'enabled')) {
       await agentSettingsStore.update({ enabled: record.settings.agent?.enabled === true });
     }
@@ -7811,7 +7817,8 @@ function shutdownHub(signal) {
     forceCloseTimer.unref?.();
 
     const cleanupBudgetMs = Math.max(500, hubShutdownTimeoutMs - hubShutdownGraceMs - 500);
-    await Promise.all([
+    await Promise.all([
+      boundedShutdownStep('temporary router mappings removed', () => hubConsoleDirect?.releaseRouterMappings(), cleanupBudgetMs),
       boundedShutdownStep('atlas pool closed', () => atlasPool.close(), cleanupBudgetMs),
       boundedShutdownStep('host target lease cleared', () => clearHubHostTarget(`process-${String(signal).toLowerCase()}`), Math.min(3_000, cleanupBudgetMs)),
       boundedShutdownStep('remote transport closed', () => remoteHub.close(), cleanupBudgetMs)

package/src/settings/settings-schema.js

@@ -13,7 +13,8 @@ export const DEFAULT_LIVEDESK_SETTINGS = Object.freeze({
     approveNewDevices: true,
     startWithComputer: true,
     keepRunningInTray: true,
-    showConnectionNotifications: true,
+    showConnectionNotifications: true,
+    temporaryRouterMapping: false,
     showThisComputer: false
   },
   security: {
@@ -180,7 +181,7 @@ export function migrateLiveDeskSettings(value = {}) {
 
 const RULES = {
   connection: {
-    ...bools(['usePinToAddDevices', 'rotatePinAfterPairing', 'allowNewDevices', 'approveNewDevices', 'startWithComputer', 'keepRunningInTray', 'showConnectionNotifications', 'showThisComputer']),
+    ...bools(['usePinToAddDevices', 'rotatePinAfterPairing', 'allowNewDevices', 'approveNewDevices', 'startWithComputer', 'keepRunningInTray', 'showConnectionNotifications', 'temporaryRouterMapping', 'showThisComputer']),
     ...numbers([['pinValidityMinutes', 10, 1440]])
   },
   security: {