livedesk 0.1.253 → 0.1.255

package/README.md

@@ -13,15 +13,15 @@ This starts the LiveDesk Hub, opens the local screen wall, and accepts clients.
 The Hub UI/API listens on `127.0.0.1` by default while the client endpoint
 continues to listen on the LAN.
 
-On startup, the launcher finds stale processes whose command line identifies
-them as a LiveDesk Hub, even if the old Hub is still starting and has not
-finished binding its ports. It also checks the Hub ports (`5179` and `5197`),
-waits for stale LiveDesk processes to exit, and then starts the new Hub. The
-client endpoint remains fixed at TCP `5197` by default so firewall rules,
-router forwarding, and direct clients keep a stable contract. An unrelated
-process is preserved and reported instead of being terminated; stop it or use
-an explicit `--remote-port` value. Pass `--no-clean` to disable the startup
-cleanup explicitly.
+On startup, the launcher checks the Hub ports (`5179` and `5197`), identifies
+stale LiveDesk Hub processes from their Node command line, stops each PID only
+once, waits for the ports to be released and bindable, and then starts the new
+Hub. Unrelated processes are preserved and reported with their PID, name, and
+command line. The client endpoint remains fixed at TCP `5197` by default so
+firewall rules, router forwarding, and direct clients keep a stable contract.
+Pass `--no-clean` to disable the startup cleanup explicitly. If a child Hub
+still loses a startup race with `EADDRINUSE`, the launcher performs one cleanup
+and startup retry, then exits without looping.
 
 ## Client
 

package/bin/livedesk.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import { createRequire } from 'node:module';
+import net from 'node:net';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execFile, spawn } from 'node:child_process';
@@ -14,6 +15,9 @@ const packageRoot = resolve(__dirname, '..');
 const DEFAULT_MANAGER_HTTP_PORT = 5179;
 const DEFAULT_REMOTE_HUB_PORT = 5197;
 const DEFAULT_MANAGER_URL = `http://127.0.0.1:${DEFAULT_MANAGER_HTTP_PORT}`;
+const PORT_CLEANUP_TIMEOUT_MS = 3000;
+const PORT_CLEANUP_POLL_MS = 100;
+const HUB_STARTUP_RETRY_LIMIT = 1;
 const MANAGER_STATE_DIR = join(os.homedir(), '.livedesk');
 const MANAGER_STATE_PATH = join(MANAGER_STATE_DIR, 'manager.json');
 
@@ -212,6 +216,134 @@ function runQuiet(command, args) {
   });
 }
 
