@livedesk/hub 0.1.39 → 0.1.41

package/package.json

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

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

@@ -0,0 +1,119 @@
+import crypto from 'node:crypto';
+
+export const HUB_UI_SESSION_COOKIE = 'livedesk_hub_ui';
+export const HUB_UI_SESSION_TTL_MS = 12 * 60 * 60 * 1000;
+
+const SAFE_HTTP_METHODS = new Set(['GET', 'HEAD', 'OPTIONS']);
+
+function secureEqual(left, right) {
+  const leftBuffer = Buffer.from(String(left || ''), 'utf8');
+  const rightBuffer = Buffer.from(String(right || ''), 'utf8');
+  return leftBuffer.length === rightBuffer.length
+    && leftBuffer.length > 0
+    && crypto.timingSafeEqual(leftBuffer, rightBuffer);
+}
+
+function parseCookies(value) {
+  const result = new Map();
+  for (const part of String(value || '').split(';')) {
+    const separator = part.indexOf('=');
+    if (separator <= 0) continue;
+    const key = part.slice(0, separator).trim();
+    const rawValue = part.slice(separator + 1).trim();
+    if (!key) continue;
+    try {
+      result.set(key, decodeURIComponent(rawValue));
+    } catch {
+      result.set(key, rawValue);
+    }
+  }
+  return result;
+}
+
+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();
+
+  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);
+    }
+  }
+
+  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 authorize(req, currentUserId, {
+    requireCsrf = !SAFE_HTTP_METHODS.has(String(req.method || 'GET').toUpperCase())
+  } = {}) {
+    purgeExpired();
+    const sessionId = parseCookies(req.headers?.cookie).get(HUB_UI_SESSION_COOKIE) || '';
+    if (!sessionId) {
+      return { ok: false, status: 401, error: 'hub-ui-session-required' };
+    }
+    const session = sessions.get(sessionId);
+    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' };
+    }
+    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 {
+    issue,
+    authorize,
+    revokeAll() {
+      sessions.clear();
+    },
+    sessionCount: () => sessions.size
+  };
+}
+
+export function serializeHubUiSessionCookie(sessionId, expiresAt, { secure = false } = {}) {
+  const maxAgeSeconds = Math.max(1, Math.floor((Number(expiresAt || 0) - Date.now()) / 1000));
+  return [
+    `${HUB_UI_SESSION_COOKIE}=${encodeURIComponent(String(sessionId || ''))}`,
+    'Path=/',
+    'HttpOnly',
+    'SameSite=Strict',
+    `Max-Age=${maxAgeSeconds}`,
+    secure ? 'Secure' : ''
+  ].filter(Boolean).join('; ');
+}
+
+export function clearHubUiSessionCookie({ secure = false } = {}) {
+  return [
+    `${HUB_UI_SESSION_COOKIE}=`,
+    'Path=/',
+    'HttpOnly',
+    'SameSite=Strict',
+    'Max-Age=0',
+    secure ? 'Secure' : ''
+  ].filter(Boolean).join('; ');
+}

package/src/remote-hub.js

@@ -9705,10 +9705,39 @@ export function createRemoteHub(options = {}) {
                 liveStreamReplacementStillPending(activeLiveStream)
                     ? 'stream-restart-superseded'
                     : 'stream-start-timeout');
