@livedesk/client 0.1.213 → 0.1.215

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/client",
-  "version": "0.1.213",
+  "version": "0.1.215",
   "description": "LiveDesk local remote client",
   "type": "module",
   "bin": {
@@ -10,9 +10,10 @@
     "livedesk-client-fast": "bin/livedesk-client-fast.js"
   },
   "files": [
-    "bin/",
-    "src/",
-    "README.md",
+    "bin/",
+    "src/",
+    "tests/",
+    "README.md",
     "THIRD_PARTY_NOTICES.md"
   ],
   "scripts": {
@@ -40,10 +41,10 @@
     "ws": "^8.18.3"
   },
   "optionalDependencies": {
-    "@livedesk/fast-linux-x64": "0.1.417",
-    "@livedesk/fast-osx-arm64": "0.1.417",
-    "@livedesk/fast-osx-x64": "0.1.417",
-    "@livedesk/fast-win-x64": "0.1.417"
+    "@livedesk/fast-linux-x64": "0.1.419",
+    "@livedesk/fast-osx-arm64": "0.1.419",
+    "@livedesk/fast-osx-x64": "0.1.419",
+    "@livedesk/fast-win-x64": "0.1.419"
   },
   "publishConfig": {
     "access": "public"

package/src/runtime/client-runtime-server.js

@@ -165,6 +165,12 @@ function readCpuTotals() {
 }
 
 function finiteNumber(value) {
+  if (value === null
+    || value === undefined
+    || typeof value === 'boolean'
+    || (typeof value === 'string' && value.trim() === '')) {
+    return null;
+  }
   const number = Number(value);
   return Number.isFinite(number) && number >= 0 ? number : null;
 }
@@ -300,6 +306,53 @@ function normalizeGpu(value) {
   };
 }
 
