livedesk 0.1.445 → 0.1.446

package/bin/livedesk.js

@@ -694,10 +694,11 @@ async function getProcessDetails(pid) {
     }
   }
 
-  const [nameResult, commandResult, groupResult, startResult] = await Promise.all([
+  const [nameResult, commandResult, groupResult, parentResult, startResult] = await Promise.all([
     runQuiet('ps', ['-p', String(processId), '-o', 'comm=']),
     runQuiet('ps', ['-p', String(processId), '-o', 'args=']),
     runQuiet('ps', ['-p', String(processId), '-o', 'pgid=']),
+    runQuiet('ps', ['-p', String(processId), '-o', 'ppid=']),
     runQuiet('ps', ['-p', String(processId), '-o', 'lstart='])
   ]);
   if (!nameResult.stdout && !commandResult.stdout) return null;
@@ -711,7 +712,7 @@ async function getProcessDetails(pid) {
   }
   return {
     processId,
-    parentProcessId: 0,
+    parentProcessId: Number(parentResult.stdout || 0),
     processName: nameResult.stdout,
     commandLine: commandResult.stdout,
     executablePath,
@@ -720,6 +721,64 @@ async function getProcessDetails(pid) {
   };
 }
 
+async function hasKnownLiveDeskClientAgentDescendant(rootPid) {
+  const processId = Number(rootPid);
+  if (!Number.isInteger(processId) || processId <= 1) return false;
+  let pairs = [];
+  if (os.platform() === 'win32') {
+    const script = '$ErrorActionPreference = "Stop"; @(Get-CimInstance Win32_Process | ForEach-Object { [pscustomobject]@{ ProcessId = [int]$_.ProcessId; ParentProcessId = [int]$_.ParentProcessId } }) | ConvertTo-Json -Compress';
+    const result = await runQuiet(
+      'powershell.exe',
+      ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-Command', script],
+      { timeout: 10000, killSignal: 'SIGKILL' }
+    );
+    if (!result.ok || !result.stdout) return false;
+    try {
+      const parsed = JSON.parse(result.stdout);
+      pairs = (Array.isArray(parsed) ? parsed : [parsed]).map(item => ({
+        pid: Number(item?.ProcessId || 0),
+        parentPid: Number(item?.ParentProcessId || 0)
+      }));
+    } catch {
+      return false;
+    }
+  } else {
+    const result = await runQuiet(
+      'ps',
+      ['-axo', 'pid=,ppid='],
+      { timeout: 10000, killSignal: 'SIGKILL' }
+    );
+    if (!result.ok || !result.stdout) return false;
+    pairs = result.stdout.split(/\r?\n/).flatMap(line => {
+      const match = line.match(/^\s*(\d+)\s+(\d+)\s*$/);
+      return match ? [{ pid: Number(match[1]), parentPid: Number(match[2]) }] : [];
+    });
+  }
+
+  const childrenByParent = new Map();
+  for (const pair of pairs) {
+    if (!childrenByParent.has(pair.parentPid)) childrenByParent.set(pair.parentPid, []);
+    childrenByParent.get(pair.parentPid).push(pair.pid);
+  }
+  const queue = [...(childrenByParent.get(processId) || [])];
+  const seen = new Set();
+  while (queue.length > 0) {
+    const candidatePid = queue.shift();
+    if (!Number.isInteger(candidatePid) || candidatePid <= 1 || seen.has(candidatePid)) continue;
+    seen.add(candidatePid);
+    const details = await getProcessDetails(candidatePid);
+    if (details && isKnownLiveDeskClientAgentProcess(
+      details.processName,
+      details.commandLine,
+      details.executablePath
+    )) {
+      return true;
+    }
+    queue.push(...(childrenByParent.get(candidatePid) || []));
+  }
+  return false;
+}
+
 async function waitForProcessExit(pid, timeoutMs = EXISTING_RUNTIME_STOP_TIMEOUT_MS) {
   const processId = Number(pid);
   const deadline = Date.now() + timeoutMs;
@@ -748,16 +807,26 @@ async function stopExistingRuntime(existing) {
     return null;
   }
   const commandLineConfirmed = isKnownLiveDeskLauncherProcess(details.processName, details.commandLine);
-  const runtimeProof = commandLineConfirmed
+  const lockInstanceConfirmed = String(existing?.ownerToken || '').trim().length >= 16
+    && String(existing?.ownerInstanceMarker || '').trim()
+      === processInstanceMarker(details);
+  const legacyClientTreeConfirmed = !String(existing?.ownerToken || '').trim()
+    && String(existing?.role || '').trim().toLowerCase() === 'client'
+    && await hasKnownLiveDeskClientAgentDescendant(processId);
+  const runtimeProof = commandLineConfirmed || lockInstanceConfirmed || legacyClientTreeConfirmed
     ? null
     : await probeExistingRuntimeIdentity(existing);
-  if (!commandLineConfirmed && !runtimeProof) {
+  if (!commandLineConfirmed && !lockInstanceConfirmed && !legacyClientTreeConfirmed && !runtimeProof) {
     throw new Error(`Existing runtime pid ${processId} is not a confirmed LiveDesk launcher; it was preserved.`);
   }
 
   const identityProof = commandLineConfirmed
     ? 'command-line'
-    : `runtime-api:${runtimeProof.port}:${runtimeProof.appVersion || 'unknown'}`;
+    : lockInstanceConfirmed
+      ? 'lock-instance'
+      : legacyClientTreeConfirmed
+        ? 'legacy-lock-exact-client-descendant'
+        : `runtime-api:${runtimeProof.port}:${runtimeProof.appVersion || 'unknown'}`;
   console.log(`[LiveDesk] Stopping existing ${existing?.role || 'runtime'} launcher pid ${processId} before starting a fresh runtime (identity=${identityProof}).`);
   if (os.platform() === 'win32') {
     await runQuiet('taskkill.exe', ['/PID', String(processId), '/T', '/F']);
@@ -1003,7 +1072,13 @@ async function stopStaleClientAgents() {
       );
     }
     const candidatePids = [];
-    const patterns = ['livedesk-client-fast', 'livedesk-client-node.js', 'livedesk-sck-h264'];
+    const patterns = [
+      'livedesk-client-fast',
+      'livedesk-client-node.js',
+      'livedesk-sck-h264',
+      'livedesk-sck-audio',
+      'livedesk-raw-capture-helper.mjs'
+    ];
     for (const line of result.stdout.split(/\r?\n/)) {
       if (!patterns.some(pattern => line.includes(pattern))) continue;
       const match = line.match(/^\s*(\d+)\s+/);
@@ -2131,6 +2206,8 @@ async function main() {
   if (topLevel.noSingleInstance || process.env.LIVEDESK_DISABLE_SINGLE_INSTANCE === '1') {
     console.warn('[LiveDesk] Single-instance lock disabled for this run.');
   }
+  const launcherProcessDetails = await getProcessDetails(process.pid);
+  const launcherInstanceMarker = processInstanceMarker(launcherProcessDetails);
   const reportExistingRuntime = existing => {
     const port = DEFAULT_MANAGER_HTTP_PORT;
     openBrowser(`http://127.0.0.1:${port}`);
@@ -2141,6 +2218,7 @@ async function main() {
     : acquireRuntimeLock({
       stateDir: MANAGER_STATE_DIR,
       role: resolvedRole.role,
+      ownerInstanceMarker: launcherInstanceMarker,
       openExisting: () => undefined
     });
 
@@ -2151,6 +2229,7 @@ async function main() {
     lock = acquireRuntimeLock({
       stateDir: MANAGER_STATE_DIR,
       role: resolvedRole.role,
+      ownerInstanceMarker: launcherInstanceMarker,
       openExisting: () => undefined
     });
   }
@@ -2162,6 +2241,7 @@ async function main() {
       lock = acquireRuntimeLock({
         stateDir: MANAGER_STATE_DIR,
         role: resolvedRole.role,
+        ownerInstanceMarker: launcherInstanceMarker,
         openExisting: () => undefined
       });
     }

package/bootstrap/client-process-identity.js

@@ -50,11 +50,25 @@ export function isKnownLiveDeskClientAgentProcess(processName, commandLine, exec
 export function isKnownLiveDeskCaptureHelperProcess(processName, commandLine, executablePath = '') {
   const normalizedName = String(processName || '').trim().replaceAll('\\', '/').split('/').pop() || '';
   const normalizedCommandLine = String(commandLine || '').replaceAll('\\', '/');
-  const helperPathPattern = /(?:^|\/)\.livedesk\/helpers\/macos-sck-h264\/livedesk-sck-h264$/i;
-  const knownCommand = /(?:^|\/)\.livedesk\/helpers\/macos-sck-h264\/livedesk-sck-h264(?:\s|["']|$)/i
+  const normalizedExecutablePath = normalizeExecutablePath(executablePath);
+  const argvExecutable = normalizeExecutablePath(firstCommandArgument(normalizedCommandLine));
+  const videoHelperPath = /(?:^|\/)\.livedesk\/helpers\/macos-sck-h264\/livedesk-sck-h264$/i;
+  const audioHelperPath = /(?:^|\/)\.livedesk\/helpers\/macos-sck-audio\/livedesk-sck-audio$/i;
+  const knownVideoCommand = /(?:^|\/)\.livedesk\/helpers\/macos-sck-h264\/livedesk-sck-h264(?:\s|["']|$)/i
+    .test(normalizedCommandLine);
+  const knownAudioCommand = /(?:^|\/)\.livedesk\/helpers\/macos-sck-audio\/livedesk-sck-audio(?:\s|["']|$)/i
     .test(normalizedCommandLine);
-  const strictExecutableProof = helperPathPattern.test(normalizeExecutablePath(executablePath))
-    || helperPathPattern.test(normalizeExecutablePath(firstCommandArgument(normalizedCommandLine)));
-  return (/^livedesk-sck-h264$/i.test(normalizedName) && knownCommand)
-    || (/^livedesk-sck-h2$/i.test(normalizedName) && strictExecutableProof);
+  const strictVideoExecutableProof = videoHelperPath.test(normalizedExecutablePath)
+    || videoHelperPath.test(argvExecutable);
+  const strictAudioExecutableProof = audioHelperPath.test(normalizedExecutablePath)
+    || audioHelperPath.test(argvExecutable);
+  const knownRawCaptureCommand = new RegExp(
+    `^(?:"[^"]*"|'[^']*'|\\S+)\\s+["']?\\S*${FAST_ROOT}/livedesk-raw-capture-helper\\.mjs(?:["']|\\s|$)`,
+    'i'
+  ).test(normalizedCommandLine);
+  return (/^livedesk-sck-h264$/i.test(normalizedName) && knownVideoCommand)
+    || (/^livedesk-sck-h2$/i.test(normalizedName) && strictVideoExecutableProof)
+    || (/^livedesk-sck-audio$/i.test(normalizedName) && knownAudioCommand)
+    || (/^livedesk-sck-aud$/i.test(normalizedName) && strictAudioExecutableProof)
+    || (/^(?:node|node\.exe)$/i.test(normalizedName) && knownRawCaptureCommand);
 }

package/bootstrap/runtime-lock.js

@@ -1,15 +1,48 @@
-import { existsSync, openSync, readFileSync, closeSync, unlinkSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import os from 'node:os';
+import { existsSync, linkSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import { join } from 'node:path';
+import os from 'node:os';
 
-function readLock(path) {
+function readLock(path) {
   try {
     return JSON.parse(readFileSync(path, 'utf8'));
   } catch {
     return null;
   }
-}
-
+}
+
+function readLockText(path) {
+  try {
+    return readFileSync(path, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function publishCompleteLock(targetPath, stagedPath, payload) {
+  writeFileSync(stagedPath, JSON.stringify(payload, null, 2), {
+    flag: 'wx',
+    mode: 0o600
+  });
+  try {
+    linkSync(stagedPath, targetPath);
+  } finally {
+    try { unlinkSync(stagedPath); } catch { /* staged inode was already removed */ }
+  }
+}
+
+function releaseOwnedLock(path, payload) {
+  try {
+    const current = readLock(path);
+    if (Number(current?.pid) === payload.pid
+      && current?.ownerToken === payload.ownerToken) {
+      unlinkSync(path);
+    }
+  } catch {
+    // The exact owner already released the lock.
+  }
+}
+
 function isProcessAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 1) {
     return false;
@@ -26,33 +59,112 @@ export function getRuntimeLockPath(stateDir = join(os.homedir(), '.livedesk')) {
   return join(stateDir, 'livedesk-runtime.lock');
 }
 
-export function acquireRuntimeLock({ stateDir, role = '', openExisting } = {}) {
-  const path = getRuntimeLockPath(stateDir);
-  const payload = {
-    pid: process.pid,
-    role: String(role || '').trim(),
-    startedAt: new Date().toISOString()
-  };
-
-  try {
-    const descriptor = openSync(path, 'wx');
-    writeFileSync(descriptor, JSON.stringify(payload, null, 2));
-    closeSync(descriptor);
-    let released = false;
-    const release = () => {
-      if (released) return;
-      released = true;
-      try { unlinkSync(path); } catch { /* already released */ }
-    };
-    return { acquired: true, path, payload, release };
-  } catch (error) {
-    const existing = readLock(path);
-    if (!existing || !isProcessAlive(Number(existing.pid))) {
-      try { unlinkSync(path); } catch { /* another process may repair it */ }
-      return acquireRuntimeLock({ stateDir, role, openExisting });
-    }
-    if (typeof openExisting === 'function') {
-      openExisting(existing);
+export function acquireRuntimeLock({
+  stateDir,
+  role = '',
+  ownerInstanceMarker = '',
+  openExisting
+} = {}) {
+  const path = getRuntimeLockPath(stateDir);
+  const payload = {
+    pid: process.pid,
+    role: String(role || '').trim(),
+    startedAt: new Date().toISOString(),
+    ownerToken: randomBytes(16).toString('hex'),
+    ownerInstanceMarker: String(ownerInstanceMarker || '').trim()
+  };
+  const stagedPath = `${path}.${process.pid}.${payload.ownerToken}.pending`;
+  const takeoverPath = `${path}.takeover`;
+  const takeoverStagedPath = `${takeoverPath}.${process.pid}.${payload.ownerToken}.pending`;
+  const existingTakeover = readLock(takeoverPath);
+
+  // Stale repair is synchronous and normally lasts only a few filesystem
+  // operations. Every contender that observes its marker must fail closed so
+  // nobody can acquire the main path in the unlink/link handoff window.
+  if (existingTakeover || existsSync(takeoverPath)) {
+    const existing = readLock(path);
+    if (typeof openExisting === 'function') {
+      openExisting(existing || existingTakeover);
+    }
+    return {
+      acquired: false,
+      path,
+      existing: existing || existingTakeover,
+      error: new Error('LiveDesk runtime lock takeover is already in progress.')
+    };
+  }
+
+  try {
+    // Publish a fully written inode with one atomic hard-link operation. With
+    // open(path, 'wx') followed by write(), another launcher could observe the
+    // temporary zero-byte file, classify it as stale, unlink it on macOS, and
+    // acquire a second lock while the first owner still held the old inode.
+    publishCompleteLock(path, stagedPath, payload);
+    let released = false;
+    const release = () => {
+      if (released) return;
+      released = true;
+      releaseOwnedLock(path, payload);
+    };
+    return { acquired: true, path, payload, release };
+  } catch (error) {
+    try { unlinkSync(stagedPath); } catch { /* staged inode was never created or was already removed */ }
+    const existingText = readLockText(path);
+    const existing = readLock(path);
+    if (existing && !isProcessAlive(Number(existing.pid))) {
+      const takeoverPayload = {
+        pid: process.pid,
+        role: 'runtime-lock-takeover',
+        startedAt: new Date().toISOString(),
+        ownerToken: randomBytes(16).toString('hex'),
+        ownerInstanceMarker: String(ownerInstanceMarker || '').trim()
+      };
+      try {
+        publishCompleteLock(takeoverPath, takeoverStagedPath, takeoverPayload);
+      } catch {
+        if (typeof openExisting === 'function') {
+          openExisting(existing);
+        }
+        return { acquired: false, path, existing, error };
+      }
+
+      try {
+        const currentText = readLockText(path);
+        const current = readLock(path);
+        if (!current
+          || currentText !== existingText
+          || isProcessAlive(Number(current.pid))) {
+          if (typeof openExisting === 'function') {
+            openExisting(current);
+          }
+          return { acquired: false, path, existing: current, error };
+        }
+        unlinkSync(path);
+        try {
+          publishCompleteLock(path, stagedPath, payload);
+        } catch (takeoverError) {
+          const winner = readLock(path);
+          if (typeof openExisting === 'function') {
+            openExisting(winner);
+          }
+          return { acquired: false, path, existing: winner, error: takeoverError };
+        }
+        let released = false;
+        const release = () => {
+          if (released) return;
+          released = true;
+          releaseOwnedLock(path, payload);
+        };
+        return { acquired: true, path, payload, release };
+      } finally {
+        releaseOwnedLock(takeoverPath, takeoverPayload);
+      }
+    }
+    // An unreadable existing file is never evidence that the lock is stale.
+    // Preserve it and fail closed; the next invocation can repair it after its
+    // owner disappears, without ever admitting two launchers concurrently.
+    if (typeof openExisting === 'function') {
+      openExisting(existing);
     }
     return { acquired: false, path, existing, error };
   }