-        }
-        const commandId = safeString(options.commandId, 128) || crypto.randomUUID();
-        if (activeLiveStream
-            && options.forceRestart !== true
+        }
+        const commandId = safeString(options.commandId, 128) || crypto.randomUUID();
+        const restartToken = safeString(options.restartToken, 128);
+        if (activeLiveStream
+            && options.forceRestart === true
+            && restartToken
+            && safeString(activeLiveStream.restartToken, 128) === restartToken
+            && liveStreamMatchesOptions(activeLiveStream, normalized)
+            && liveStreamIsReusable(activeLiveStream)) {
+            emitRemoteEvent('RemoteLiveStreamRestartTokenReused', device, {
+                streamId,
+                commandId: activeLiveStream.commandId,
+                restartToken,
+                captureGeneration: Number(activeLiveStream.captureGeneration || 0)
+            });
+            return {
+                ok: true,
+                commandId: activeLiveStream.commandId,
+                sessionId: device.sessionId,
+                streamId,
+                streamPurpose,
+                fps: Number(activeLiveStream.fps || fps),
+                mode: activeLiveStream.mode || transfer.mode,
+                frameMode: activeLiveStream.frameMode || transfer.frameMode,
+                monitorIndex: Number(activeLiveStream.monitorIndex ?? monitorIndex),
+                captureGeneration: Number(activeLiveStream.captureGeneration || 0),
+                ready: liveStreamHasCurrentFrame(activeLiveStream),
+                pending: activeLiveStream.open !== true,
+                reused: true
+            };
+        }
+        if (activeLiveStream
+            && options.forceRestart !== true
             && options.reuseExisting === true
             && liveStreamMatchesOptions(activeLiveStream, normalized)
             && liveStreamIsReusable(activeLiveStream)) {
@@ -9838,7 +9867,7 @@ export function createRemoteHub(options = {}) {
             monitorIndex,
             monitorCount: 1,
             startedAt: now,
-            restartToken: safeString(options.restartToken, 128),
+            restartToken,
             stoppedAt: '',
             stopReason: '',
             stopPending: false,

package/src/server.js

@@ -51,8 +51,13 @@ import { normalizeRuntimeAuthSession, runtimeRoleError } from '../../runtime-cor
 import { fetchAuthResponse, AUTH_REQUEST_TIMEOUT_MS } from '../../runtime-core/src/auth-http.js';
 import { PRODUCTION_SUPABASE_PUBLISHABLE_KEY, PRODUCTION_SUPABASE_URL } from '../../runtime-core/src/auth-config.js';
 import { createHubRuntime } from './runtime/hub-runtime.js';
-import { hubRuntimeStatus } from './runtime/hub-runtime-status.js';
-import { roleGuardResponse } from './http/hub-role-guard.js';
+import { hubRuntimeStatus } from './runtime/hub-runtime-status.js';
+import { roleGuardResponse } from './http/hub-role-guard.js';
+import {
+  clearHubUiSessionCookie,
+  createHubUiSessionAuthority,
+  serializeHubUiSessionCookie
+} from './http/hub-ui-session.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const webDistCandidates = [
@@ -182,9 +187,10 @@ const persistentSessionGcToken = persistentSessionGcEnabled
   ? String(process.env.LIVEDESK_PERSISTENT_SESSION_TEST_TOKEN || '').trim()
   : '';
 let connectedDeviceCount = 0;
-let runtimeAccessToken = '';
-let runtimeRefreshToken = '';
-let runtimeAccessTokenExpiresAt = 0;
+let runtimeAccessToken = '';
+let runtimeRefreshToken = '';
+let runtimeAccessTokenExpiresAt = 0;
+const hubUiSessionAuthority = createHubUiSessionAuthority();
 let roleWatchInFlight = false;
 let verifiedLicense = {
   userId: '',
@@ -485,11 +491,12 @@ function clearPersistedRuntimeSession() {
   return writePrivateRuntimeAuthState(state);
 }
 
-function clearRuntimeSession() {
-  runtimeAccessToken = '';
-  runtimeRefreshToken = '';
-  runtimeAccessTokenExpiresAt = 0;
-  runtimeManager.setAuthenticated(false);
+function clearRuntimeSession() {
+  runtimeAccessToken = '';
+  runtimeRefreshToken = '';
+  runtimeAccessTokenExpiresAt = 0;
+  hubUiSessionAuthority.revokeAll();
+  runtimeManager.setAuthenticated(false);
   try { clearPersistedRuntimeSession(); } catch { /* runtime auth is already invalid */ }
 }
 
@@ -1405,7 +1412,7 @@ function requestHostname(req) {
   }
 }
 
-function isTrustedBrowserRequest(req) {
+function isTrustedBrowserRequest(req) {
   const origin = String(req.headers.origin || '').trim();
   if (!origin) {
     const fetchSite = String(req.headers['sec-fetch-site'] || '').toLowerCase();
@@ -1422,22 +1429,59 @@ function isTrustedBrowserRequest(req) {
     const targetHost = requestHostname(req);
     return (originHost === targetHost && isPrivateHubHostname(targetHost))
       || (isLoopbackHostname(originHost) && isLoopbackHostname(targetHost));
-  } catch {
-    return false;
-  }
-}
-
-app.use((req, res, next) => {
+  } catch {
+    return false;
+  }
+}
+
+function isSecureHubHttpRequest(req) {
+  return req.socket?.encrypted === true
+    || String(req.headers['x-forwarded-proto'] || '').trim().toLowerCase() === 'https';
+}
+
+function currentBoundHubUserId() {
+  return String(
+    runtimeManager.getSnapshot().userId
+    || readPersistedRuntimeSession()?.user?.id
+    || ''
+  ).trim();
+}
+
+function isPublicHubApiRequest(req) {
+  const method = String(req.method || 'GET').toUpperCase();
+  const path = String(req.path || '');
+  return (method === 'GET' && (path === '/api/health' || path === '/api/runtime/status' || path === '/api/auth/status'))
+    || (method === 'POST' && path === '/api/auth/session');
+}
+
+function isTrustedNativeLoopbackRequest(req) {
+  return isLoopbackAddress(req.socket?.remoteAddress)
+    && !String(req.headers.origin || '').trim()
+    && !String(req.headers['sec-fetch-site'] || '').trim();
+}
+
+function authorizeHubUiRequest(req) {
+  if (process.env.LIVEDESK_TEST_MODE === '1') {
+    return { ok: true, explicitTestMode: true };
+  }
+  if (isTrustedNativeLoopbackRequest(req)) {
+    return { ok: true, nativeLoopback: true };
+  }
+  return hubUiSessionAuthority.authorize(req, currentBoundHubUserId());
+}
+
+app.use((req, res, next) => {
   if (!isTrustedBrowserRequest(req)) {
     res.status(403).json({ ok: false, error: 'untrusted-hub-origin' });
     return;
   }
   const origin = String(req.headers.origin || '').trim();
   if (origin) {
-    res.setHeader('Access-Control-Allow-Origin', origin);
-    res.setHeader('Access-Control-Allow-Private-Network', 'true');
+    res.setHeader('Access-Control-Allow-Origin', origin);
+    res.setHeader('Access-Control-Allow-Credentials', 'true');
+    res.setHeader('Access-Control-Allow-Private-Network', 'true');
     res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, PATCH, DELETE, OPTIONS');
-    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-LiveDesk-CSRF');
     res.setHeader('Vary', 'Origin, Access-Control-Request-Headers, Access-Control-Request-Private-Network');
   }
   if (req.method === 'OPTIONS') {
@@ -1446,8 +1490,21 @@ app.use((req, res, next) => {
   }
   next();
 });
-app.use(express.json({ limit: '32mb' }));
-app.use((req, res, next) => {
+app.use(express.json({ limit: '32mb' }));
+app.use((req, res, next) => {
+  if (!req.path.startsWith('/api/') || isPublicHubApiRequest(req)) {
+    next();
+    return;
+  }
+  const authorization = authorizeHubUiRequest(req);
+  if (!authorization.ok) {
+    noStore(res);
+    res.status(authorization.status).json({ ok: false, error: authorization.error });
+    return;
+  }
+  next();
+});
+app.use((req, res, next) => {
   if (runtimeRole === 'client' && req.path.startsWith('/api/remote')) {
     res.status(403).json(roleGuardResponse(runtimeRole, 'hub'));
     return;
@@ -4351,10 +4408,19 @@ app.post('/api/auth/session', async (req, res) => {
     res.status(400).json({ ok: false, error: normalized.error });
     return;
   }
-  const { access_token: accessToken, refresh_token: refreshToken, expires_at: expiresAt } = normalized.session;
-  try {
-    const user = await verifySupabaseUser(accessToken);
-    runtimeAccessToken = accessToken;
+  const { access_token: accessToken, refresh_token: refreshToken, expires_at: expiresAt } = normalized.session;
+  try {
+    const user = await verifySupabaseUser(accessToken);
+    const boundUserId = currentBoundHubUserId();
+    if (boundUserId && boundUserId !== user.id) {
+      res.status(403).json({ ok: false, error: 'hub-account-mismatch' });
+      return;
+    }
+    if (!boundUserId && !isLoopbackAddress(req.socket?.remoteAddress)) {
+      res.status(403).json({ ok: false, error: 'hub-first-account-binding-must-be-local' });
+      return;
+    }
+    runtimeAccessToken = accessToken;
     runtimeRefreshToken = refreshToken;
     runtimeAccessTokenExpiresAt = normalizeSessionExpiryMs(expiresAt);
     runtimeManager.setAuthenticated(true, user.id);
@@ -4364,13 +4430,32 @@ app.post('/api/auth/session', async (req, res) => {
       expires_at: expiresAt,
       user
     });
-    const hostTarget = runtimeRole === 'hub'
-      ? await publishHubHostTargetWithPendingRoleTakeover('session-received')
-      : { ok: true, active: false };
-    if (runtimeRole === 'hub') {
-      startHubHostTargetLeaseRenewal();
-    }
-    res.json({ ok: true, authenticated: true, persisted, userId: user.id, role: runtimeRole, hostTarget });
+    const hostTarget = runtimeRole === 'hub'
+      ? {
+          ok: true,
+          pending: true,
+          active: remoteHub.getStatus({ includeSecrets: false }).hostTargetActive === true
+        }
+      : { ok: true, pending: false, active: false };
+    const uiSession = hubUiSessionAuthority.issue(user.id);
+    res.setHeader('Set-Cookie', serializeHubUiSessionCookie(uiSession.sessionId, uiSession.expiresAt, {
+      secure: isSecureHubHttpRequest(req)
+    }));
+    res.json({
+      ok: true,
+      authenticated: true,
+      persisted,
+      userId: user.id,
+      role: runtimeRole,
+      hostTarget,
+      uiSession: {
+        csrfToken: uiSession.csrfToken,
+        expiresAt: uiSession.expiresAt
+      }
+    });
+    if (runtimeRole === 'hub') {
+      scheduleAuthenticatedHubHostTargetPublication('session-received');
+    }
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     const status = authVerificationHttpStatus(message);
@@ -4656,24 +4741,36 @@ async function clearHubHostTarget(reason = 'shutdown') {
   return { ok: !error, error, lease: getHubHostTargetLeaseStatus() };
 }
 
-function startHubHostTargetLeaseRenewal() {
+function startHubHostTargetLeaseRenewal() {
   if (hubHostTargetRenewTimer || runtimeRole !== 'hub') {
     return;
   }
   hubHostTargetRenewTimer = setInterval(() => {
     void publishHubHostTargetWithPendingRoleTakeover('renewal');
   }, HUB_HOST_TARGET_RENEW_MS);
-  hubHostTargetRenewTimer.unref?.();
-}
+  hubHostTargetRenewTimer.unref?.();
+}
+
+function scheduleAuthenticatedHubHostTargetPublication(reason = 'session-received') {
+  startHubHostTargetLeaseRenewal();
+  setImmediate(() => {
+    void publishHubHostTargetWithPendingRoleTakeover(reason).catch(error => {
+      const message = error instanceof Error ? error.message : String(error);
+      updateHubHostTargetLeaseState({ state: 'error', lastError: message });
+      console.error(`[LiveDesk Hub] Host target ${reason} background publish failed: ${message}`);
+    });
+  });
+}
 
-app.delete('/api/auth/session', async (_req, res) => {
+app.delete('/api/auth/session', async (req, res) => {
   noStore(res);
   const hostTarget = runtimeRole === 'hub'
     ? await clearHubHostTarget('logout')
     : { ok: true, active: false };
-  clearRuntimeSession();
-  res.json({ ok: true, authenticated: false, role: runtimeRole, hostTarget });
-});
+  clearRuntimeSession();
+  res.setHeader('Set-Cookie', clearHubUiSessionCookie({ secure: isSecureHubHttpRequest(req) }));
+  res.json({ ok: true, authenticated: false, role: runtimeRole, hostTarget });
+});
 
 app.get('/api/hub/status', (_req, res) => {
   noStore(res);
@@ -5474,13 +5571,20 @@ if (existsSync(webIndexPath)) {
   });
 }
 
-httpServer.on('upgrade', (req, socket, head) => {
-  if (!isTrustedBrowserRequest(req)) {
-    socket.write('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n');
-    socket.destroy();
-    return;
-  }
-  try {
+httpServer.on('upgrade', (req, socket, head) => {
+  if (!isTrustedBrowserRequest(req)) {
+    socket.write('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n');
+    socket.destroy();
+    return;
+  }
+  const authorization = authorizeHubUiRequest(req);
+  if (!authorization.ok) {
+    const label = authorization.status === 403 ? 'Forbidden' : 'Unauthorized';
+    socket.write(`HTTP/1.1 ${authorization.status} ${label}\r\nConnection: close\r\n\r\n`);
+    socket.destroy();
+    return;
+  }
+  try {
     const parsed = new URL(req.url || '/', `http://${req.headers.host || '127.0.0.1'}`);
     if (parsed.pathname === '/api/remote/frames/ws') {
       frameWss.handleUpgrade(req, socket, head, ws => frameWss.emit('connection', ws, req));