livedesk 0.1.496 → 0.1.498

package/bin/livedesk.js

@@ -31,8 +31,15 @@ import {
   isKnownLiveDeskCaptureHelperProcess,
   isKnownLiveDeskClientAgentProcess
 } from '../bootstrap/client-process-identity.js';
-import { runLegacyClientUpdateSupervisorCli } from '../bootstrap/legacy-client-update.js';
-import { transferSavedClientSessionToHub } from '../bootstrap/hub-auth-handoff.js';
+import { runLegacyClientUpdateSupervisorCli } from '../bootstrap/legacy-client-update.js';
+import { transferSavedClientSessionToHub } from '../bootstrap/hub-auth-handoff.js';
+import {
+  cancelUpdateHostJob,
+  ensureUpdateHost,
+  getUpdateHostJob,
+  submitUpdateHostJob,
+  updateHostEnvironment
+} from '../bootstrap/update-host-client.mjs';
 import {
   consumeDeadWindowsOwnedProcessManifest,
   readDeadWindowsOwnedProcessManifest,
@@ -220,108 +227,80 @@ function readBoundedMilliseconds(value, fallback, minimum = 1) {
   return Number.isFinite(parsed) && parsed >= minimum ? Math.round(parsed) : fallback;
 }
 
-async function stopUnclaimedHubRestartSupervisor(child) {
-  const supervisorPid = Number(child?.pid || 0);
-  if (supervisorPid <= 1 || !isPidAlive(supervisorPid)) return;
-  try {
-    child.kill('SIGKILL');
-  } catch {
-    // The bounded liveness check below decides whether recovery is safe.
-  }
-  const deadline = Date.now() + 2_000;
-  while (Date.now() < deadline && isPidAlive(supervisorPid)) {
-    await delay(HUB_UPDATE_SUPERVISOR_HANDSHAKE_POLL_MS);
-  }
-  if (isPidAlive(supervisorPid)) {
-    throw new Error(
-      `Unclaimed Hub restart supervisor pid=${supervisorPid} could not be stopped; `
-      + 'the current launcher will remain alive and keep the unchanged Hub running.'
-    );
-  }
-}
-
-async function waitForHubRestartSupervisorClaim(child, expected) {
-  let exit = null;
-  let spawnError = null;
-  let spawned = false;
-  child.once('spawn', () => {
-    spawned = true;
-  });
-  child.once('error', error => {
-    spawnError = error;
-  });
-  child.once('exit', (code, signal) => {
-    exit = { code, signal };
-  });
-
-  const spawnDeadline = Date.now() + expected.timeoutMs;
-  while (!spawned && !spawnError && !exit && Date.now() < spawnDeadline) {
-    await delay(HUB_UPDATE_SUPERVISOR_HANDSHAKE_POLL_MS);
-  }
-  if (spawnError) {
-    throw new Error(`Hub restart supervisor spawn failed: ${spawnError.message}`);
-  }
-  if (!spawned) {
-    const detail = exit
-      ? `exited code=${exit.code ?? 'none'} signal=${exit.signal || 'none'}`
-      : `did not emit spawn within ${expected.timeoutMs}ms`;
-    throw new Error(`Hub restart supervisor ${detail} before claiming the handoff.`);
-  }
-
-  const supervisorPid = Number(child.pid || 0);
-  const claimDeadline = Date.now() + expected.timeoutMs;
-  let matchingClaimSince = 0;
-  while (Date.now() < claimDeadline) {
-    if (spawnError) {
-      throw new Error(`Hub restart supervisor failed before handoff: ${spawnError.message}`);
-    }
-    if (exit || !isPidAlive(supervisorPid)) {
-      throw new Error(
-        `Hub restart supervisor pid=${supervisorPid || 'unknown'} exited before handoff `
-        + `(code=${exit?.code ?? 'none'} signal=${exit?.signal || 'none'}).`
-      );
-    }
-    const claim = readJsonFile(expected.resultPath);
-    if (
-      claim?.operationId === expected.operationId
-      && claim?.stage === 'waiting-for-old-launcher'
-      && claim?.outcome === 'in-progress'
-      && Number(claim?.supervisorPid || 0) === supervisorPid
-      && Number(claim?.launcherPid || 0) === expected.launcherPid
-      && claim?.targetVersion === expected.targetVersion
-      && claim?.handoffToken === expected.handoffToken
-    ) {
-      if (!matchingClaimSince) matchingClaimSince = Date.now();
-      if (Date.now() - matchingClaimSince >= expected.stabilityMs) {
-        await delay(HUB_UPDATE_SUPERVISOR_HANDSHAKE_POLL_MS);
-        const stableClaim = readJsonFile(expected.resultPath);
-        if (
-          !exit
-          && isPidAlive(supervisorPid)
-          && stableClaim?.operationId === expected.operationId
-          && stableClaim?.stage === 'waiting-for-old-launcher'
-          && stableClaim?.outcome === 'in-progress'
-          && Number(stableClaim?.supervisorPid || 0) === supervisorPid
-          && Number(stableClaim?.launcherPid || 0) === expected.launcherPid
-          && stableClaim?.targetVersion === expected.targetVersion
-          && stableClaim?.handoffToken === expected.handoffToken
-        ) {
-          return stableClaim;
-        }
-        matchingClaimSince = 0;
-      }
-    } else {
-      matchingClaimSince = 0;
-    }
-    await delay(HUB_UPDATE_SUPERVISOR_HANDSHAKE_POLL_MS);
-  }
-  throw new Error(
-    `Hub restart supervisor pid=${supervisorPid || 'unknown'} did not atomically claim `
-    + `operation ${expected.operationId} within ${expected.timeoutMs}ms.`
-  );
-}
-
-function writeJsonAtomic(filePath, value) {
+async function cancelUnclaimedHubUpdateHostJob(updateHost, jobId, reason) {
+  try {
+    await cancelUpdateHostJob(updateHost, jobId, reason);
+  } catch (error) {
+    const job = await getUpdateHostJob(updateHost, jobId).catch(() => null);
+    if (job && ['accepted', 'running', 'cancelling'].includes(String(job.state || ''))) {
+      throw new Error(
+        `Update Host job ${jobId} could not be cancelled: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+}
+
+async function waitForHubRestartUpdateHostClaim(updateHost, jobId, expected) {
+  const claimDeadline = Date.now() + expected.timeoutMs;
+  let matchingClaimSince = 0;
+  let workerPid = 0;
+  while (Date.now() < claimDeadline) {
+    const job = await getUpdateHostJob(updateHost, jobId, {
+      timeoutMs: Math.min(2_000, Math.max(250, claimDeadline - Date.now()))
+    });
+    if (!job) {
+      throw new Error(`LiveDesk Update Host lost job ${jobId} before handoff.`);
+    }
+    if (['failed', 'cancelled'].includes(String(job.state || ''))) {
+      throw new Error(
+        `LiveDesk Update Host job ${jobId} failed before handoff: ${job.error || `state=${job.state}`}`
+      );
+    }
+    workerPid = Number(job.workerPid || 0);
+    const claim = readJsonFile(expected.resultPath);
+    if (
+      job.state === 'running'
+      && workerPid > 1
+      && claim?.operationId === expected.operationId
+      && claim?.stage === 'waiting-for-old-launcher'
+      && claim?.outcome === 'in-progress'
+      && Number(claim?.supervisorPid || 0) === workerPid
+      && Number(claim?.launcherPid || 0) === expected.launcherPid
+      && claim?.targetVersion === expected.targetVersion
+      && claim?.handoffToken === expected.handoffToken
+    ) {
+      if (!matchingClaimSince) matchingClaimSince = Date.now();
+      if (Date.now() - matchingClaimSince >= expected.stabilityMs) {
+        await delay(HUB_UPDATE_SUPERVISOR_HANDSHAKE_POLL_MS);
+        const stableJob = await getUpdateHostJob(updateHost, jobId, { timeoutMs: 2_000 });
+        const stableClaim = readJsonFile(expected.resultPath);
+        if (
+          stableJob?.state === 'running'
+          && Number(stableJob?.workerPid || 0) === workerPid
+          && stableClaim?.operationId === expected.operationId
+          && stableClaim?.stage === 'waiting-for-old-launcher'
+          && stableClaim?.outcome === 'in-progress'
+          && Number(stableClaim?.supervisorPid || 0) === workerPid
+          && Number(stableClaim?.launcherPid || 0) === expected.launcherPid
+          && stableClaim?.targetVersion === expected.targetVersion
+          && stableClaim?.handoffToken === expected.handoffToken
+        ) {
+          return stableClaim;
+        }
+        matchingClaimSince = 0;
+      }
+    } else {
+      matchingClaimSince = 0;
+    }
+    await delay(Math.max(50, HUB_UPDATE_SUPERVISOR_HANDSHAKE_POLL_MS));
+  }
+  throw new Error(
+    `LiveDesk Update Host job ${jobId} did not publish an atomic handoff for `
+    + `operation ${expected.operationId} within ${expected.timeoutMs}ms.`
+  );
+}
+
+function writeJsonAtomic(filePath, value) {
   if (!filePath) return;
   mkdirSync(dirname(filePath), { recursive: true });
   const previous = readJsonFile(filePath);
@@ -2465,7 +2444,7 @@ function buildHubRestartBootstrapScript() {
   ].join('\n');
 }
 
-async function runManager(args, resolvedRole = null, runtimeLock = null) {
+async function runManager(args, resolvedRole = null, runtimeLock = null, updateHost = null) {
   const runtimeOwner = runtimeLock?.payload || null;
   const options = parseManagerArgs(args);
   const httpPort = normalizePort(
@@ -2513,7 +2492,7 @@ async function runManager(args, resolvedRole = null, runtimeLock = null) {
     LIVEDESK_HUB_HTTP_PORT: String(httpPort),
     LIVEDESK_MANAGER_VERSION: readVersion(),
     LIVEDESK_CLIENT_PACKAGE_VERSION: readClientVersion(),
-    LIVEDESK_HUB_UPDATE_REQUEST_PATH: updateRequestPath,
+    LIVEDESK_HUB_UPDATE_REQUEST_PATH: updateHost?.available ? updateRequestPath : '',
     LIVEDESK_HUB_UPDATE_RESULT_PATH: hubUpdateResultPath,
     LIVEDESK_UDP_ENABLED: String(process.env.LIVEDESK_UDP_ENABLED || '1'),
     LIVEDESK_UDP_PREFER_P2P: String(process.env.LIVEDESK_UDP_PREFER_P2P || '0'),
@@ -2641,7 +2620,10 @@ async function runManager(args, resolvedRole = null, runtimeLock = null) {
     process.on(signal, handler);
   }
 
-  const restartWithLatest = async request => {
+  const restartWithLatest = async request => {
+    if (!updateHost?.available) {
+      throw new Error('The independent LiveDesk Update Host is unavailable. The unchanged Hub remains running.');
+    }
     const requestedVersion = normalizeExactUpdateVersion(request?.latestVersion);
     if (!requestedVersion) {
       throw new Error('The Hub update target version must be one exact semantic version.');
@@ -2698,67 +2680,83 @@ async function runManager(args, resolvedRole = null, runtimeLock = null) {
       reportLauncherUpdate(`[LiveDesk Hub] Could not persist the restart supervisor state: ${error instanceof Error ? error.message : String(error)}.`, true);
       throw error;
     }
-    const restartBootstrap = spawn(process.execPath, ['-e', buildHubRestartBootstrapScript()], {
-      cwd: neutralCwd,
-      env: {
-        ...process.env,
-        LIVEDESK_RESTART_WAIT_PID: String(process.pid),
-        LIVEDESK_RESTART_PREVIOUS_RUNTIME_PID: String(request?.pid || 0),
-        LIVEDESK_RESTART_OPERATION_ID: operationId,
-        LIVEDESK_RESTART_STARTED_AT: restartStartedAt,
-        LIVEDESK_RESTART_HANDOFF_TOKEN: handoffToken,
-        LIVEDESK_RESTART_RESULT_PATH: hubUpdateResultPath,
-        LIVEDESK_RESTART_COMMAND: restartInvocation.command,
-        LIVEDESK_RESTART_ARGS_BASE64: Buffer.from(JSON.stringify(restartInvocation.args), 'utf8').toString('base64'),
-        LIVEDESK_RESTART_FALLBACK_COMMAND: fallbackInvocation.command,
-        LIVEDESK_RESTART_FALLBACK_ARGS_BASE64: Buffer.from(JSON.stringify(fallbackInvocation.args), 'utf8').toString('base64'),
-        LIVEDESK_RESTART_EXPECTED_VERSION: requestedVersion,
-        LIVEDESK_RESTART_FALLBACK_VERSION: readVersion(),
-        LIVEDESK_RESTART_HEALTH_URL: hubProbeBaseUrl,
-        LIVEDESK_RESTART_REMOTE_HOST: '127.0.0.1',
-        LIVEDESK_RESTART_REMOTE_PORT: String(remotePort),
-        LIVEDESK_RESTART_NEUTRAL_CWD: neutralCwd,
-        LIVEDESK_RESTART_FALLBACK_CWD: originalCwd,
-        LIVEDESK_UPDATE_ORIGINAL_CWD: originalCwd,
-        LIVEDESK_RESTART_LOG_PATH: hubLogPath
-      },
-      stdio: 'ignore',
-      detached: true,
-      windowsHide: true
-    });
-    try {
-      await waitForHubRestartSupervisorClaim(restartBootstrap, {
-        operationId,
-        targetVersion: requestedVersion,
-        resultPath: hubUpdateResultPath,
+    const workerEnvironment = {
+      ...process.env,
+      LIVEDESK_RESTART_WAIT_PID: String(process.pid),
+      LIVEDESK_RESTART_PREVIOUS_RUNTIME_PID: String(request?.pid || 0),
+      LIVEDESK_RESTART_OPERATION_ID: operationId,
+      LIVEDESK_RESTART_STARTED_AT: restartStartedAt,
+      LIVEDESK_RESTART_HANDOFF_TOKEN: handoffToken,
+      LIVEDESK_RESTART_RESULT_PATH: hubUpdateResultPath,
+      LIVEDESK_RESTART_COMMAND: restartInvocation.command,
+      LIVEDESK_RESTART_ARGS_BASE64: Buffer.from(JSON.stringify(restartInvocation.args), 'utf8').toString('base64'),
+      LIVEDESK_RESTART_FALLBACK_COMMAND: fallbackInvocation.command,
+      LIVEDESK_RESTART_FALLBACK_ARGS_BASE64: Buffer.from(JSON.stringify(fallbackInvocation.args), 'utf8').toString('base64'),
+      LIVEDESK_RESTART_EXPECTED_VERSION: requestedVersion,
+      LIVEDESK_RESTART_FALLBACK_VERSION: readVersion(),
+      LIVEDESK_RESTART_HEALTH_URL: hubProbeBaseUrl,
+      LIVEDESK_RESTART_REMOTE_HOST: '127.0.0.1',
+      LIVEDESK_RESTART_REMOTE_PORT: String(remotePort),
+      LIVEDESK_RESTART_NEUTRAL_CWD: neutralCwd,
+      LIVEDESK_RESTART_FALLBACK_CWD: originalCwd,
+      LIVEDESK_UPDATE_ORIGINAL_CWD: originalCwd,
+      LIVEDESK_RESTART_LOG_PATH: hubLogPath
+    };
+    const hostJobId = `hub-${safeUpdatePathSegment(operationId)}`;
+    let hostJob;
+    try {
+      const submitted = await submitUpdateHostJob(updateHost, {
+        jobId: hostJobId,
+        kind: 'hub-update',
+        operationId,
+        command: process.execPath,
+        args: ['-e', buildHubRestartBootstrapScript()],
+        cwd: neutralCwd,
+        env: workerEnvironment,
+        resultPath: hubUpdateResultPath,
+        requestedAt: restartStartedAt,
+        expiresAt: new Date(Date.parse(restartStartedAt) + 90 * 60_000).toISOString()
+      }, { timeoutMs: handshakeTimeoutMs });
+      hostJob = submitted?.job || null;
+      if (!hostJob || Number(hostJob.workerPid || 0) <= 1) {
+        throw new Error('LiveDesk Update Host accepted the request without a worker identity.');
+      }
+    } catch (error) {
+      throw new Error(`LiveDesk Update Host rejected the Hub replacement: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    try {
+      await waitForHubRestartUpdateHostClaim(updateHost, hostJobId, {
+        operationId,
+        targetVersion: requestedVersion,
+        resultPath: hubUpdateResultPath,
         launcherPid: process.pid,
         handoffToken,
         timeoutMs: handshakeTimeoutMs,
         stabilityMs: HUB_UPDATE_SUPERVISOR_CLAIM_STABILITY_MS
       });
-    } catch (handshakeError) {
-      let stopError = null;
-      try {
-        await stopUnclaimedHubRestartSupervisor(restartBootstrap);
-      } catch (error) {
-        stopError = error;
-      }
+    } catch (handshakeError) {
+      let stopError = null;
+      try {
+        await cancelUnclaimedHubUpdateHostJob(updateHost, hostJobId, 'Hub handoff was not proven.');
+      } catch (error) {
+        stopError = error;
+      }
       const error = new Error(
         `Hub restart supervisor handoff failed: `
         + `${handshakeError instanceof Error ? handshakeError.message : String(handshakeError)}`
         + `${stopError ? ` ${stopError.message}` : ''}`
       );
-      error.supervisorPid = Number(restartBootstrap.pid || 0);
-      error.handoffToken = handoffToken;
-      error.handoffCancelled = true;
-      throw error;
-    }
-    restartBootstrap.unref();
-    reportLauncherUpdate(
-      `[LiveDesk Hub] Update handoff claimed target=${requestedVersion} `
-      + `supervisorPid=${restartBootstrap.pid || 0} operation=${operationId}. `
-      + `The current launcher will now exit. Restart diagnostics: ${hubLogPath}`
-    );
+      error.supervisorPid = Number(hostJob?.workerPid || 0);
+      error.updateHostPid = Number(updateHost?.host?.pid || 0);
+      error.handoffToken = handoffToken;
+      error.handoffCancelled = true;
+      throw error;
+    }
+    reportLauncherUpdate(
+      `[LiveDesk Hub] Update handoff claimed target=${requestedVersion} `
+      + `updateHostPid=${updateHost.host?.pid || 0} workerPid=${hostJob.workerPid || 0} operation=${operationId}. `
+      + `The current launcher will now exit. Restart diagnostics: ${hubLogPath}`
+    );
     process.exit(0);
   };
 
@@ -3287,11 +3285,30 @@ async function main() {
       });
     }
   }
-  if (!lock.acquired) {
-    reportExistingRuntime(lock.existing || { role: resolvedRole.role, pid: 'unknown' });
-    return;
-  }
-  process.once('exit', lock.release);
+  if (!lock.acquired) {
+    reportExistingRuntime(lock.existing || { role: resolvedRole.role, pid: 'unknown' });
+    return;
+  }
+  process.once('exit', lock.release);
+
+  const updateHost = await ensureUpdateHost({
+    stateDir: MANAGER_STATE_DIR,
+    entryPath: resolve(packageRoot, 'bootstrap', 'update-host.mjs'),
+    sourceVersion: readVersion(),
+    env: process.env
+  });
+  Object.assign(process.env, updateHostEnvironment(updateHost));
+  if (updateHost.available) {
+    console.log(
+      `[LiveDesk] Independent Update Host ready pid=${updateHost.host?.pid || 'unknown'} `
+      + `source=${updateHost.host?.sourceVersion || readVersion()}.`
+    );
+  } else if (!updateHost.disabled) {
+    console.warn(
+      `[LiveDesk] Independent Update Host is unavailable; updates are disabled for this run: `
+      + `${updateHost.error || 'unknown error'}`
+    );
+  }
 
   // Only the contender that won the replacement lock may clean residual
   // listener ports. A simultaneous losing launcher must never kill the newly
@@ -3335,16 +3352,16 @@ async function main() {
     await runClient(runtimeArgs, resolvedRole, lock);
     return;
   }
-  if (command === 'hub' || command === 'manager') {
-    await runManager(runtimeArgs, resolvedRole, lock);
+  if (command === 'hub' || command === 'manager') {
+    await runManager(runtimeArgs, resolvedRole, lock, updateHost);
     return;
   }
   if (resolvedRole.role === 'client') {
     await runClient(runtimeArgs, resolvedRole, lock);
     return;
   }
-  await runManager(runtimeArgs, resolvedRole, lock);
-}
+  await runManager(runtimeArgs, resolvedRole, lock, updateHost);
+}
 
 main().catch(error => {
   console.error(error?.message || error);