@livedesk/hub 0.1.58 → 0.1.61

package/src/http/hub-ui-session.js

@@ -34,33 +34,97 @@ function randomToken() {
   return crypto.randomBytes(32).toString('base64url');
 }
 
-export function createHubUiSessionAuthority({
-  ttlMs = HUB_UI_SESSION_TTL_MS,
-  maxSessions = 32,
-  now = () => Date.now()
-} = {}) {
-  const sessions = new Map();
+export function createHubUiSessionAuthority({
+  ttlMs = HUB_UI_SESSION_TTL_MS,
+  maxSessions = 32,
+  now = () => Date.now(),
+  onRevoke = () => {}
+} = {}) {
+  const sessions = new Map();
+
+  function dropSession(sessionId, reason) {
+    const session = sessions.get(sessionId);
+    if (!session) return null;
+    sessions.delete(sessionId);
+    try {
+      onRevoke({ sessionId, ...session }, String(reason || 'hub-ui-session-revoked'));
+    } catch {
+      // Revocation remains authoritative even if a best-effort socket cleanup
+      // listener fails. The next protected request still fails closed.
+    }
+    return session;
+  }
 
   function purgeExpired() {
-    const current = now();
-    for (const [sessionId, session] of sessions) {
-      if (session.expiresAt <= current) sessions.delete(sessionId);
-    }
-    while (sessions.size >= maxSessions) {
-      sessions.delete(sessions.keys().next().value);
+    const current = now();
+    for (const [sessionId, session] of sessions) {
+      if (session.expiresAt <= current
+        || (session.accessExpiresAt > 0 && session.accessExpiresAt <= current)) {
+        dropSession(sessionId, 'hub-ui-session-expired');
+      }
+    }
+    while (sessions.size >= maxSessions) {
+      dropSession(sessions.keys().next().value, 'hub-ui-session-capacity-evicted');
     }
   }
 
-  function issue(userId) {
-    const normalizedUserId = String(userId || '').trim();
-    if (!normalizedUserId) throw new Error('hub-ui-session-user-required');
-    purgeExpired();
-    const sessionId = randomToken();
-    const csrfToken = randomToken();
-    const expiresAt = now() + ttlMs;
-    sessions.set(sessionId, { userId: normalizedUserId, csrfToken, expiresAt });
-    return { sessionId, csrfToken, expiresAt };
-  }
+  function normalizedSessionAccess(userId, access = {}) {
+    const normalizedUserId = String(userId || '').trim();
+    if (!normalizedUserId) throw new Error('hub-ui-session-user-required');
+    const workspaceId = String(access.workspaceId || '').trim();
+    const workspaceKind = String(access.workspaceKind || 'personal').trim().toLowerCase();
+    const role = String(access.role || 'owner').trim().toLowerCase();
+    const entitlementStatus = String(access.entitlementStatus || 'active').trim().toLowerCase();
+    const membershipRevision = Math.max(0, Number(access.membershipRevision || 0));
+    const accessExpiresAt = Math.max(0, Number(access.accessExpiresAt || 0));
+    if (workspaceId && !['owner', 'operator'].includes(role)) {
+      throw new Error('hub-ui-session-workspace-role-invalid');
+    }
+    return {
+      userId: normalizedUserId,
+      workspaceId,
+      workspaceKind,
+      role,
+      plan: String(access.plan || 'free').trim().toLowerCase(),
+      entitlementStatus,
+      membershipRevision,
+      accessExpiresAt
+    };
+  }
+
+  function issue(userId, access = {}) {
+    const normalized = normalizedSessionAccess(userId, access);
+    purgeExpired();
+    const sessionId = randomToken();
+    const csrfToken = randomToken();
+    const expiresAt = now() + ttlMs;
+    sessions.set(sessionId, {
+      ...normalized,
+      csrfToken,
+      expiresAt
+    });
+    return { sessionId, csrfToken, expiresAt };
+  }
+
+  function renew(req, userId, access = {}) {
+    purgeExpired();
+    const sessionId = parseCookies(req?.headers?.cookie).get(HUB_UI_SESSION_COOKIE) || '';
+    const session = sessions.get(sessionId);
+    const normalized = normalizedSessionAccess(userId, access);
+    if (!session
+      || session.userId !== normalized.userId
+      || session.workspaceId !== normalized.workspaceId
+      || session.role !== normalized.role) {
+      return issue(userId, access);
+    }
+    const expiresAt = now() + ttlMs;
+    sessions.set(sessionId, {
+      ...session,
+      ...normalized,
+      expiresAt
+    });
+    return { sessionId, csrfToken: session.csrfToken, expiresAt, renewed: true };
+  }
 
   function authorize(req, currentUserId, {
     requireCsrf = !SAFE_HTTP_METHODS.has(String(req.method || 'GET').toUpperCase())
@@ -74,23 +138,82 @@ export function createHubUiSessionAuthority({
     if (!session) {
       return { ok: false, status: 401, error: 'hub-ui-session-expired' };
     }
-    const normalizedUserId = String(currentUserId || '').trim();
-    if (!normalizedUserId || session.userId !== normalizedUserId) {
-      sessions.delete(sessionId);
-      return { ok: false, status: 403, error: 'hub-ui-session-account-mismatch' };
+    const expected = currentUserId && typeof currentUserId === 'object'
+      ? currentUserId
+      : { userId: currentUserId };
+    const normalizedUserId = String(expected.userId || '').trim();
+    const expectedWorkspaceId = String(expected.workspaceId || '').trim();
+    const allowedRoles = new Set(Array.isArray(expected.allowedRoles)
+      ? expected.allowedRoles.map(role => String(role || '').trim().toLowerCase())
+      : ['owner', 'operator']);
+    const identityMismatch = expectedWorkspaceId
+      ? session.workspaceId !== expectedWorkspaceId || !allowedRoles.has(session.role)
+      : !normalizedUserId || session.userId !== normalizedUserId;
+    if (identityMismatch || (session.accessExpiresAt > 0 && session.accessExpiresAt <= now())) {
+      dropSession(sessionId, 'hub-ui-session-account-mismatch');
+      return { ok: false, status: 403, error: 'hub-ui-session-account-mismatch' };
     }
     if (requireCsrf && !secureEqual(req.headers?.['x-livedesk-csrf'], session.csrfToken)) {
       return { ok: false, status: 403, error: 'hub-ui-csrf-invalid' };
     }
-    return { ok: true, sessionId, userId: session.userId, expiresAt: session.expiresAt };
+    return {
+      ok: true,
+      sessionId,
+      userId: session.userId,
+      workspaceId: session.workspaceId,
+      workspaceKind: session.workspaceKind,
+      role: session.role,
+      plan: session.plan,
+      entitlementStatus: session.entitlementStatus,
+      membershipRevision: session.membershipRevision,
+      accessExpiresAt: session.accessExpiresAt,
+      expiresAt: session.expiresAt
+    };
   }
 
   return {
-    issue,
-    authorize,
-    revokeAll() {
-      sessions.clear();
-    },
+    issue,
+    renew,
+    authorize,
+    sessionDeadline(sessionId) {
+      purgeExpired();
+      const session = sessions.get(String(sessionId || ''));
+      if (!session) return 0;
+      return session.accessExpiresAt > 0
+        ? Math.min(session.expiresAt, session.accessExpiresAt)
+        : session.expiresAt;
+    },
+    revokeAll(reason = 'hub-ui-session-revoked-all') {
+      let revoked = 0;
+      for (const sessionId of [...sessions.keys()]) {
+        if (dropSession(sessionId, reason)) revoked += 1;
+      }
+      return revoked;
+    },
+    revokeWorkspaceMember(workspaceId, userId) {
+      const normalizedWorkspaceId = String(workspaceId || '').trim();
+      const normalizedUserId = String(userId || '').trim();
+      let revoked = 0;
+      for (const [sessionId, session] of sessions) {
+        if (session.workspaceId !== normalizedWorkspaceId || session.userId !== normalizedUserId) continue;
+        if (dropSession(sessionId, 'workspace-member-revoked')) revoked += 1;
+      }
+      return revoked;
+    },
+    revoke(req) {
+      const sessionId = parseCookies(req?.headers?.cookie).get(HUB_UI_SESSION_COOKIE) || '';
+      if (!sessionId) return null;
+      const session = dropSession(sessionId, 'hub-ui-session-signed-out');
+      return session ? {
+        sessionId,
+        userId: session.userId,
+        workspaceId: session.workspaceId,
+        workspaceKind: session.workspaceKind,
+        role: session.role,
+        plan: session.plan,
+        entitlementStatus: session.entitlementStatus
+      } : null;
+    },
     sessionCount: () => sessions.size
   };
 }

package/src/live-stream-monitor-contract.js

@@ -10,7 +10,7 @@ export function parseExactLiveStreamMonitorIndex(value) {
         : null;
 }
 
-export function isReusedLiveStreamFrameReady(result, activeStream, expectedBinding) {
+export function isReusedLiveStreamFrameReady(result, activeStream, expectedBinding) {
     const expectedMonitorIndex = parseExactLiveStreamMonitorIndex(expectedBinding?.monitorIndex);
     const activeMonitorIndex = parseExactLiveStreamMonitorIndex(activeStream?.monitorIndex);
     const latestFrame = activeStream?.latestFrame;
@@ -34,5 +34,197 @@ export function isReusedLiveStreamFrameReady(result, activeStream, expectedBindi
         && Number(latestFrame?.captureGeneration || 0) === expectedCaptureGeneration
         && expectedMonitorIndex !== null
         && activeMonitorIndex === expectedMonitorIndex
-        && frameMonitorIndex === expectedMonitorIndex;
-}
+        && frameMonitorIndex === expectedMonitorIndex;
+}
+
+export const READ_ONLY_CONTROL_PRESENTATION_MAX_IDLE_MS = 3_000;
+export const READ_ONLY_CONTROL_STOP_RECONCILE_GRACE_MS = 250;
+
+function normalizedPurpose(value) {
+    return String(value || '').trim().toLowerCase();
+}
+
+function positiveInteger(value) {
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : 0;
+}
+
+/**
+ * Own exactly one short stop-reconcile timer per device. A replacement Control
+ * transition cancels that timer before a PWA Wall can claim the released
+ * native capture; its Ready event then rebinds observers immediately.
+ */
+export function createReadOnlyControlPresentationReconcileCoordinator({
+    onReconcile,
+    graceMs = READ_ONLY_CONTROL_STOP_RECONCILE_GRACE_MS,
+    setTimeoutFn = setTimeout,
+    clearTimeoutFn = clearTimeout
+} = {}) {
+    if (typeof onReconcile !== 'function') {
+        throw new TypeError('onReconcile must be a function');
+    }
+    if (typeof setTimeoutFn !== 'function' || typeof clearTimeoutFn !== 'function') {
+        throw new TypeError('timer functions must be callable');
+    }
+    const normalizedGraceMs = Number(graceMs);
+    if (!Number.isFinite(normalizedGraceMs)
+        || normalizedGraceMs < 1
+        || normalizedGraceMs > 5_000) {
+        throw new RangeError('graceMs must be between 1 and 5000 milliseconds');
+    }
+
+    const pendingByDeviceId = new Map();
+    let closed = false;
+
+    function normalizeDeviceId(deviceId) {
+        return String(deviceId || '').trim();
+    }
+
+    function cancelForControlTransition(deviceId) {
+        const normalizedDeviceId = normalizeDeviceId(deviceId);
+        const owner = normalizedDeviceId ? pendingByDeviceId.get(normalizedDeviceId) : null;
+        if (!owner) return false;
+        pendingByDeviceId.delete(normalizedDeviceId);
+        clearTimeoutFn(owner.timer);
+        return true;
+    }
+
+    function scheduleAfterConfirmedStop(deviceId) {
+        const normalizedDeviceId = normalizeDeviceId(deviceId);
+        if (closed || !normalizedDeviceId || pendingByDeviceId.has(normalizedDeviceId)) {
+            return false;
+        }
+        const owner = { timer: null };
+        pendingByDeviceId.set(normalizedDeviceId, owner);
+        try {
+            owner.timer = setTimeoutFn(() => {
+                if (closed || pendingByDeviceId.get(normalizedDeviceId) !== owner) {
+                    return;
+                }
+                pendingByDeviceId.delete(normalizedDeviceId);
+                onReconcile(normalizedDeviceId);
+            }, normalizedGraceMs);
+            owner.timer?.unref?.();
+        } catch (error) {
+            if (pendingByDeviceId.get(normalizedDeviceId) === owner) {
+                pendingByDeviceId.delete(normalizedDeviceId);
+            }
+            throw error;
+        }
+        return true;
+    }
+
+    function reconcileReadyControl(deviceId) {
+        const normalizedDeviceId = normalizeDeviceId(deviceId);
+        if (closed || !normalizedDeviceId) return false;
+        cancelForControlTransition(normalizedDeviceId);
+        onReconcile(normalizedDeviceId);
+        return true;
+    }
+
+    function close() {
+        if (closed) return;
+        closed = true;
+        for (const owner of pendingByDeviceId.values()) {
+            clearTimeoutFn(owner.timer);
+        }
+        pendingByDeviceId.clear();
+    }
+
+    return {
+        scheduleAfterConfirmedStop,
+        cancelForControlTransition,
+        reconcileReadyControl,
+        close,
+        getPendingCount: () => pendingByDeviceId.size
+    };
+}
+
+/**
+ * Bind a Wall presentation observer to an already healthy Control encoder.
+ * This returns metadata only: it never starts, stops, or replaces native work.
+ */
+export function resolveReadOnlyControlPresentationBorrow({
+    device,
+    liveOptions,
+    monitorIndex,
+    nowEpochMs = Date.now()
+} = {}) {
+    if (liveOptions?.allowReadOnlyControlBorrow !== true
+        || normalizedPurpose(liveOptions?.streamPurpose) !== 'wall') {
+        return null;
+    }
+
+    const active = device?.activeLiveStream;
+    const latest = active?.latestFrame;
+    const sessionId = String(device?.sessionId || '').trim();
+    const streamId = String(active?.streamId || '').trim();
+    const commandId = String(active?.commandId || '').trim();
+    const captureGeneration = positiveInteger(active?.captureGeneration);
+    const activeMonitorIndex = parseExactLiveStreamMonitorIndex(active?.monitorIndex);
+    const requestedMonitorIndex = parseExactLiveStreamMonitorIndex(monitorIndex);
+    const frameMode = String(active?.frameMode || active?.mode || '').trim().toLowerCase();
+    const requestedFrameMode = String(liveOptions?.frameMode || liveOptions?.mode || '').trim().toLowerCase();
+    const lastFrameAtEpochMs = Date.parse(String(active?.lastFrameAt || ''));
+    const currentEpochMs = Number(nowEpochMs);
+    const frameIdleMs = Number.isFinite(lastFrameAtEpochMs) && Number.isFinite(currentEpochMs)
+        ? Math.max(0, currentEpochMs - lastFrameAtEpochMs)
+        : Number.POSITIVE_INFINITY;
+    const latestMonitorIndex = parseExactLiveStreamMonitorIndex(latest?.monitorIndex);
+
+    if (active?.active !== true
+        || active?.open !== true
+        || active?.stopPending === true
+        || !!String(active?.stopCommandId || '').trim()
+        || !!String(active?.pendingDescriptor?.commandId || '').trim()
+        || normalizedPurpose(active?.streamPurpose) !== 'control'
+        || frameMode !== 'mode3-h264-hw'
+        || requestedFrameMode !== 'mode3-h264-hw'
+        || !sessionId
+        || !streamId
+        || !commandId
+        || captureGeneration <= 0
+        || requestedMonitorIndex === null
+        || activeMonitorIndex !== requestedMonitorIndex
+        || active?.readyFrameReceived !== true
+        || Number(active?.framesReceived || 0) <= 0
+        || frameIdleMs > READ_ONLY_CONTROL_PRESENTATION_MAX_IDLE_MS
+        || latest?.currentGenerationVerified !== true
+        || String(latest?.sessionId || '') !== sessionId
+        || String(latest?.streamId || '') !== streamId
+        || String(latest?.commandId || '') !== commandId
+        || Number(latest?.captureGeneration || 0) !== captureGeneration
+        || latestMonitorIndex !== activeMonitorIndex
+        || normalizedPurpose(latest?.streamPurpose) !== 'control') {
+        return null;
+    }
+
+    return {
+        ok: true,
+        commandId,
+        sessionId,
+        streamId,
+        streamPurpose: 'control',
+        fps: positiveInteger(active?.fps) || 1,
+        mode: String(active?.mode || active?.frameMode || 'mode3-h264-hw'),
+        frameMode: 'mode3-h264-hw',
+        monitorIndex: activeMonitorIndex,
+        captureGeneration,
+        ready: true,
+        reused: true,
+        readOnlyControlBorrow: true,
+        presentationPurpose: 'wall',
+        requestedProfile: {
+            fps: Number(liveOptions?.fps || 0),
+            maxWidth: Number(liveOptions?.maxWidth || 0),
+            maxHeight: Number(liveOptions?.maxHeight || 0),
+            quality: Number(liveOptions?.quality || 0)
+        },
+        effectiveProfile: {
+            fps: Number(active?.fps || 0),
+            maxWidth: Number(active?.maxWidth || 0),
+            maxHeight: Number(active?.maxHeight || 0),
+            quality: Number(active?.quality || 0)
+        }
+    };
+}