livedesk 0.1.384 → 0.1.385

package/hub/src/remote-hub.js

@@ -927,9 +927,10 @@ function serializeDevice(device, options = {}) {
         platform: device.platform,
         arch: device.arch,
         slotNumber: device.slotNumber || 0,
-        pid: device.pid,
-        agentVersion: device.agentVersion,
-        protocol: device.protocol,
+        pid: device.pid,
+        agentVersion: device.agentVersion,
+        productVersion: device.productVersion,
+        protocol: device.protocol,
         protocolVersion: device.protocolVersion,
         frameProtocol: device.frameProtocol ? { ...device.frameProtocol } : null,
         frameModes: Array.isArray(device.frameModes)
@@ -2646,9 +2647,10 @@ export function createRemoteHub(options = {}) {
             platform: safeString(hello.platform, 80),
             arch: safeString(hello.arch, 40),
             slotNumber: normalizeSlotNumber(hello.slotNumber ?? hello.slot ?? hello.computerNumber),
-            pid: Number.isFinite(Number(hello.pid)) ? Number(hello.pid) : 0,
-            agentVersion: safeString(hello.agentVersion, 40),
-            protocol: safeString(hello.protocol, 80) || REMOTE_AGENT_PROTOCOL,
+            pid: Number.isFinite(Number(hello.pid)) ? Number(hello.pid) : 0,
+            agentVersion: safeString(hello.agentVersion, 40),
+            productVersion: safeString(hello.productVersion, 40),
+            protocol: safeString(hello.protocol, 80) || REMOTE_AGENT_PROTOCOL,
             protocolVersion: Number.isFinite(Number(hello.protocolVersion)) ? Math.max(1, Math.floor(Number(hello.protocolVersion))) : 1,
             frameProtocol: frameProtocol || buildRemoteFrameProtocolDescriptor(),
             frameModes: frameModes.length > 0 ? frameModes : getSupportedRemoteFrameModeProfiles(),

package/hub/src/server.js

@@ -67,7 +67,12 @@ const mode5FrameBackpressureBytes = readPositiveIntegerEnv('LIVEDESK_MODE5_WS_BA
 const mode5FrameQueuePackets = readPositiveIntegerEnv('LIVEDESK_MODE5_WS_QUEUE_PACKETS', 2);
 const audioBackpressureBytes = readPositiveIntegerEnv('LIVEDESK_AUDIO_WS_BACKPRESSURE_BYTES', 96 * 1024);
 const webSocketHeartbeatMs = readPositiveIntegerEnv('LIVEDESK_BROWSER_WS_HEARTBEAT_MS', 15_000);
-const frameClients = new Set();
+const hubShutdownGraceMs = readPositiveIntegerEnv('LIVEDESK_HUB_SHUTDOWN_GRACE_MS', 1_500);
+const hubShutdownTimeoutMs = Math.max(
+  hubShutdownGraceMs + 1_000,
+  readPositiveIntegerEnv('LIVEDESK_HUB_SHUTDOWN_TIMEOUT_MS', 8_000)
+);
+const frameClients = new Set();
 const frameClientsByDeviceId = new Map();
 const frameWildcardClients = new Set();
 const pendingFrameStreamStops = new Map();
@@ -507,7 +512,7 @@ const remoteHub = createRemoteHub({
   }
 });
 
-function requestHubRestart(request = {}) {
+function requestHubRestart(request = {}) {
   const requestPath = String(process.env.LIVEDESK_HUB_UPDATE_REQUEST_PATH || '').trim();
   if (!requestPath) {
     return { ok: false, error: 'hub-launcher-restart-unavailable' };
@@ -524,10 +529,73 @@ function requestHubRestart(request = {}) {
     return { ok: true };
   } catch (error) {
     return { ok: false, error: `hub-restart-request-failed: ${error instanceof Error ? error.message : String(error)}` };
-  }
-}
-
-if (process.env.LIVEDESK_DESKTOP_HOST !== '1') {
+  }
+}
+
+const HUB_RESTART_RESULT_STAGES = new Set([
+  'supervisor-starting',
+  'waiting-for-old-launcher',
+  'old-launcher-exited',
+  'target-attempt',
+  'target-failed',
+  'fallback-attempt',
+  'fallback-failed',
+  'updated',
+  'restored',
+  'failed'
+]);
+const HUB_RESTART_RESULT_OUTCOMES = new Set(['in-progress', 'updated', 'restored', 'failed']);
+
+function readHubRestartResult() {
+  const resultPath = String(process.env.LIVEDESK_HUB_UPDATE_RESULT_PATH || '').trim();
+  if (!resultPath || !existsSync(resultPath)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(resultPath, 'utf8'));
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+    const operationId = String(raw.operationId || '').trim().slice(0, 160);
+    const stage = String(raw.stage || '').trim();
+    const outcome = String(raw.outcome || '').trim();
+    if (!operationId || !HUB_RESTART_RESULT_STAGES.has(stage) || !HUB_RESTART_RESULT_OUTCOMES.has(outcome)) {
+      return null;
+    }
+    const text = (value, maximum = 200) => String(value || '').trim().slice(0, maximum);
+    const positiveInteger = value => {
+      const numeric = Number(value);
+      return Number.isInteger(numeric) && numeric > 0 ? numeric : undefined;
+    };
+    return {
+      operationId,
+      stage,
+      outcome,
+      targetVersion: text(raw.targetVersion),
+      fallbackVersion: text(raw.fallbackVersion),
+      appVersion: text(raw.appVersion),
+      attempt: positiveInteger(raw.attempt),
+      previousRuntimePid: positiveInteger(raw.previousRuntimePid),
+      supervisorPid: positiveInteger(raw.supervisorPid),
+      launcherPid: positiveInteger(raw.launcherPid),
+      runtimePid: positiveInteger(raw.runtimePid),
+      startedAt: text(raw.startedAt, 64),
+      updatedAt: text(raw.updatedAt, 64),
+      completedAt: text(raw.completedAt, 64),
+      error: text(raw.error, 4_000)
+    };
+  } catch {
+    return null;
+  }
+}
+
+function getLiveDeskUpdateStatus() {
+  return {
+    ...(liveDeskUpdateManager?.getStatus() || {
+      updateAvailable: false,
+      state: 'unavailable'
+    }),
+    restartResult: readHubRestartResult()
+  };
+}
+
+if (process.env.LIVEDESK_DESKTOP_HOST !== '1') {
   liveDeskUpdateManager = createLiveDeskUpdateManager({
     remoteHub,
     currentManagerVersion: process.env.LIVEDESK_MANAGER_VERSION || packageInfo.version,
@@ -1062,14 +1130,20 @@ const hubSharedFolders = createHubSharedFolders({
   remoteHub
 });
 
-const app = express();
-const httpServer = createServer(app);
+const app = express();
+const httpServer = createServer(app);
+const httpConnections = new Set();
 const frameWss = new WebSocketServer({ noServer: true, perMessageDeflate: false });
 const atlasWss = new WebSocketServer({ noServer: true, perMessageDeflate: false });
 const inputWss = new WebSocketServer({ noServer: true, perMessageDeflate: false });
 const audioWss = new WebSocketServer({ noServer: true, perMessageDeflate: false });
 const browserWebSocketServers = [frameWss, atlasWss, inputWss, audioWss];
 
+httpServer.on('connection', socket => {
+  httpConnections.add(socket);
+  socket.once('close', () => httpConnections.delete(socket));
+});
+
 for (const wss of browserWebSocketServers) {
   wss.on('connection', ws => {
     ws.liveDeskHeartbeatAlive = true;
@@ -2765,8 +2839,8 @@ app.get('/api/remote/status', (_req, res) => {
     deviceId: runtimeDeviceId,
     deviceName: runtimeDeviceName,
     roleSource: runtimeRoleSource,
-    agentPackage: '@livedesk/client',
-    update: liveDeskUpdateManager?.getStatus() || null
+    agentPackage: '@livedesk/client',
+    update: getLiveDeskUpdateStatus()
   });
 });
 
@@ -2780,19 +2854,27 @@ app.get('/api/runtime/events', (_req, res) => {
   res.json({ ok: true, events: runtimeManager.getEvents() });
 });
 
-app.post('/api/runtime/restart', (_req, res) => {
-  noStore(res);
-  runtimeManager.emit('runtime.restart.requested', { role: runtimeRole });
-  res.json({ ok: true, restarting: true, role: runtimeRole });
-  setTimeout(() => process.kill(process.pid, 'SIGTERM'), 150);
-});
-
-app.post('/api/runtime/shutdown', (_req, res) => {
-  noStore(res);
-  runtimeManager.emit('runtime.shutdown.requested', { role: runtimeRole });
-  res.json({ ok: true, shuttingDown: true, role: runtimeRole });
-  setTimeout(() => process.kill(process.pid, 'SIGTERM'), 150);
-});
+app.post('/api/runtime/restart', (_req, res) => {
+  noStore(res);
+  runtimeManager.emit('runtime.restart.requested', { role: runtimeRole });
+  res.json({ ok: true, restarting: true, role: runtimeRole });
+  setTimeout(() => {
+    void shutdownHub('API_RESTART')
+      .then(() => process.exit(0))
+      .catch(() => process.exit(1));
+  }, 150);
+});
+
+app.post('/api/runtime/shutdown', (_req, res) => {
+  noStore(res);
+  runtimeManager.emit('runtime.shutdown.requested', { role: runtimeRole });
+  res.json({ ok: true, shuttingDown: true, role: runtimeRole });
+  setTimeout(() => {
+    void shutdownHub('API_SHUTDOWN')
+      .then(() => process.exit(0))
+      .catch(() => process.exit(1));
+  }, 150);
+});
 
 app.post('/api/runtime/switch-role', (req, res) => {
   noStore(res);
@@ -3137,7 +3219,7 @@ app.get('/api/hub/status', (_req, res) => {
     roleSource: runtimeRoleSource,
     runtimeStarted: true,
     hostTargetLease: getHubHostTargetLeaseStatus(),
-    update: liveDeskUpdateManager?.getStatus() || null
+    update: getLiveDeskUpdateStatus()
   });
 });
 
@@ -3248,14 +3330,20 @@ app.post('/api/runtime/role', async (req, res) => {
   }
 });
 
-app.get('/api/update/status', (_req, res) => {
-  noStore(res);
-  if (process.env.LIVEDESK_DESKTOP_HOST === '1') {
-    res.json({ updateAvailable: false, state: 'electron-managed', canApply: false, disabled: true });
-    return;
-  }
-  res.json(liveDeskUpdateManager?.getStatus() || { updateAvailable: false, state: 'unavailable' });
-});
+app.get('/api/update/status', (_req, res) => {
+  noStore(res);
+  if (process.env.LIVEDESK_DESKTOP_HOST === '1') {
+    res.json({
+      updateAvailable: false,
+      state: 'electron-managed',
+      canApply: false,
+      disabled: true,
+      restartResult: readHubRestartResult()
+    });
+    return;
+  }
+  res.json(getLiveDeskUpdateStatus());
+});
 
 app.post('/api/update/apply', async (_req, res) => {
   noStore(res);
@@ -4037,18 +4125,130 @@ const roleWatchTimer = runtimeRole === 'hub'
   : null;
 roleWatchTimer?.unref?.();
 
-for (const signal of ['SIGINT', 'SIGTERM']) {
-  process.once(signal, async () => {
-    if (roleWatchTimer) {
-      clearInterval(roleWatchTimer);
+function waitForShutdownDelay(milliseconds) {
+  return new Promise(resolveWait => {
+    const timer = setTimeout(resolveWait, milliseconds);
+    timer.unref?.();
+  });
+}
+
+async function boundedShutdownStep(label, action, timeoutMs) {
+  let timer;
+  try {
+    await Promise.race([
+      Promise.resolve().then(action),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+        timer.unref?.();
+      })
+    ]);
+    console.log(`[LiveDesk Hub] Shutdown stage completed: ${label}.`);
+  } catch (error) {
+    console.warn(`[LiveDesk Hub] Shutdown stage warning: ${error instanceof Error ? error.message : String(error)}`);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+function runSynchronousShutdownStep(label, action) {
+  try {
+    action();
+  } catch (error) {
+    console.warn(`[LiveDesk Hub] Shutdown stage warning: ${label} failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+function closeBrowserWebSockets() {
+  let closeRequested = 0;
+  for (const wss of browserWebSocketServers) {
+    for (const ws of wss.clients) {
+      closeRequested += 1;
+      try {
+        ws.close(1012, 'LiveDesk Hub restarting');
+      } catch {
+        try { ws.terminate(); } catch { /* socket already closed */ }
+      }
     }
+  }
+  console.log(`[LiveDesk Hub] Shutdown stage: requested ${closeRequested} browser WebSocket connection(s) to close.`);
+}
+
+function terminateOpenConnections() {
+  let terminatedWebSockets = 0;
+  for (const wss of browserWebSocketServers) {
+    for (const ws of wss.clients) {
+      terminatedWebSockets += 1;
+      try { ws.terminate(); } catch { /* socket already closed */ }
+    }
+    try { wss.close(); } catch { /* no active WebSocket server state */ }
+  }
+  let destroyedHttpConnections = 0;
+  for (const socket of httpConnections) {
+    if (socket.destroyed) continue;
+    destroyedHttpConnections += 1;
+    try { socket.destroy(); } catch { /* socket already closed */ }
+  }
+  try { httpServer.closeAllConnections?.(); } catch { /* older Node runtime */ }
+  console.log(`[LiveDesk Hub] Shutdown stage: force-closed ${terminatedWebSockets} WebSocket and ${destroyedHttpConnections} HTTP connection(s).`);
+}
+
+let hubShutdownPromise = null;
+function shutdownHub(signal) {
+  if (hubShutdownPromise) return hubShutdownPromise;
+  hubShutdownPromise = (async () => {
+    const startedAt = Date.now();
+    console.log(`[LiveDesk Hub] Shutdown started signal=${signal} grace=${hubShutdownGraceMs}ms timeout=${hubShutdownTimeoutMs}ms.`);
+    if (roleWatchTimer) clearInterval(roleWatchTimer);
     clearInterval(browserWebSocketHeartbeatTimer);
-    liveDeskUpdateManager?.close();
-    atlasPool.close();
+    runSynchronousShutdownStep('update manager close', () => liveDeskUpdateManager?.close());
+    runSynchronousShutdownStep('atlas pool close', () => atlasPool.close());
     atlasClients.clear();
-    hubSharedFolders.close();
-    await clearHubHostTarget(`process-${signal.toLowerCase()}`);
-    await remoteHub.close();
-    httpServer.close(() => process.exit(0));
-  });
-}
+    runSynchronousShutdownStep('shared folder close', () => hubSharedFolders.close());
+
+    const httpClosed = new Promise(resolveClose => {
+      try {
+        httpServer.close(error => {
+          if (error) {
+            console.warn(`[LiveDesk Hub] HTTP listener close warning: ${error.message}`);
+          } else {
+            console.log('[LiveDesk Hub] Shutdown stage completed: HTTP listener closed.');
+          }
+          resolveClose();
+        });
+        httpServer.closeIdleConnections?.();
+      } catch (error) {
+        console.warn(`[LiveDesk Hub] HTTP listener close warning: ${error instanceof Error ? error.message : String(error)}`);
+        resolveClose();
+      }
+    });
+
+    closeBrowserWebSockets();
+    const forceCloseTimer = setTimeout(terminateOpenConnections, hubShutdownGraceMs);
+    forceCloseTimer.unref?.();
+
+    const cleanupBudgetMs = Math.max(500, hubShutdownTimeoutMs - hubShutdownGraceMs - 500);
+    await Promise.all([
+      boundedShutdownStep('host target lease cleared', () => clearHubHostTarget(`process-${String(signal).toLowerCase()}`), Math.min(3_000, cleanupBudgetMs)),
+      boundedShutdownStep('remote transport closed', () => remoteHub.close(), cleanupBudgetMs)
+    ]);
+
+    const remainingMs = Math.max(0, hubShutdownTimeoutMs - (Date.now() - startedAt));
+    await Promise.race([httpClosed, waitForShutdownDelay(remainingMs)]);
+    clearTimeout(forceCloseTimer);
+    terminateOpenConnections();
+    console.log(`[LiveDesk Hub] Shutdown complete in ${Date.now() - startedAt}ms.`);
+  })();
+  return hubShutdownPromise;
+}
+
+for (const signal of ['SIGINT', 'SIGTERM']) {
+  process.once(signal, () => {
+    void shutdownHub(signal)
+      .then(() => process.exit(0))
+      .catch(error => {
+        console.error(`[LiveDesk Hub] Shutdown failed: ${error instanceof Error ? error.message : String(error)}`);
+        terminateOpenConnections();
+        process.exit(1);
+      });
+  });
+}

package/package.json

@@ -1,7 +1,8 @@
 {
-  "name": "livedesk",
-  "version": "0.1.384",
-  "buildFlavor": "production",
+  "name": "livedesk",
+  "version": "0.1.385",
+  "livedeskClientVersion": "0.1.170",
+  "buildFlavor": "production",
   "description": "LiveDesk Hub and client launcher",
   "type": "module",
   "main": "electron/main.mjs",
@@ -48,10 +49,10 @@
     "ws": "^8.18.3"
   },
   "optionalDependencies": {
-    "@livedesk/fast-linux-x64": "0.1.373",
-    "@livedesk/fast-osx-arm64": "0.1.375",
-    "@livedesk/fast-osx-x64": "0.1.375",
-    "@livedesk/fast-win-x64": "0.1.373"
+    "@livedesk/fast-linux-x64": "0.1.374",
+    "@livedesk/fast-osx-arm64": "0.1.376",
+    "@livedesk/fast-osx-x64": "0.1.376",
+    "@livedesk/fast-win-x64": "0.1.374"
   },
   "publishConfig": {
     "access": "public"