livedesk 0.1.459 → 0.1.461

package/diagnostics/livedesk-transport-physical-core.mjs

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { isIP } from 'node:net';
 
 const REQUIRED_PHASES = Object.freeze([
@@ -33,6 +34,7 @@ const SAFE_NETWORK_KEYS = new Set([
   'differentpublicegress',
   'evidence',
   'observedat',
+  'rendezvousport',
   'udpready'
 ]);
 const IDENTIFIER_KEYS = new Set([
@@ -50,12 +52,65 @@ const IDENTIFIER_KEYS = new Set([
   'clientid',
   'ownerid'
 ]);
+const FILESYSTEM_KEYS = new Set([
+  'cwd',
+  'directory',
+  'dirname',
+  'executablepath',
+  'filepath',
+  'filename',
+  'homedir',
+  'packagepath',
+  'path',
+  'reportpath'
+]);
 const SECRET_TEXT = /\b(?:authorization|bearer|token|secret|password|api[-_ ]?key|pair[-_ ]?token)(?:\s+|\s*[:=]\s*)\S+/i;
+const FILESYSTEM_TEXT = /(?:^|\s)(?:[a-z]:[\\/]|\\\\[^\\\s]+\\|\/(?:applications|etc|home|opt|private|run|srv|tmp|users|usr|var|volumes)\/)\S*/i;
 const IPV4_TEXT = /(^|[^\d])(?:\d{1,3}\.){3}\d{1,3}(?::\d{1,5})?($|[^\d])/;
 const IPV6_CANDIDATE_TEXT = /\[[0-9a-f:.%]+\](?::\d{1,5})?|[0-9a-f:%]*:[0-9a-f:.%:]*/gi;
 const URL_TEXT = /\b[a-z][a-z0-9+.-]*:\/\/[^\s]+/i;
 const HOST_TEXT = /\b(?:localhost|(?:[a-z0-9-]+\.)+[a-z]{2,63})(?::\d{1,5})?\b/i;
 const UUID_TEXT = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i;
+const SAFE_PLATFORMS = new Set([
+  'aix',
+  'android',
+  'darwin',
+  'freebsd',
+  'linux',
+  'macos',
+  'openbsd',
+  'sunos',
+  'win32',
+  'windows'
+]);
+const SAFE_ARCHITECTURES = new Set([
+  'arm',
+  'arm64',
+  'ia32',
+  'loong64',
+  'mips',
+  'mipsel',
+  'ppc',
+  'ppc64',
+  'riscv64',
+  's390',
+  's390x',
+  'x64'
+]);
+const SAFE_RUNTIME_STATES = new Set([
+  'booting',
+  'connecting',
+  'error',
+  'resolving-role',
+  'running',
+  'starting',
+  'stopping',
+  'switching',
+  'updating',
+  'waiting-auth'
+]);
+const SAFE_RUNTIME_ROLES = new Set(['client', 'hub']);
+const SAFE_VERSION = /^(?:v)?\d+(?:\.\d+){1,3}(?:[-+][0-9a-z][0-9a-z.-]{0,47})?$/i;
 
 function normalizedKey(key) {
   return String(key || '').replace(/[-_]/g, '').toLowerCase();
@@ -74,6 +129,10 @@ function isSecretKey(key) {
     || normalized.endsWith('apikey');
 }
 
+function isRawFilesystemKey(key) {
+  return FILESYSTEM_KEYS.has(normalizedKey(key));
+}
+
 function isRawNetworkKey(key) {
   const rawKey = String(key || '');
   const normalized = normalizedKey(key);
@@ -119,6 +178,139 @@ function identifierMarker(value) {
   return '[redacted-id]';
 }
 
+function normalizedEnum(value, allowed) {
+  const normalized = String(value || '').trim().toLowerCase();
+  return allowed.has(normalized) ? normalized : 'unknown';
+}
+
+function normalizedVersion(value) {
+  const normalized = String(value || '').trim();
+  if (normalized === 'dev') return 'dev';
+  return SAFE_VERSION.test(normalized) && isIP(normalized.replace(/^v/i, '')) === 0
+    ? normalized
+    : 'unknown';
+}
+
+function normalizedPackageName(value, fallback = '') {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (normalized === 'livedesk' || /^@livedesk\/[a-z0-9-]{1,48}$/.test(normalized)) {
+    return normalized;
+  }
+  return fallback;
+}
+
+function normalizedBoolean(value) {
+  return typeof value === 'boolean' ? value : null;
+}
+
+function isAllowedStructuredScalar(key, value) {
+  const normalized = normalizedKey(key);
+  const text = String(value || '');
+  if (normalized === 'schema') {
+    return /^livedesk\.transport-physical\.v\d+$/.test(text);
+  }
+  if (normalized.endsWith('hash')) {
+    return /^sha256:[0-9a-f]{20,64}$/.test(text);
+  }
+  if ([
+    'agentversion',
+    'appversion',
+    'managerversion',
+    'nodeversion',
+    'packageversion',
+    'productversion'
+  ].includes(normalized)) {
+    return text === 'unknown'
+      || text === 'dev'
+      || normalizedVersion(text) === text;
+  }
+  return false;
+}
+
+function stableFingerprint(value) {
+  const normalized = String(value || '').trim();
+  if (!normalized) return '';
+  return `sha256:${createHash('sha256').update(normalized).digest('hex').slice(0, 20)}`;
+}
+
+function runtimeFingerprint(value = {}) {
+  const explicit = String(value.runtimeId || value.sessionId || '').trim();
+  if (explicit) return stableFingerprint(explicit);
+  const pid = Number(value.runtimePid ?? value.pid);
+  const startedAt = String(value.startedAt || value.connectedAt || '').trim();
+  if (!Number.isSafeInteger(pid) || pid <= 0 || !startedAt) return '';
+  return stableFingerprint(`${pid}:${startedAt}`);
+}
+
+function normalizedRendezvousEndpoint(value = {}) {
+  let rawHost = String(value.host || value.rendezvousHost || '').trim();
+  let rawPort = Number(value.port ?? value.rendezvousPort);
+  if (rawHost) {
+    try {
+      const parsed = new URL(rawHost.includes('://') ? rawHost : `udp://${rawHost}`);
+      rawHost = parsed.hostname.replace(/^\[|\]$/g, '').toLowerCase().replace(/\.$/, '');
+      if ((!Number.isSafeInteger(rawPort) || rawPort < 1 || rawPort > 65_535)
+        && parsed.port) {
+        rawPort = Number(parsed.port);
+      }
+    } catch {
+      rawHost = '';
+    }
+  }
+  const rendezvousPort = Number.isSafeInteger(rawPort) && rawPort >= 1 && rawPort <= 65_535
+    ? rawPort
+    : null;
+  return {
+    endpointKind: 'udp-rendezvous',
+    configured: !!rawHost && rendezvousPort !== null,
+    hostHash: stableFingerprint(rawHost),
+    rendezvousPort
+  };
+}
+
+export function buildTransportPhysicalProvenance(input = {}) {
+  const liveDeskPackage = input.liveDeskPackage || {};
+  const runner = input.runner || {};
+  const hubRuntime = input.hubRuntime || {};
+  const hubRemote = input.hubRemote || {};
+  const client = input.client || {};
+  const udp = input.rendezvous || hubRemote.udp || {};
+  const hubVersion = normalizedVersion(hubRuntime.appVersion);
+  const managerVersion = normalizedVersion(hubRemote.managerVersion);
+  return {
+    livedesk: {
+      packageName: 'livedesk',
+      packageVersion: normalizedVersion(liveDeskPackage.version)
+    },
+    runner: {
+      nodeVersion: normalizedVersion(runner.nodeVersion),
+      platform: normalizedEnum(runner.platform, SAFE_PLATFORMS),
+      arch: normalizedEnum(runner.arch, SAFE_ARCHITECTURES)
+    },
+    hub: {
+      packageName: normalizedPackageName(hubRemote.managerPackage, '@livedesk/hub'),
+      appVersion: hubVersion !== 'unknown' ? hubVersion : managerVersion,
+      managerVersion,
+      role: normalizedEnum(hubRuntime.role || hubRemote.runtimeRole, SAFE_RUNTIME_ROLES),
+      state: normalizedEnum(hubRuntime.state, SAFE_RUNTIME_STATES),
+      runtimeStarted: normalizedBoolean(hubRuntime.runtimeStarted),
+      runtimeIdentityHash: runtimeFingerprint(hubRuntime)
+    },
+    client: {
+      productVersion: normalizedVersion(client.productVersion),
+      agentVersion: normalizedVersion(client.agentVersion),
+      platform: normalizedEnum(client.platform, SAFE_PLATFORMS),
+      arch: normalizedEnum(client.arch, SAFE_ARCHITECTURES),
+      runtimeIdentityHash: runtimeFingerprint(client)
+    },
+    rendezvous: {
+      ...normalizedRendezvousEndpoint(udp),
+      enabled: normalizedBoolean(udp.enabled),
+      started: normalizedBoolean(udp.started)
+    }
+  };
+}
+
 export function genericTransportPhysicalError(value, fallback = 'transport-diagnostic-error') {
   const text = String(value instanceof Error ? value.message : value || '').trim();
   if (!text
@@ -132,6 +324,7 @@ export function genericTransportPhysicalError(value, fallback = 'transport-diagn
 export function redactTransportPhysicalReport(value, key = '') {
   if (isSecretKey(key)) return '[redacted]';
   if (isIdentifierKey(key)) return identifierMarker(value);
+  if (isRawFilesystemKey(key)) return '[redacted-path]';
   if (isRawNetworkKey(key)) return '[redacted-network]';
   if (Array.isArray(value)) {
     return value.map(item => redactTransportPhysicalReport(item));
@@ -145,7 +338,9 @@ export function redactTransportPhysicalReport(value, key = '') {
       ]));
   }
   if (typeof value === 'string'
+    && !isAllowedStructuredScalar(key, value)
     && (containsRawNetworkText(value)
+      || FILESYSTEM_TEXT.test(value)
       || SECRET_TEXT.test(value)
       || UUID_TEXT.test(value))) {
     return /error|reason|detail|summary/i.test(key)
@@ -163,6 +358,7 @@ export function findTransportPhysicalReportLeaks(value, path = '$', leaks = [])
   if (value && typeof value === 'object') {
     for (const [key, child] of Object.entries(value)) {
       if (isSecretKey(key)
+        || (isRawFilesystemKey(key) && child !== '[redacted-path]')
         || (isRawNetworkKey(key) && child !== '[redacted-network]')) {
         leaks.push(`${path}.${key}`);
       }
@@ -176,7 +372,9 @@ export function findTransportPhysicalReportLeaks(value, path = '$', leaks = [])
     return leaks;
   }
   if (typeof value === 'string'
+    && !isAllowedStructuredScalar(path.split('.').at(-1)?.replace(/\[\d+\]$/, ''), value)
     && (containsRawNetworkText(value)
+      || FILESYSTEM_TEXT.test(value)
       || SECRET_TEXT.test(value)
       || UUID_TEXT.test(value))) {
     leaks.push(path);
@@ -482,10 +680,11 @@ export function classifyTransportPhysicalSnapshot(snapshot) {
 export function buildTransportPhysicalReport(snapshot, context = {}) {
   const classified = classifyTransportPhysicalSnapshot(snapshot);
   const report = redactTransportPhysicalReport({
-    schema: 'livedesk.transport-physical.v1',
+    schema: 'livedesk.transport-physical.v2',
     generatedAt: new Date().toISOString(),
     hubUrl: context.hubUrl,
     selectedDeviceId: context.deviceId,
+    provenance: buildTransportPhysicalProvenance(context.provenance),
     result: classified,
     transport: snapshot
   });

package/diagnostics/livedesk-transport-physical.mjs

@@ -22,6 +22,54 @@ const CLEANUP_RETRY_DELAY_MS = 250;
 const DEFAULT_TTL_MS = 150_000;
 const MIN_TTL_MARGIN_MS = 20_000;
 
+async function readLiveDeskPackageIdentity() {
+  try {
+    const packageInfo = JSON.parse(
+      await fs.readFile(new URL('../package.json', import.meta.url), 'utf8'));
+    return { version: String(packageInfo?.version || '') };
+  } catch {
+    return { version: '' };
+  }
+}
+
+export async function collectTransportPhysicalProvenance({
+  hubUrl = '',
+  deviceId = '',
+  signal,
+  requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS
+} = {}) {
+  const provenance = {
+    liveDeskPackage: await readLiveDeskPackageIdentity(),
+    runner: {
+      nodeVersion: process.versions.node,
+      platform: process.platform,
+      arch: process.arch
+    },
+    hubRuntime: null,
+    hubRemote: null,
+    client: null
+  };
+  if (!hubUrl || !deviceId) return provenance;
+
+  const requests = await Promise.allSettled([
+    requestJson(`${hubUrl}/api/runtime/status`, { signal, requestTimeoutMs }),
+    requestJson(`${hubUrl}/api/remote/status`, { signal, requestTimeoutMs }),
+    requestJson(`${hubUrl}/api/remote/devices`, { signal, requestTimeoutMs })
+  ]);
+  if (signal?.aborted) {
+    throw signal.reason instanceof Error
+      ? signal.reason
+      : new Error('transport diagnostic aborted');
+  }
+  provenance.hubRuntime = requests[0].status === 'fulfilled' ? requests[0].value : null;
+  provenance.hubRemote = requests[1].status === 'fulfilled' ? requests[1].value : null;
+  const devices = requests[2].status === 'fulfilled' && Array.isArray(requests[2].value?.devices)
+    ? requests[2].value.devices
+    : [];
+  provenance.client = devices.find(device => device?.deviceId === deviceId) || null;
+  return provenance;
+}
+
 export function normalizeTransportPhysicalTiming(options = {}) {
   const ttlMs = Math.max(15_000, Math.min(180_000, Number(options.ttlMs) || DEFAULT_TTL_MS));
   const phaseTimeoutMs = Math.max(
@@ -355,6 +403,7 @@ export async function runTransportPhysicalDiagnostic(options = {}) {
   let latest = null;
   let completed = false;
   let runError = null;
+  let provenance = await collectTransportPhysicalProvenance();
 
   const stopForSignal = () => {
     if (!lifecycleController.signal.aborted) {
@@ -369,6 +418,12 @@ export async function runTransportPhysicalDiagnostic(options = {}) {
       options.deviceId || '',
       signal,
       timing.requestTimeoutMs);
+    provenance = await collectTransportPhysicalProvenance({
+      hubUrl,
+      deviceId,
+      signal,
+      requestTimeoutMs: timing.requestTimeoutMs
+    });
     const started = await requestJson(`${hubUrl}/api/remote/diagnostics/transport/start`, {
       method: 'POST',
       body: { deviceId, ttlMs: timing.ttlMs },
@@ -445,7 +500,11 @@ export async function runTransportPhysicalDiagnostic(options = {}) {
       error: genericTransportPhysicalError(runError)
     };
   }
-  const report = buildTransportPhysicalReport(latest || {}, { hubUrl, deviceId });
+  const report = buildTransportPhysicalReport(latest || {}, {
+    hubUrl,
+    deviceId,
+    provenance
+  });
   await writeStableJson(reportPath, report);
   if (runError) {
     const failure = new Error(

package/hub/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/hub",
-  "version": "0.1.26",
+  "version": "0.1.27",
   "description": "LiveDesk local Hub API and browser frame bridge",
   "type": "module",
   "main": "src/server.js",