+function waitMilliseconds(milliseconds) {
+  return new Promise(resolve => setTimeout(resolve, milliseconds));
+}
+
+function canBindPort(port, host = '0.0.0.0') {
+  return new Promise(resolve => {
+    const server = net.createServer();
+    let settled = false;
+    const finish = value => {
+      if (settled) return;
+      settled = true;
+      resolve(value);
+    };
+    server.once('error', () => finish(false));
+    server.listen(port, host, () => {
+      server.close(() => finish(true));
+    });
+  });
+}
+
+function isKnownLiveDeskProcess(processName, commandLine) {
+  const normalizedName = String(processName || '').trim();
+  const normalizedCommandLine = String(commandLine || '').replaceAll('\\', '/');
+  return /^(?:node|node\.exe)$/i.test(normalizedName)
+    && /livedesk/i.test(normalizedCommandLine)
+    && /hub\/src\/server\.js/i.test(normalizedCommandLine)
+    && /(?:node_modules\/livedesk|packages\/livedesk)\/hub\/src\/server\.js/i.test(normalizedCommandLine);
+}
+
+function isPortConflictOutput(output) {
+  return /\bEADDRINUSE\b|address already in use|requires client endpoint TCP \d+/i.test(String(output || ''));
+}
+
+function formatPortOwner(record) {
+  return `${record?.Pid || 'unknown'}:${record?.ProcessName || 'unknown'} cmd=${String(record?.CommandLine || 'unavailable').replace(/\s+/g, ' ').slice(0, 240)}`;
+}
+
+function assertPortCleanupReady(finalRecords, portStates) {
+  const blockedPorts = portStates.filter(port => port?.Ready !== true);
+  if (blockedPorts.length === 0) {
+    return;
+  }
+
+  const summary = blockedPorts.map(port => {
+    const owners = finalRecords
+      .filter(record => Number(record?.Port) === Number(port?.Port))
+      .map(formatPortOwner);
+    return `TCP ${port.Port}[available=${port.PortAvailable === true},bindable=${port.PortBindable === true},owners=${owners.length ? owners.join('; ') : 'owner not visible'}`;
+  }).join('], ');
+  throw new Error(`LiveDesk Hub startup cleanup could not release the configured port(s): ${summary}]. Unrelated processes are preserved; stop the owning process manually or choose an explicit --port/--remote-port value.`);
+}
+
+async function collectUnixPortRecords(ports) {
+  const records = [];
+  for (const port of ports) {
+    const lsof = await runQuiet('lsof', ['-nP', '-ti', `tcp:${port}`, '-sTCP:LISTEN']);
+    if (!lsof.ok && !lsof.stdout) {
+      throw new Error(`Could not inspect listening port TCP ${port}: ${lsof.stderr || lsof.error?.message || 'lsof failed'}`);
+    }
+    const pids = [...new Set(lsof.stdout.split(/\r?\n/).map(value => Number(value.trim())).filter(Number.isInteger))];
+    for (const pid of pids) {
+      const [nameResult, commandResult] = await Promise.all([
+        runQuiet('ps', ['-p', String(pid), '-o', 'comm=']),
+        runQuiet('ps', ['-p', String(pid), '-o', 'args='])
+      ]);
+      const processName = nameResult.stdout.trim();
+      const commandLine = commandResult.stdout.trim();
+      records.push({
+        Port: port,
+        Pid: pid,
+        ProcessName: processName,
+        CommandLine: commandLine,
+        KnownLiveDesk: isKnownLiveDeskProcess(processName, commandLine),
+        Action: 'preserved'
+      });
+    }
+  }
+  const unique = new Map();
+  for (const record of records) {
+    unique.set(`${record.Port}:${record.Pid}`, record);
+  }
+  return [...unique.values()];
+}
+
+async function stopUnixProcessesOnPorts(ports) {
+  const records = await collectUnixPortRecords(ports);
+  const killedPids = new Set();
+  for (const record of records) {
+    if (!record.KnownLiveDesk || killedPids.has(record.Pid)) continue;
+    killedPids.add(record.Pid);
+    await runQuiet('kill', ['-KILL', String(record.Pid)]);
+    for (const matching of records.filter(candidate => candidate.Pid === record.Pid)) {
+      matching.Action = 'stopped';
+    }
+  }
+
+  const deadline = Date.now() + PORT_CLEANUP_TIMEOUT_MS;
+  let finalRecords = [];
+  let portStates = [];
+  do {
+    finalRecords = await collectUnixPortRecords(ports);
+    portStates = [];
+    for (const port of ports) {
+      const busy = finalRecords.some(record => Number(record.Port) === Number(port));
+      const bindable = busy ? false : await canBindPort(port);
+      portStates.push({
+        Port: port,
+        PortAvailable: !busy,
+        PortBindable: bindable,
+        Ready: !busy && bindable
+      });
+    }
+    if (portStates.every(state => state.Ready) || Date.now() >= deadline) break;
+    await waitMilliseconds(PORT_CLEANUP_POLL_MS);
+  } while (true);
+
+  const stopped = records.filter(record => record.Action === 'stopped');
+  if (stopped.length > 0) {
+    const stoppedOwners = new Map();
+    for (const record of stopped) {
+      if (!stoppedOwners.has(String(record.Pid))) stoppedOwners.set(String(record.Pid), record);
+    }
+    const summary = [...stoppedOwners.values()].map(record => `${record.Pid}:${record.ProcessName || 'node'}`).join(', ');
+    console.log(`Restarting LiveDesk Hub. Stopped stale LiveDesk owner(s) once: ${summary}`);
+  }
+  assertPortCleanupReady(finalRecords, portStates);
+}
+
 async function stopProcessesOnPorts(ports) {
   const uniquePorts = [...new Set(ports.map(port => normalizePort(port, 0)).filter(Boolean))];
   if (uniquePorts.length === 0) {
@@ -223,19 +355,6 @@ async function stopProcessesOnPorts(ports) {
       '$ErrorActionPreference = "SilentlyContinue";',
       `$ports = @(${uniquePorts.join(',')});`,
       `$currentNodePid = ${process.pid};`,
-      '      $liveDeskProcessPattern = "(?i)(?:livedesk|@livedesk)";',
-      '      $hubServerProcessPattern = "(?i)(?:hub[\\\\/].*server\\.js|server\\.js)";',
-      'function Get-ProcessCommandChain($proc) {',
-      '  $chain = @();',
-      '  $current = $proc;',
-      '  for ($depth = 0; $current -and $depth -lt 8; $depth++) {',
-      '    $chain += [string]$current.CommandLine;',
-      '    $parentId = [int]$current.ParentProcessId;',
-      '    if ($parentId -le 0) { break }',
-      '    $current = Get-CimInstance Win32_Process -Filter "ProcessId = $parentId" -ErrorAction SilentlyContinue;',
-      '  }',
-      '  return ($chain -join " ");',
-      '}',
       'function Get-ListenConnections($port) {',
       '  $connections = @(Get-NetTCPConnection -LocalPort $port -State Listen -ErrorAction SilentlyContinue);',
       '  if ($connections.Count -gt 0) { return $connections }',
@@ -247,87 +366,93 @@ async function stopProcessesOnPorts(ports) {
       '    }',
       '  }',
       '}',
-      '$records = foreach ($port in $ports) {',
-      '  $connections = @(Get-ListenConnections $port | Where-Object { $_.OwningProcess -and $_.OwningProcess -ne $currentNodePid });',
+      'function Get-PortRecords($port) {',
+      '  $connections = @(Get-ListenConnections $port | Where-Object { $_.OwningProcess -and $_.OwningProcess -ne $currentNodePid -and $_.OwningProcess -ne $PID });',
       '  foreach ($connection in $connections) {',
       '    $owner = [int]$connection.OwningProcess;',
       '    $proc = Get-CimInstance Win32_Process -Filter "ProcessId = $owner" -ErrorAction SilentlyContinue;',
       '    $processName = if ($proc) { [string]$proc.Name } else { "" };',
       '    $commandLine = if ($proc) { [string]$proc.CommandLine } else { "" };',
-      '    $commandChain = if ($proc) { Get-ProcessCommandChain $proc } else { "" };',
-      '    $knownLiveDesk = ($processName -match "(?i)^node(?:\\.exe)?$") -and ($commandChain -match $liveDeskProcessPattern) -and ($commandChain -match $hubServerProcessPattern);',
-      '    [pscustomobject]@{ Port = [int]$port; Pid = $owner; ProcessName = $processName; CommandLine = $commandLine; KnownLiveDesk = [bool]$knownLiveDesk; Action = "preserved"; PortAvailable = $false; ProcessGone = $false }',
+      '    $isNodeProcess = $processName -match "(?i)^node(?:\\.exe)?$";',
+      '    $hasLiveDeskToken = $commandLine -match "(?i)livedesk";',
+      '    $hasHubServerPath = $commandLine -match "(?i)hub[\\\\/]src[\\\\/]server\\.js";',
+      '    $hasPackagedHubPath = $commandLine -match "(?i)(?:node_modules|packages)[\\\\/]livedesk[\\\\/]hub[\\\\/]src[\\\\/]server\\.js";',
+      '    $knownLiveDesk = [bool]($isNodeProcess -and $hasLiveDeskToken -and $hasHubServerPath -and $hasPackagedHubPath);',
+      '    [pscustomobject]@{ Port = [int]$port; Pid = $owner; ProcessName = $processName; CommandLine = $commandLine; KnownLiveDesk = $knownLiveDesk; Action = "preserved"; KillAttempted = $false }',
       '  }',
       '}',
-      '$records = @($records | Sort-Object Port,Pid -Unique);',
-      '$hubProcesses = @(Get-CimInstance Win32_Process -ErrorAction SilentlyContinue | Where-Object { $_.ProcessId -and $_.ProcessId -ne $currentNodePid -and ([string]$_.Name) -ieq "node.exe" } | ForEach-Object {',
-      '  $commandChain = Get-ProcessCommandChain $_;',
-      '  if (($commandChain -match $liveDeskProcessPattern) -and ($commandChain -match $hubServerProcessPattern)) {',
-      '    [pscustomobject]@{ ProcessId = [int]$_.ProcessId; ParentProcessId = [int]$_.ParentProcessId; Name = [string]$_.Name; CommandLine = [string]$_.CommandLine; CommandChain = $commandChain }',
-      '  }',
-      '});',
-      'foreach ($proc in $hubProcesses) {',
-      '  if (-not (@($records | Where-Object { $_.Pid -eq [int]$proc.ProcessId }).Count)) {',
-      '    $records += [pscustomobject]@{ Port = 0; Pid = [int]$proc.ProcessId; ProcessName = [string]$proc.Name; CommandLine = [string]$proc.CommandLine; KnownLiveDesk = $true; Action = "preserved"; PortAvailable = $false; ProcessGone = $false }',
+      'function Test-PortBindable($port) {',
+      '  $listener = $null;',
+      '  try {',
+      '    $listener = [System.Net.Sockets.TcpListener]::new([System.Net.IPAddress]::Any, [int]$port);',
+      '    $listener.Start();',
+      '    return $true;',
+      '  } catch {',
+      '    return $false;',
+      '  } finally {',
+      '    if ($listener) { $listener.Stop(); }',
       '  }',
       '}',
-      'foreach ($record in @($records | Where-Object { $_.KnownLiveDesk })) {',
-      '  Stop-Process -Id $record.Pid -Force -ErrorAction SilentlyContinue;',
-      '  $record.Action = "stopped";',
+      '$records = @($ports | ForEach-Object { Get-PortRecords $_ } | Sort-Object Port,Pid -Unique);',
+      '$killableOwners = @($records | Where-Object { $_.KnownLiveDesk } | Group-Object Pid | ForEach-Object { @($_.Group)[0] });',
+      'foreach ($owner in $killableOwners) {',
+      '  Stop-Process -Id $owner.Pid -Force -ErrorAction SilentlyContinue;',
+      '  foreach ($record in @($records | Where-Object { [int]$_.Pid -eq [int]$owner.Pid })) {',
+      '    $record.Action = "stopped";',
+      '    $record.KillAttempted = $true;',
+      '  }',
       '}',
-      '$deadline = (Get-Date).ToUniversalTime().AddMilliseconds(3000);',
+      `$deadline = (Get-Date).ToUniversalTime().AddMilliseconds(${PORT_CLEANUP_TIMEOUT_MS});`,
+      '$finalRecords = @();',
+      '$portStates = @();',
       'do {',
-      '  $busyPorts = @($ports | ForEach-Object { Get-ListenConnections $_ });',
-      '  $busyHubPids = @($records | Where-Object { $_.KnownLiveDesk } | ForEach-Object { Get-Process -Id $_.Pid -ErrorAction SilentlyContinue });',
-      '  if (($busyPorts.Count -eq 0 -and $busyHubPids.Count -eq 0) -or (Get-Date).ToUniversalTime() -ge $deadline) { break }',
-      '  Start-Sleep -Milliseconds 100;',
+      '  $finalRecords = @($ports | ForEach-Object { Get-PortRecords $_ });',
+      '  $busyPorts = @($finalRecords | Select-Object -ExpandProperty Port -Unique);',
+      '  $portStates = @($ports | ForEach-Object {',
+      '    $port = [int]$_;',
+      '    $busy = $busyPorts -contains $port;',
+      '    $bindable = if ($busy) { $false } else { Test-PortBindable $port };',
+      '    [pscustomobject]@{ Port = $port; PortAvailable = [bool](-not $busy); PortBindable = [bool]$bindable; Ready = [bool](-not $busy -and $bindable) }',
+      '  });',
+      '  if ((@($portStates | Where-Object { -not $_.Ready }).Count -eq 0) -or (Get-Date).ToUniversalTime() -ge $deadline) { break }',
+      `  Start-Sleep -Milliseconds ${PORT_CLEANUP_POLL_MS};`,
       '} while ($true);',
-      '$busyPortNumbers = @($busyPorts | Select-Object -ExpandProperty LocalPort -Unique);',
-      'foreach ($record in $records) {',
-      '  $record.PortAvailable = $busyPortNumbers -notcontains $record.Port;',
-      '  $record.ProcessGone = -not (Get-Process -Id $record.Pid -ErrorAction SilentlyContinue);',
-      '}',
-      '$records | ConvertTo-Json -Compress'
+      '[pscustomobject]@{ Records = @($records); FinalRecords = @($finalRecords); Ports = @($portStates) } | ConvertTo-Json -Compress -Depth 8'
     ].join(' ');
     const result = await runQuiet('powershell.exe', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', script]);
     if (!result.ok && !result.stdout) {
       throw new Error(`Could not inspect existing LiveDesk Hub ports: ${result.stderr || result.error?.message || 'PowerShell failed'}`);
     }
-    let records = [];
+    let payload = { Records: [], FinalRecords: [], Ports: [] };
     if (result.stdout) {
       try {
         const parsed = JSON.parse(result.stdout);
-        records = Array.isArray(parsed) ? parsed : [parsed];
+        payload = Array.isArray(parsed)
+          ? { Records: parsed, FinalRecords: parsed, Ports: [] }
+          : parsed;
       } catch {
         throw new Error(`Could not parse existing LiveDesk Hub port state: ${result.stdout}`);
       }
     }
+    const records = Array.isArray(payload?.Records) ? payload.Records : [];
+    const finalRecords = Array.isArray(payload?.FinalRecords) ? payload.FinalRecords : [];
+    const portStates = Array.isArray(payload?.Ports) ? payload.Ports : [];
     const stopped = records.filter(record => record?.Action === 'stopped');
     if (stopped.length > 0) {
-      const summary = stopped.map(record => `${record.Pid}:${record.ProcessName || 'node'}${record.Port ? `@${record.Port}` : ''}`).join(', ');
-      console.log(`Restarting LiveDesk Hub. Stopped stale LiveDesk owner(s): ${summary}`);
-    }
-    const blocked = records.filter(record => record?.PortAvailable !== true || (record?.Port === 0 && record?.ProcessGone !== true));
-    if (blocked.length > 0) {
-      const summary = blocked.map(record => `${record.Pid}:${record.ProcessName || 'unknown'}@${record.Port}[port-free=${record.PortAvailable === true},process-gone=${record.ProcessGone === true},cmd=${String(record.CommandLine || 'unavailable').replace(/\s+/g, ' ').slice(0, 240)}]`).join(', ');
-      throw new Error(`LiveDesk Hub startup cleanup could not release port/process owner(s): ${summary}. LiveDesk keeps the configured port fixed; stop that process or choose an explicit --port/--remote-port value.`);
+      const stoppedOwners = new Map();
+      for (const record of stopped) {
+        if (!stoppedOwners.has(String(record.Pid))) {
+          stoppedOwners.set(String(record.Pid), record);
+        }
+      }
+      const summary = [...stoppedOwners.values()].map(record => `${record.Pid}:${record.ProcessName || 'node'}`).join(', ');
+      console.log(`Restarting LiveDesk Hub. Stopped stale LiveDesk owner(s) once: ${summary}`);
     }
+    assertPortCleanupReady(finalRecords, portStates);
     return;
   }
 
-  const script = uniquePorts.map(port => [
-    `pids="$(lsof -ti tcp:${port} -sTCP:LISTEN 2>/dev/null || true)"`,
-    'for pid in $pids; do',
-    '  if [ "$pid" != "$$" ]; then',
-    '    kill "$pid" 2>/dev/null || true',
-    '    echo "$pid"',
-    '  fi',
-    'done'
-  ].join('; ')).join('; ');
-  const result = await runQuiet('sh', ['-c', script]);
-  if (result.stdout) {
-    console.log(`Restarting LiveDesk Hub. Cleared port owner(s): ${result.stdout.replace(/\r?\n/g, ', ')}`);
-  }
+  await stopUnixProcessesOnPorts(uniquePorts);
 }
 
 async function waitForManager(url = DEFAULT_MANAGER_URL, timeoutMs = 10000) {
@@ -386,23 +511,54 @@ async function runManager(args) {
     LIVEDESK_WEB_DIST: existsSync(resolve(packagedWebDist, 'index.html')) ? packagedWebDist : (process.env.LIVEDESK_WEB_DIST || '')
   };
 
-  const child = spawn(process.execPath, [hubEntry, ...options.forwarded], {
-    env,
-    stdio: 'inherit',
-    windowsHide: false
-  });
+  let startupRetryCount = 0;
+  const startHubProcess = () => {
+    const stderrChunks = [];
+    const child = spawn(process.execPath, [hubEntry, ...options.forwarded], {
+      env,
+      stdio: ['inherit', 'inherit', 'pipe'],
+      windowsHide: false
+    });
 
-  child.once('error', error => {
-    console.error(`Failed to start LiveDesk Hub: ${error.message}`);
-    process.exitCode = 1;
-  });
-  child.once('exit', (code, signal) => {
-    if (signal) {
-      process.kill(process.pid, signal);
-      return;
-    }
-    process.exit(code ?? 0);
-  });
+    child.stderr.on('data', chunk => {
+      const text = chunk.toString();
+      stderrChunks.push(text);
+      while (stderrChunks.join('').length > 16_000) {
+        stderrChunks.shift();
+      }
+      process.stderr.write(chunk);
+    });
+
+    child.once('error', error => {
+      console.error(`Failed to start LiveDesk Hub: ${error.message}`);
+      process.exitCode = 1;
+    });
+    child.once('exit', (code, signal) => {
+      const startupOutput = stderrChunks.join('');
+      if (!signal
+        && code !== 0
+        && options.cleanPortsOnStart
+        && startupRetryCount < HUB_STARTUP_RETRY_LIMIT
+        && isPortConflictOutput(startupOutput)) {
+        startupRetryCount += 1;
+        console.warn('[LiveDesk Hub] Startup port conflict detected. Cleaning Hub ports and retrying once.');
+        void stopProcessesOnPorts([httpPort, remotePort])
+          .then(() => startHubProcess())
+          .catch(error => {
+            console.error(error?.message || error);
+            process.exitCode = 1;
+          });
+        return;
+      }
+      if (signal) {
+        process.kill(process.pid, signal);
+        return;
+      }
+      process.exit(code ?? 0);
+    });
+  };
+
+  startHubProcess();
 
   if (options.openBrowserOnStart) {
     void waitForManager(openUrl).then(ok => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livedesk",
-  "version": "0.1.253",
+  "version": "0.1.255",
   "description": "LiveDesk Hub and client launcher",
   "type": "module",
   "bin": {