@livedesk/hub 0.1.59 → 0.1.64

package/src/pwa-runtime-diagnostic-store.mjs

@@ -0,0 +1,365 @@
+export const PWA_RUNTIME_DIAGNOSTIC_STORE_SCHEMA = 'livedesk.pwa-runtime-diagnostics.v1';
+export const PWA_RUNTIME_DIAGNOSTIC_STORE_MAX_BATCH_EVENTS = 32;
+export const PWA_RUNTIME_DIAGNOSTIC_STORE_MAX_BATCH_UTF8_BYTES = 24 * 1024;
+export const PWA_RUNTIME_DIAGNOSTIC_STORE_MAX_EVENT_UTF8_BYTES = 4 * 1024;
+export const PWA_RUNTIME_DIAGNOSTIC_STORE_MAX_EVENTS_PER_OWNER = 128;
+export const PWA_RUNTIME_DIAGNOSTIC_STORE_MAX_TOTAL_EVENTS = 1_024;
+export const PWA_RUNTIME_DIAGNOSTIC_STORE_MAX_OWNERS = 64;
+export const PWA_RUNTIME_DIAGNOSTIC_STORE_INSTANCE_ID_MIN_LENGTH = 16;
+export const PWA_RUNTIME_DIAGNOSTIC_STORE_INSTANCE_ID_MAX_LENGTH = 64;
+
+const ALLOWED_EVENT_TYPES = new Set([
+  'client.started',
+  'client.stopped',
+  'session.changed',
+  'visibility.changed',
+  'frame.owner.changed',
+  'frame.transport.changed',
+  'frame.recovery.changed',
+  'stream.state.changed',
+  'control.state.changed',
+  'audio.state.changed',
+  'hub.request.failed'
+]);
+const SENSITIVE_KEY = /token|auth(?:orization)?|bearer|cookie|secret|password|credential|api[-_]?key|access[-_]?key|private[-_]?key|connection[-_]?string|pair/i;
+// Fixed prefixes plus flat character classes keep value-only credential
+// detection linear while covering the provider formats most likely to appear
+// in otherwise unlabeled runtime output.
+const KNOWN_SECRET_VALUE = /\b(?:sk-(?:proj-|ant-)?[A-Za-z0-9_-]{8,}|gh[pousr]_[A-Za-z0-9]{8,}|github_pat_[A-Za-z0-9_]{8,}|(?:AKIA|ASIA)[A-Z0-9]{16}|AIza[A-Za-z0-9_-]{35}|npm_[A-Za-z0-9]{8,}|xox[a-z]-[A-Za-z0-9-]{8,}|(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{8,})\b/g;
+const encoder = new TextEncoder();
+
+function utf8Bytes(value) {
+  return encoder.encode(String(value ?? '')).byteLength;
+}
+
+function truncateUtf8(value, maxBytes) {
+  const source = String(value ?? '');
+  if (utf8Bytes(source) <= maxBytes) return source;
+  let result = '';
+  let used = 0;
+  for (const character of source) {
+    const size = utf8Bytes(character);
+    if (used + size > maxBytes) break;
+    result += character;
+    used += size;
+  }
+  return result;
+}
+
+function redactText(value, maxBytes = 1_000) {
+  return truncateUtf8(String(value ?? '')
+    .replace(/-----BEGIN ([A-Z0-9 ]*PRIVATE KEY)-----[\s\S]*?-----END \1-----/gi, '[redacted private key]')
+    .replace(/\b((?:Proxy-)?Authorization)\s*:\s*[^\r\n]*/gi, '$1: [redacted]')
+    .replace(/\b((?:Set-Cookie|Cookie))\s*:\s*[^\r\n]*/gi, '$1: [redacted]')
+    .replace(/[\u0000-\u001f\u007f]/g, ' ')
+    .replace(/("[a-z0-9_-]*(?:token|authorization|cookie|secret|password|credential|api[-_]?key|access[-_]?key|private[-_]?key|connection[-_]?string|pair)[a-z0-9_-]*"\s*:\s*")([^"]*)(")/gi, '$1[redacted]$3')
+    .replace(/\b([a-z0-9_-]*(?:token|authorization|cookie|secret|password|credential|api[-_]?key|access[-_]?key|private[-_]?key|connection[-_]?string|pair)[a-z0-9_-]*)\s*[:=]\s*([^\s,;&]+)/gi, '$1=[redacted]')
+    .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]+/gi, 'Bearer [redacted]')
+    .replace(/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g, '[redacted]')
+    .replace(KNOWN_SECRET_VALUE, '[redacted]')
+    .trim(), maxBytes);
+}
+
+function redactValue(value, depth = 0) {
+  if (depth > 3) return '[truncated]';
+  if (typeof value === 'string') return redactText(value, 1_000);
+  if (typeof value === 'number') return Number.isFinite(value) ? value : 'unknown';
+  if (typeof value === 'boolean' || value === null) return value;
+  if (Array.isArray(value)) return value.slice(0, 16).map(item => redactValue(item, depth + 1));
+  if (!value || typeof value !== 'object') return redactText(value, 200) || 'unknown';
+  return Object.fromEntries(Object.entries(value).slice(0, 16).map(([rawKey, child]) => {
+    const key = redactText(rawKey, 80) || 'unknown';
+    return [key, SENSITIVE_KEY.test(key) ? '[redacted]' : redactValue(child, depth + 1)];
+  }));
+}
+
+function boundedInteger(value, fallback, minimum, maximum) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return fallback;
+  return Math.max(minimum, Math.min(maximum, Math.floor(numeric)));
+}
+
+function normalizeOwner(value = {}) {
+  return Object.freeze({
+    clientId: redactText(value.clientId, 160) || 'unknown',
+    sessionId: redactText(value.sessionId, 160) || 'unknown'
+  });
+}
+
+function normalizeInstanceId(value) {
+  if (typeof value !== 'string') return null;
+  if (
+    value.length < PWA_RUNTIME_DIAGNOSTIC_STORE_INSTANCE_ID_MIN_LENGTH
+    || value.length > PWA_RUNTIME_DIAGNOSTIC_STORE_INSTANCE_ID_MAX_LENGTH
+    || !/^[A-Za-z0-9_-]+$/.test(value)
+  ) {
+    return null;
+  }
+  return value;
+}
+
+function ownerKey(owner) {
+  return `${owner.clientId}\u0000${owner.sessionId}`;
+}
+
+function claimedOwnerMismatch(claimedOwner, authoritativeOwner) {
+  return (claimedOwner.clientId !== 'unknown' && claimedOwner.clientId !== authoritativeOwner.clientId)
+    || (claimedOwner.sessionId !== 'unknown' && claimedOwner.sessionId !== authoritativeOwner.sessionId);
+}
+
+function normalizeEvent(input, authoritativeOwner, authoritativeInstanceId, receivedAt) {
+  const type = redactText(input?.type, 80);
+  if (!ALLOWED_EVENT_TYPES.has(type)) {
+    return { ok: false, error: 'event-type-not-allowed' };
+  }
+  const numericSequence = Number(input?.sequence);
+  if (!Number.isSafeInteger(numericSequence) || numericSequence < 1) {
+    return { ok: false, error: 'invalid-event-sequence' };
+  }
+  const claimedInstanceId = normalizeInstanceId(input?.instanceId);
+  if (!claimedInstanceId) {
+    return { ok: false, error: 'invalid-event-instance-id' };
+  }
+  if (claimedInstanceId !== authoritativeInstanceId) {
+    return { ok: false, error: 'event-instance-mismatch' };
+  }
+  const claimedOwner = normalizeOwner(input?.owner);
+  if (claimedOwnerMismatch(claimedOwner, authoritativeOwner)) {
+    return { ok: false, error: 'event-owner-mismatch' };
+  }
+  const missingEvidence = Array.isArray(input?.missingEvidence)
+    ? input.missingEvidence.slice(0, 8).map(item => redactText(item, 80)).filter(Boolean)
+    : [];
+  const component = redactText(input?.component, 80) || 'unknown';
+  const state = redactText(input?.state, 120) || 'unknown';
+  const reason = redactText(input?.reason, 500) || 'unknown';
+  const sourceTimestamp = redactText(input?.sourceTimestamp, 80) || 'unknown';
+  if (component === 'unknown' && !missingEvidence.includes('component')) missingEvidence.push('component');
+  if (state === 'unknown' && !missingEvidence.includes('state')) missingEvidence.push('state');
+  if (reason === 'unknown' && !missingEvidence.includes('reason')) missingEvidence.push('reason');
+  if (sourceTimestamp === 'unknown' && !missingEvidence.includes('sourceTimestamp')) missingEvidence.push('sourceTimestamp');
+  if (authoritativeOwner.clientId === 'unknown' && !missingEvidence.includes('owner.clientId')) {
+    missingEvidence.push('owner.clientId');
+  }
+  if (authoritativeOwner.sessionId === 'unknown' && !missingEvidence.includes('owner.sessionId')) {
+    missingEvidence.push('owner.sessionId');
+  }
+  let event = {
+    instanceId: authoritativeInstanceId,
+    sequence: numericSequence,
+    sourceTimestamp,
+    receivedAt,
+    type,
+    component,
+    state,
+    reason,
+    owner: authoritativeOwner,
+    ownerEvidence: authoritativeOwner.clientId === 'unknown' || authoritativeOwner.sessionId === 'unknown'
+      ? 'unknown'
+      : 'observed',
+    missingEvidence,
+    details: redactValue(input?.details ?? {})
+  };
+  if (utf8Bytes(JSON.stringify(event)) > PWA_RUNTIME_DIAGNOSTIC_STORE_MAX_EVENT_UTF8_BYTES) {
+    event = { ...event, details: { truncated: true } };
+  }
+  return { ok: true, event: Object.freeze(event) };
+}
+
+/**
+ * In-memory Hub retention for authenticated PWA lifecycle diagnostics.
+ *
+ * The HTTP handler must pass the owner derived from its authenticated request
+ * context. Payload owner fields are only mismatch checks and never authority.
+ */
+export function createPwaRuntimeDiagnosticStore(options = {}) {
+  const now = typeof options.now === 'function' ? options.now : () => Date.now();
+  const maxEventsPerOwner = boundedInteger(
+    options.maxEventsPerOwner,
+    PWA_RUNTIME_DIAGNOSTIC_STORE_MAX_EVENTS_PER_OWNER,
+    1,
+    PWA_RUNTIME_DIAGNOSTIC_STORE_MAX_EVENTS_PER_OWNER
+  );
+  const maxTotalEvents = boundedInteger(
+    options.maxTotalEvents,
+    PWA_RUNTIME_DIAGNOSTIC_STORE_MAX_TOTAL_EVENTS,
+    1,
+    PWA_RUNTIME_DIAGNOSTIC_STORE_MAX_TOTAL_EVENTS
+  );
+  const maxOwners = boundedInteger(
+    options.maxOwners,
+    PWA_RUNTIME_DIAGNOSTIC_STORE_MAX_OWNERS,
+    1,
+    PWA_RUNTIME_DIAGNOSTIC_STORE_MAX_OWNERS
+  );
+  let events = [];
+  const ownerStats = new Map();
+  let hubDroppedTotal = 0;
+  let evictedOwnerCount = 0;
+
+  const incrementHubDrop = key => {
+    hubDroppedTotal += 1;
+    const stats = ownerStats.get(key);
+    if (stats) stats.hubDropped += 1;
+  };
+
+  const ensureOwnerStats = (key, owner, receivedAt) => {
+    let stats = ownerStats.get(key);
+    if (stats) {
+      stats.lastReceivedAt = receivedAt;
+      return stats;
+    }
+    if (ownerStats.size >= maxOwners) {
+      let oldestKey = null;
+      let oldestTimestamp = Number.POSITIVE_INFINITY;
+      for (const [candidateKey, candidate] of ownerStats) {
+        if (candidate.lastReceivedMs < oldestTimestamp) {
+          oldestTimestamp = candidate.lastReceivedMs;
+          oldestKey = candidateKey;
+        }
+      }
+      if (oldestKey !== null) {
+        const removedCount = events.filter(event => ownerKey(event.owner) === oldestKey).length;
+        events = events.filter(event => ownerKey(event.owner) !== oldestKey);
+        hubDroppedTotal += removedCount;
+        ownerStats.delete(oldestKey);
+        evictedOwnerCount += 1;
+      }
+    }
+    stats = {
+      owner,
+      clientDroppedTotal: 'unknown',
+      hubDropped: 0,
+      lastReceivedAt: receivedAt,
+      lastReceivedMs: Number(now()) || Date.now()
+    };
+    ownerStats.set(key, stats);
+    return stats;
+  };
+
+  const ingest = (payload, context = {}) => {
+    let serialized;
+    try {
+      serialized = JSON.stringify(payload);
+    } catch {
+      return Object.freeze({ accepted: false, error: 'invalid-json-payload' });
+    }
+    if (utf8Bytes(serialized) > PWA_RUNTIME_DIAGNOSTIC_STORE_MAX_BATCH_UTF8_BYTES) {
+      return Object.freeze({ accepted: false, error: 'batch-too-large' });
+    }
+    if (!payload || typeof payload !== 'object' || payload.schema !== PWA_RUNTIME_DIAGNOSTIC_STORE_SCHEMA) {
+      return Object.freeze({ accepted: false, error: 'invalid-schema' });
+    }
+    const instanceId = normalizeInstanceId(payload.instanceId);
+    if (!instanceId) {
+      return Object.freeze({ accepted: false, error: 'invalid-instance-id' });
+    }
+    if (!Array.isArray(payload.events) || payload.events.length > PWA_RUNTIME_DIAGNOSTIC_STORE_MAX_BATCH_EVENTS) {
+      return Object.freeze({ accepted: false, error: 'invalid-event-count' });
+    }
+    const authoritativeOwner = normalizeOwner(context.owner || {
+      clientId: context.authenticatedClientId,
+      sessionId: context.authenticatedSessionId
+    });
+    const claimedOwner = normalizeOwner(payload.owner);
+    if (claimedOwnerMismatch(claimedOwner, authoritativeOwner)) {
+      return Object.freeze({ accepted: false, error: 'batch-owner-mismatch' });
+    }
+    const receivedAt = new Date(Number(now()) || Date.now()).toISOString();
+    const normalizedEvents = [];
+    for (const input of payload.events) {
+      const normalized = normalizeEvent(input, authoritativeOwner, instanceId, receivedAt);
+      if (!normalized.ok) return Object.freeze({ accepted: false, error: normalized.error });
+      normalizedEvents.push(normalized.event);
+    }
+    const key = ownerKey(authoritativeOwner);
+    const stats = ensureOwnerStats(key, authoritativeOwner, receivedAt);
+    stats.lastReceivedMs = Number(now()) || Date.now();
+    const clientDroppedTotal = Number(payload?.droppedCount?.total);
+    if (Number.isSafeInteger(clientDroppedTotal) && clientDroppedTotal >= 0) {
+      stats.clientDroppedTotal = stats.clientDroppedTotal === 'unknown'
+        ? clientDroppedTotal
+        : Math.max(stats.clientDroppedTotal, clientDroppedTotal);
+    }
+
+    let acceptedEventCount = 0;
+    let duplicateEventCount = 0;
+    for (const event of normalizedEvents) {
+      const duplicate = events.some(existing => (
+        ownerKey(existing.owner) === key
+        && existing.instanceId === event.instanceId
+        && existing.sequence === event.sequence
+      ));
+      if (duplicate) {
+        duplicateEventCount += 1;
+        continue;
+      }
+      const ownerEventCount = events.reduce(
+        (count, existing) => count + (ownerKey(existing.owner) === key ? 1 : 0),
+        0
+      );
+      if (ownerEventCount >= maxEventsPerOwner) {
+        const oldestOwnerIndex = events.findIndex(existing => ownerKey(existing.owner) === key);
+        if (oldestOwnerIndex >= 0) {
+          events.splice(oldestOwnerIndex, 1);
+          incrementHubDrop(key);
+        }
+      }
+      if (events.length >= maxTotalEvents) {
+        const removed = events.shift();
+        if (removed) incrementHubDrop(ownerKey(removed.owner));
+      }
+      events.push(event);
+      acceptedEventCount += 1;
+    }
+    return Object.freeze({
+      accepted: true,
+      owner: authoritativeOwner,
+      ownerEvidence: authoritativeOwner.clientId === 'unknown' || authoritativeOwner.sessionId === 'unknown'
+        ? 'unknown'
+        : 'observed',
+      acceptedEventCount,
+      duplicateEventCount,
+      retainedEventCount: events.length,
+      clientDroppedTotal: stats.clientDroppedTotal,
+      hubDroppedTotal
+    });
+  };
+
+  const list = ({ clientId, sessionId, limit = 200 } = {}) => {
+    const clientFilter = redactText(clientId, 160) || null;
+    const sessionFilter = redactText(sessionId, 160) || null;
+    const boundedLimit = boundedInteger(limit, 200, 1, 500);
+    const matched = events.filter(event => (
+      (!clientFilter || event.owner.clientId === clientFilter)
+      && (!sessionFilter || event.owner.sessionId === sessionFilter)
+    ));
+    const exactKey = clientFilter && sessionFilter ? ownerKey({ clientId: clientFilter, sessionId: sessionFilter }) : null;
+    const stats = exactKey ? ownerStats.get(exactKey) : null;
+    return Object.freeze({
+      schema: PWA_RUNTIME_DIAGNOSTIC_STORE_SCHEMA,
+      evidenceStatus: matched.length > 0 ? 'observed' : 'unknown',
+      queryOwner: Object.freeze({
+        clientId: clientFilter || 'unknown',
+        sessionId: sessionFilter || 'unknown'
+      }),
+      droppedCount: Object.freeze({
+        client: stats?.clientDroppedTotal ?? 'unknown',
+        hub: stats?.hubDropped ?? hubDroppedTotal
+      }),
+      events: Object.freeze(matched.slice(-boundedLimit).reverse())
+    });
+  };
+
+  const inspect = () => Object.freeze({
+    retainedEventCount: events.length,
+    retainedOwnerCount: ownerStats.size,
+    hubDroppedTotal,
+    evictedOwnerCount,
+    maxEventsPerOwner,
+    maxTotalEvents,
+    maxOwners
+  });
+
+  return Object.freeze({ ingest, list, inspect });
+}