+export function normalizeGpuIdentityName(value) {
+  return normalizeString(value, 160)
+    .normalize('NFKC')
+    .replace(/\((?:r|tm)\)/giu, '')
+    .replace(/[®™]/gu, '')
+    .toLocaleLowerCase('en-US')
+    .replace(/[^\p{L}\p{N}]+/gu, ' ')
+    .trim();
+}
+
+export function mergeGpuSnapshots(platformGpus = [], telemetryGpus = []) {
+  const merged = [];
+  const indexesByIdentity = new Map();
+  for (const value of Array.isArray(platformGpus) ? platformGpus : []) {
+    const gpu = normalizeGpu(value);
+    const identity = normalizeGpuIdentityName(gpu?.name);
+    if (!gpu || !identity) continue;
+    const index = merged.length;
+    merged.push(gpu);
+    const indexes = indexesByIdentity.get(identity) || [];
+    indexes.push(index);
+    indexesByIdentity.set(identity, indexes);
+  }
+
+  const matchedIndexes = new Set();
+  for (const value of Array.isArray(telemetryGpus) ? telemetryGpus : []) {
+    const gpu = normalizeGpu(value);
+    const identity = normalizeGpuIdentityName(gpu?.name);
+    if (!gpu || !identity) continue;
+    const existingIndex = (indexesByIdentity.get(identity) || [])
+      .find(index => !matchedIndexes.has(index));
+    if (existingIndex === undefined) {
+      merged.push(gpu);
+      continue;
+    }
+    matchedIndexes.add(existingIndex);
+    const existing = merged[existingIndex];
+    merged[existingIndex] = {
+      ...existing,
+      usagePercent: gpu.usagePercent ?? existing.usagePercent,
+      memoryTotalBytes: gpu.memoryTotalBytes ?? existing.memoryTotalBytes,
+      memoryUsedBytes: gpu.memoryUsedBytes ?? existing.memoryUsedBytes
+    };
+  }
+  return merged;
+}
+
 function normalizeDisk(value) {
   if (!value || typeof value !== 'object') return null;
   const mount = normalizeString(value.mount, 80);
@@ -430,7 +483,10 @@ async function collectHardwareSnapshot() {
 
   const nvidiaGpus = await nvidiaPromise;
   return {
-    gpus: nvidiaGpus.length > 0 ? nvidiaGpus : platformSnapshot.gpus,
+    // Preserve the platform adapter inventory on hybrid-GPU computers. The
+    // NVIDIA sampler enriches its matching adapter instead of replacing every
+    // non-NVIDIA display adapter with the telemetry subset.
+    gpus: mergeGpuSnapshots(platformSnapshot.gpus, nvidiaGpus),
     disks: platformSnapshot.disks,
     collectedAt: new Date().toISOString()
   };
@@ -730,7 +786,11 @@ export function createClientRuntimeServer(options = {}) {
     try {
       const gpus = await collectNvidiaGpuSnapshot();
       if (gpus.length > 0) {
-        hardwareSnapshot = { ...hardwareSnapshot, gpus, collectedAt: new Date().toISOString() };
+        hardwareSnapshot = {
+          ...hardwareSnapshot,
+          gpus: mergeGpuSnapshots(hardwareSnapshot.gpus, gpus),
+          collectedAt: new Date().toISOString()
+        };
       }
     } finally {
       gpuRefreshInFlight = false;

package/src/runtime/windows-owned-process-manifest.js

@@ -1,6 +1,7 @@
-import { randomBytes } from 'node:crypto';
+import { createHash, randomBytes } from 'node:crypto';
 import {
     chmodSync,
+    linkSync,
     mkdirSync,
     readFileSync,
     renameSync,
@@ -85,6 +86,10 @@ function normalizeRecords(values) {
     return [...unique.values()];
 }
 
+function sourceRevision(sourceText) {
+    return createHash('sha256').update(String(sourceText || ''), 'utf8').digest('hex');
+}
+
 function writeJsonAtomic(path, value) {
     mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
     const temporaryPath = `${path}.${process.pid}.${randomBytes(8).toString('hex')}.tmp`;
@@ -157,19 +162,16 @@ export function writeWindowsOwnedProcessManifest({
     }
 }
 
-/**
- * Reads only a fresh manifest belonging to the exact runtime-lock generation.
- * Owner mismatch, malformed identity, expiry, and PID reuse all fail closed.
- */
-export function readWindowsOwnedProcessManifest({
+function readExactWindowsOwnedProcessManifest({
     stateDir,
     owner,
-    maxAgeMs = DEFAULT_WINDOWS_OWNED_PROCESS_MANIFEST_MAX_AGE_MS,
+    maxAgeMs = null,
+    includeRevision = false,
     now
 } = {}) {
     const exactOwner = normalizeOwner(owner);
     const nowMs = resolveNow(now);
-    const maximumAge = Number(maxAgeMs);
+    const maximumAge = maxAgeMs === null ? null : Number(maxAgeMs);
     const path = getWindowsOwnedProcessManifestPath(stateDir);
     if (!exactOwner) {
         return {
@@ -179,8 +181,8 @@ export function readWindowsOwnedProcessManifest({
         };
     }
     if (!Number.isFinite(nowMs)
-        || !Number.isFinite(maximumAge)
-        || maximumAge < 0) {
+        || (maximumAge !== null
+            && (!Number.isFinite(maximumAge) || maximumAge < 0))) {
         return {
             ok: false,
             records: [],
@@ -189,10 +191,17 @@ export function readWindowsOwnedProcessManifest({
     }
 
     let parsed;
+    let sourceText;
     try {
-        parsed = JSON.parse(readFileSync(path, 'utf8'));
+        sourceText = readFileSync(path, 'utf8');
+        parsed = JSON.parse(sourceText);
     } catch (error) {
-        return { ok: false, records: [], error };
+        return {
+            ok: false,
+            records: [],
+            missing: error?.code === 'ENOENT',
+            error
+        };
     }
     const updatedAt = String(parsed?.updatedAt || '');
     const updatedAtMs = Date.parse(updatedAt);
@@ -214,7 +223,7 @@ export function readWindowsOwnedProcessManifest({
     }
     if (!Number.isFinite(updatedAtMs)
         || updatedAtMs > nowMs + MAX_FUTURE_CLOCK_SKEW_MS
-        || nowMs - updatedAtMs > maximumAge) {
+        || (maximumAge !== null && nowMs - updatedAtMs > maximumAge)) {
         return {
             ok: false,
             records: [],
@@ -231,5 +240,163 @@ export function readWindowsOwnedProcessManifest({
             error: resultError('Windows LiveDesk process manifest contains an invalid process identity.')
         };
     }
-    return { ok: true, records: exactRecords, updatedAt };
+    return {
+        ok: true,
+        records: exactRecords,
+        updatedAt,
+        ...(includeRevision ? { revision: sourceRevision(sourceText) } : {})
+    };
+}
+
+/**
+ * Reads only a fresh manifest belonging to the exact runtime-lock generation.
+ * Owner mismatch, malformed identity, expiry, and PID reuse all fail closed.
+ */
+export function readWindowsOwnedProcessManifest({
+    stateDir,
+    owner,
+    maxAgeMs = DEFAULT_WINDOWS_OWNED_PROCESS_MANIFEST_MAX_AGE_MS,
+    now
+} = {}) {
+    return readExactWindowsOwnedProcessManifest({
+        stateDir,
+        owner,
+        maxAgeMs,
+        now
+    });
+}
+
+/**
+ * Recovers only the exact manifest generation returned by a successful
+ * stale-lock compare-and-swap. Its age is intentionally unbounded because a
+ * machine can be restarted long after the launcher and Agent died. Malformed,
+ * mismatched, or future-dated manifests still fail closed.
+ */
+export function readDeadWindowsOwnedProcessManifest({
+    stateDir,
+    owner,
+    now
+} = {}) {
+    return readExactWindowsOwnedProcessManifest({
+        stateDir,
+        owner,
+        maxAgeMs: null,
+        includeRevision: true,
+        now
+    });
+}
+
+/**
+ * Atomically quarantines and consumes only the exact dead-owner manifest
+ * revision that was drained. If another generation replaces the canonical
+ * path between validation and rename, the moved file is restored or preserved
+ * instead of ever being deleted.
+ */
+export function consumeDeadWindowsOwnedProcessManifest({
+    stateDir,
+    owner,
+    revision,
+    now
+} = {}) {
+    const exactOwner = normalizeOwner(owner);
+    const expectedRevision = String(revision || '').trim().toLowerCase();
+    const nowMs = resolveNow(now);
+    const path = getWindowsOwnedProcessManifestPath(stateDir);
+    if (!exactOwner || !/^[a-f0-9]{64}$/.test(expectedRevision)) {
+        return {
+            ok: false,
+            error: resultError('An exact Windows manifest owner and revision are required for consumption.')
+        };
+    }
+    if (!Number.isFinite(nowMs)) {
+        return { ok: false, error: resultError('A valid manifest consumption time is required.') };
+    }
+
+    const current = readDeadWindowsOwnedProcessManifest({
+        stateDir,
+        owner: exactOwner,
+        now: nowMs
+    });
+    if (!current.ok) {
+        return current.missing === true
+            ? { ok: true, path, consumed: false, missing: true }
+            : { ...current, path, consumed: false };
+    }
+    if (current.revision !== expectedRevision) {
+        return {
+            ok: false,
+            path,
+            consumed: false,
+            error: resultError('Windows LiveDesk process manifest changed after its exact process set was drained.')
+        };
+    }
+
+    const quarantinePath = `${path}.consume.${process.pid}.${randomBytes(8).toString('hex')}`;
+    try {
+        renameSync(path, quarantinePath);
+    } catch (error) {
+        return { ok: false, path, quarantinePath, consumed: false, error };
+    }
+
+    let movedSourceText = '';
+    let movedParsed = null;
+    try {
+        movedSourceText = readFileSync(quarantinePath, 'utf8');
+        movedParsed = JSON.parse(movedSourceText);
+    } catch {
+        // The exact post-rename validation below restores or preserves this
+        // file; unreadable content is never evidence that deletion is safe.
+    }
+    const movedUpdatedAtMs = Date.parse(String(movedParsed?.updatedAt || ''));
+    const movedRecords = normalizeRecords(movedParsed?.records);
+    const movedIsExact = movedParsed?.protocolVersion === WINDOWS_OWNED_PROCESS_MANIFEST_VERSION
+        && ownersMatch(movedParsed?.owner, exactOwner)
+        && Number.isFinite(movedUpdatedAtMs)
+        && movedUpdatedAtMs <= nowMs + MAX_FUTURE_CLOCK_SKEW_MS
+        && movedRecords !== null
+        && sourceRevision(movedSourceText) === expectedRevision;
+    if (!movedIsExact) {
+        let restored = false;
+        let restoreError = null;
+        try {
+            // Hard-link publication is create-if-absent. Unlike rename, it
+            // can never overwrite a newer canonical generation that appears
+            // during restoration.
+            linkSync(quarantinePath, path);
+            restored = true;
+            try { unlinkSync(quarantinePath); } catch { /* both exact links safely preserve the file */ }
+        } catch (error) {
+            restoreError = error;
+        }
+        return {
+            ok: false,
+            path,
+            quarantinePath: restored ? undefined : quarantinePath,
+            consumed: false,
+            error: resultError(
+                'Windows LiveDesk process manifest changed during consumption; '
+                + `${restored ? 'the moved generation was restored.' : 'the moved generation was preserved.'}`
+                + `${restoreError?.message ? ` ${restoreError.message}` : ''}`
+            )
+        };
+    }
+
+    try {
+        unlinkSync(quarantinePath);
+        return {
+            ok: true,
+            path,
+            revision: expectedRevision,
+            records: movedRecords,
+            consumed: true
+        };
+    } catch (error) {
+        return {
+            ok: false,
+            path,
+            quarantinePath,
+            consumed: false,
+            error
+        };
+    }
 }

package/tests/client-version.test.mjs

@@ -0,0 +1,27 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import test from 'node:test';
+import { formatClientVersionBanner, readClientPackageVersion } from '../bin/client-version.js';
+
+const packageInfo = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+
+test('reads the version shipped in the @livedesk/client npm package', () => {
+    assert.equal(readClientPackageVersion(), packageInfo.version);
+});
+
+test('prints the public launcher version in the user-facing banner', () => {
+    assert.equal(
+        formatClientVersionBanner({
+            LIVEDESK_NPM_LAUNCHER_NAME: 'livedesk',
+            LIVEDESK_NPM_LAUNCHER_VERSION: '9.8.7'
+        }),
+        '[LiveDesk Client] livedesk@9.8.7'
+    );
+});
+
+test('uses the product name for direct client launches', () => {
+    assert.equal(
+        formatClientVersionBanner({}),
+        `[LiveDesk Client] livedesk@${packageInfo.version}`
+    );
+});