@livedesk/hub 0.1.16 → 0.1.18

package/package.json

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

package/src/agents/agent-manager.js

@@ -94,15 +94,6 @@ export function createAgentManager({
     async deleteApiKey() {
       return publicSettings();
     },
-    async getModels() {
-      return [{
-        id: '',
-        name: 'Codex default',
-        protocol: 'codex-sdk',
-        available: true,
-        capabilities: { supportsReasoningLevel: true, supportsStreaming: true, supportsTools: true }
-      }];
-    },
     async testConnection() {
       if (!runtime) throw new AgentProviderError('codex-sdk-not-installed', 'Codex SDK is not installed.', { status: 503 });
       statusCache = { expiresAt: 0, value: null };

package/src/agents/agent-settings.js

@@ -4,14 +4,11 @@ import path from 'node:path';
 
 export const AGENT_PROVIDER_CODEX = 'codex';
 export const DEFAULT_AGENT_PROVIDER = AGENT_PROVIDER_CODEX;
-export const DEFAULT_CODEX_MODEL_ID = '';
 export const DEFAULT_AGENT_WORKSPACE = path.join(os.homedir(), '.livedesk', 'agent-workspace');
 export const DEFAULT_AGENT_SETTINGS = Object.freeze({
-  settingsVersion: 3,
+  settingsVersion: 4,
   enabled: true,
   provider: DEFAULT_AGENT_PROVIDER,
-  codexModelId: DEFAULT_CODEX_MODEL_ID,
-  codexReasoningEffort: 'medium',
   codexSandboxMode: 'read-only',
   codexApprovalPolicy: 'never',
   codexWorkingDirectory: DEFAULT_AGENT_WORKSPACE,
@@ -25,20 +22,6 @@ export const DEFAULT_AGENT_SETTINGS = Object.freeze({
   maxConcurrentRequests: 2
 });
 
-const REASONING_EFFORTS = new Set(['minimal', 'low', 'medium', 'high', 'xhigh']);
-const SANDBOX_MODES = new Set(['read-only', 'workspace-write', 'danger-full-access']);
-const APPROVAL_POLICIES = new Set(['never', 'on-request', 'on-failure', 'untrusted']);
-const WEB_SEARCH_MODES = new Set(['disabled', 'cached', 'live']);
-
-export class AgentSettingsError extends Error {
-  constructor(code, message) {
-    super(message);
-    this.name = 'AgentSettingsError';
-    this.code = code;
-    this.status = 400;
-  }
-}
-
 function booleanValue(value, fallback) {
   return typeof value === 'boolean' ? value : fallback;
 }
@@ -50,18 +33,7 @@ function numberValue(value, min, max, fallback, integer = false) {
   return integer ? Math.round(clamped) : clamped;
 }
 
-function stringValue(value, fallback, maxLength = 240) {
-  if (typeof value !== 'string') return fallback;
-  return value.trim().slice(0, maxLength);
-}
-
-function enumValue(value, allowed, fallback, code) {
-  const normalized = stringValue(value, fallback, 80).toLowerCase();
-  if (!allowed.has(normalized)) throw new AgentSettingsError(code, `Invalid agent setting: ${normalized}.`);
-  return normalized;
-}
-
-function normalizeWorkingDirectory(value) {
+function normalizeWorkingDirectory() {
   // The agent runtime owns this directory. Do not allow a browser/API caller
   // to move Codex into a user project or an arbitrary filesystem root.
   return DEFAULT_AGENT_WORKSPACE;
@@ -70,18 +42,16 @@ function normalizeWorkingDirectory(value) {
 export function normalizeAgentSettings(value = {}) {
   const source = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
   return {
-    settingsVersion: 3,
+    settingsVersion: 4,
     enabled: booleanValue(source.enabled, DEFAULT_AGENT_SETTINGS.enabled),
     // LiveDesk has one Agent runtime. Old provider values are deliberately
     // normalized to Codex so an upgrade cannot reactivate a retired provider.
     provider: AGENT_PROVIDER_CODEX,
-    codexModelId: stringValue(source.codexModelId, DEFAULT_AGENT_SETTINGS.codexModelId, 160),
-    codexReasoningEffort: enumValue(source.codexReasoningEffort, REASONING_EFFORTS, DEFAULT_AGENT_SETTINGS.codexReasoningEffort, 'agent-invalid-reasoning-effort'),
     // These are safety settings, not user-controlled execution toggles. They
     // are accepted for compatibility but always normalized to the safe floor.
     codexSandboxMode: 'read-only',
     codexApprovalPolicy: 'never',
-    codexWorkingDirectory: normalizeWorkingDirectory(source.codexWorkingDirectory),
+    codexWorkingDirectory: normalizeWorkingDirectory(),
     codexTaskTimeoutMs: numberValue(source.codexTaskTimeoutMs, 30000, 1800000, DEFAULT_AGENT_SETTINGS.codexTaskTimeoutMs, true),
     codexMaxTurns: numberValue(source.codexMaxTurns, 1, 40, DEFAULT_AGENT_SETTINGS.codexMaxTurns, true),
     codexMaxToolCalls: numberValue(source.codexMaxToolCalls, 1, 100, DEFAULT_AGENT_SETTINGS.codexMaxToolCalls, true),

package/src/agents/codex-agent-runtime.js

@@ -66,15 +66,13 @@ function normalizeCodexError(error) {
   return new AgentProviderError('codex-run-failed', message, { status: 502, retryable: true });
 }
 
-function codexThreadOptions(settings, workspace) {
-  return {
-    model: settings.codexModelId || undefined,
-    sandboxMode: 'read-only',
-    approvalPolicy: 'never',
-    workingDirectory: workspace,
-    skipGitRepoCheck: true,
-    modelReasoningEffort: settings.codexReasoningEffort,
-    networkAccessEnabled: false,
+function codexThreadOptions(workspace) {
+  return {
+    sandboxMode: 'read-only',
+    approvalPolicy: 'never',
+    workingDirectory: workspace,
+    skipGitRepoCheck: true,
+    networkAccessEnabled: false,
     webSearchMode: 'disabled',
     webSearchEnabled: false,
     additionalDirectories: []
@@ -417,10 +415,10 @@ export function createCodexAgentRuntime({
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), Math.min(30000, settings.codexTaskTimeoutMs));
     try {
-      const thread = codex.startThread(codexThreadOptions(settings, workspace));
-      const turn = await thread.run('Reply with the single word READY. Do not use tools.', { signal: controller.signal });
-      if (!String(turn.finalResponse || '').trim()) throw new AgentProviderError('codex-empty-response', 'Codex returned an empty response.', { status: 502 });
-      return { ok: true, modelId: settings.codexModelId || 'Codex default', modelName: settings.codexModelId || 'Codex default', latencyMs: Date.now() - startedAt, threadId: thread.id || '' };
+      const thread = codex.startThread(codexThreadOptions(workspace));
+      const turn = await thread.run('Reply with the single word READY. Do not use tools.', { signal: controller.signal });
+      if (!String(turn.finalResponse || '').trim()) throw new AgentProviderError('codex-empty-response', 'Codex returned an empty response.', { status: 502 });
+      return { ok: true, latencyMs: Date.now() - startedAt, threadId: thread.id || '' };
     } catch (error) {
       throw normalizeCodexError(error);
     } finally {
@@ -531,7 +529,7 @@ export function createCodexAgentRuntime({
         if (run.abortReason === 'timeout') throw codexAbortError('codex-run-timeout', 'The Codex task exceeded its timeout.');
         throw Object.assign(new Error('The Codex task was cancelled.'), { name: 'AbortError' });
       }
-      const threadOptions = codexThreadOptions(settings, workspace);
+      const threadOptions = codexThreadOptions(workspace);
       run.status = 'running';
       run.updatedAt = new Date().toISOString();
       for (let attempt = 0; attempt < 2; attempt += 1) {

package/src/remote-hub.js

@@ -4232,9 +4232,11 @@ export function createRemoteHub(options = {}) {
         const captureTimingAvailable = hasFrameCaptureTiming(message);
         const videoTransport = transport === 'udp-p2p'
             ? 'p2p-udp'
-            : transport === 'ws-binary'
-                ? 'direct-ws'
-                : 'direct-tcp';
+            : transport === 'relay-binary'
+                ? 'encrypted-relay'
+                : transport === 'ws-binary'
+                    ? 'direct-ws'
+                    : 'direct-tcp';
         device.latestLiveFrame = {
             streamId,
             frameSeq,
@@ -4322,9 +4324,16 @@ export function createRemoteHub(options = {}) {
             deltaRefreshTileCount: Number.isFinite(Number(message.deltaRefreshTileCount)) ? Number(message.deltaRefreshTileCount) : 0,
             deltaTotalTiles: Number.isFinite(Number(message.deltaTotalTiles)) ? Number(message.deltaTotalTiles) : 0,
             videoTransport,
-            frameTransportActive: safeString(message.frameTransportActive, 20) || (videoTransport === 'p2p-udp' ? 'p2p' : 'direct'),
+            frameTransportActive: safeString(message.frameTransportActive, 20)
+                || (videoTransport === 'p2p-udp' ? 'p2p' : videoTransport === 'encrypted-relay' ? 'relay' : 'direct'),
             frameTransportProtocol: safeString(message.frameTransportProtocol, 20)
-                || (videoTransport === 'p2p-udp' ? 'udp' : videoTransport === 'direct-ws' ? 'ws' : 'tcp'),
+                || (videoTransport === 'p2p-udp'
+                    ? 'udp'
+                    : videoTransport === 'encrypted-relay'
+                        ? 'relay'
+                        : videoTransport === 'direct-ws'
+                            ? 'ws'
+                            : 'tcp'),
             frameTransportState: safeString(message.frameTransportState, 20) || 'active',
             frameTransportP2pReady: message.frameTransportP2pReady === true,
             frameTransportReason: safeString(message.frameTransportReason, 240),
@@ -4518,7 +4527,11 @@ export function createRemoteHub(options = {}) {
         }
 
         const frameKind = safeString(header.frameKind || header.kind || header.frameType || '', 40).toLowerCase();
-        const binaryTransport = state.binaryTransport === 'ws-binary' ? 'ws-binary' : 'binary';
+        const binaryTransport = socket.__liveDeskRelayControl === true
+            ? 'relay-binary'
+            : state.binaryTransport === 'ws-binary'
+                ? 'ws-binary'
+                : 'binary';
         if (frameKind === 'thumbnail' || header.type === 'thumbnail.binary') {
             applyThumbnailFrame(device, header, framePayload, binaryTransport);
             return;

package/src/server.js

@@ -2127,9 +2127,11 @@ function buildRemoteFrameBinaryPacket(frameEvent, diagnostics = {}) {
     transport: frame.transport || '',
     videoTransport: frame.videoTransport || (frame.transport === 'udp-p2p'
       ? 'p2p-udp'
-      : frame.transport === 'ws-binary'
-        ? 'direct-ws'
-        : 'direct-tcp'),
+      : frame.transport === 'relay-binary'
+        ? 'encrypted-relay'
+        : frame.transport === 'ws-binary'
+          ? 'direct-ws'
+          : 'direct-tcp'),
     frameTransportActive: frame.frameTransportActive || '',
     frameTransportProtocol: frame.frameTransportProtocol || '',
     frameTransportState: frame.frameTransportState || '',
@@ -2955,14 +2957,14 @@ app.delete('/api/settings/agent/api-key', async (_req, res) => {
   }
 });
 
-app.get('/api/settings/agent/models', async (_req, res) => {
-  noStore(res);
-  try {
-    res.json({ ok: true, models: await agentManager.getModels() });
-  } catch (error) {
-    sendAgentError(res, error);
-  }
-});
+app.get('/api/settings/agent/models', async (_req, res) => {
+  noStore(res);
+  res.status(410).json({
+    ok: false,
+    error: 'agent-model-catalog-retired',
+    message: 'LiveDesk uses the Codex SDK defaults and does not manage models.'
+  });
+});
 
 app.post('/api/settings/agent/test', async (_req, res) => {
   noStore(res);

package/src/transport/udp-hub-transport.js

@@ -2,10 +2,10 @@ import crypto from 'node:crypto';
 import { lookup } from 'node:dns/promises';
 import dgram from 'node:dgram';
 import {
-    UDP_MAX_DATAGRAM_BYTES,
-    UDP_P2P_PROTOCOL,
-    UdpFrameReassembler,
-    UdpReplayWindow,
+    UDP_MAX_DATAGRAM_BYTES,
+    UDP_P2P_PROTOCOL,
+    UdpFrameReassembler,
+    UdpReplayWindow,
     decodeRendezvousMessage,
     decodeUdpPacket,
     encodeRendezvousMessage,
@@ -52,7 +52,7 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
     const socket = dgram.createSocket('udp4');
     const sessions = new Map();
     let frameHandler = () => {};
-    let eventHandler = () => {};
+    let eventHandler = () => {};
     let started = false;
     let boundPort = requestedPort;
     let sequence = crypto.randomInt(1, 0x7fffffff);
@@ -65,20 +65,20 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
         if (trace) logEvent('udp', `${type} ${JSON.stringify({ deviceId: event.deviceId || '', state: event.state || '', reason: event.reason || '' })}`);
     }
 
-    function nextSequence() {
-        sequence = (sequence + 1) >>> 0;
-        return sequence;
-    }
-
+    function nextSequence() {
+        sequence = (sequence + 1) >>> 0;
+        return sequence;
+    }
+
     function sendPacket(session, type, header = {}, payload = Buffer.alloc(0), address = session.clientEndpoint || session.peerEndpoint) {
         if (!address || !session) return false;
-        let packet;
-        try {
-            packet = encodeUdpPacket({ type, sessionId: session.sessionId, key: session.key, sequence: nextSequence(), header, payload });
-        } catch (error) {
-            logWarn('udp', `UDP packet rejected device=${session.deviceId}: ${error?.message || error}`);
-            return false;
-        }
+        let packet;
+        try {
+            packet = encodeUdpPacket({ type, sessionId: session.sessionId, key: session.key, sequence: nextSequence(), header, payload });
+        } catch (error) {
+            logWarn('udp', `UDP packet rejected device=${session.deviceId}: ${error?.message || error}`);
+            return false;
+        }
         socket.send(packet, address.port, address.address);
         return true;
     }
@@ -288,9 +288,9 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
             keyBase64: key.toString('base64'),
             rendezvousToken: crypto.randomBytes(16).toString('hex'),
             sendControl,
-            clientEndpoint: null,
-            peerEndpoint: null,
-            replay: new UdpReplayWindow(),
+            clientEndpoint: null,
+            peerEndpoint: null,
+            replay: new UdpReplayWindow(),
             reassembler: new UdpFrameReassembler({ maxPending: maxPendingFrames, timeoutMs: frameTimeoutMs }),
             ready: false,
             createdAt: Date.now(),
@@ -333,8 +333,8 @@ export function createHubUdpTransport({ env = process.env, logEvent = () => {},
         return {
             enabled,
             preferred: preferP2p,
-            state: session.ready ? 'udp-ready' : 'udp-session-created',
-            ready: session.ready,
+            state: session.ready ? 'udp-ready' : 'udp-session-created',
+            ready: session.ready,
             sessionId: session.sessionId,
             lastPacketAt: session.lastPacketAt ? new Date(session.lastPacketAt).toISOString() : '',
             framesReceived: session.framesReceived,

package/src/transport/udp-protocol.js

@@ -2,9 +2,11 @@ import crypto from 'node:crypto';
 import { inflateRawSync } from 'node:zlib';
 
 export const UDP_P2P_PROTOCOL = 'livedesk.udp.p2p.v1';
-export const UDP_P2P_VERSION = 1;
-export const UDP_MAX_DATAGRAM_BYTES = 1200;
-export const UDP_PACKET_TYPES = Object.freeze({
+export const UDP_P2P_VERSION = 1;
+export const UDP_MAX_DATAGRAM_BYTES = 1200;
+const UDP_SERIAL_MODULUS = 0x1_0000_0000;
+const UDP_SERIAL_HALF_RANGE = 0x8000_0000;
+export const UDP_PACKET_TYPES = Object.freeze({
     probe: 1,
     'probe-ack': 2,
     ready: 3,
@@ -83,13 +85,21 @@ function decodeFramedPayload(payload, legacyHeader = null) {
     }
 }
 
-function packetTypeCode(type) {
+function packetTypeCode(type) {
     const code = typeof type === 'number' ? type : UDP_PACKET_TYPES[String(type || '').toLowerCase()];
     if (!code || !UDP_PACKET_TYPE_NAMES.has(code)) throw new Error('invalid-udp-packet-type');
     return code;
-}
-
-function encodeHeader(header) {
+}
+
+function normalizeSequence(value) {
+    const sequence = Number(value);
+    if (!Number.isInteger(sequence) || sequence < 0 || sequence >= UDP_SERIAL_MODULUS) {
+        throw new Error('invalid-udp-packet-sequence');
+    }
+    return sequence;
+}
+
+function encodeHeader(header) {
     const bytes = Buffer.from(JSON.stringify(header && typeof header === 'object' ? header : {}), 'utf8');
     if (bytes.length > UDP_MAX_HEADER_BYTES) throw new Error('udp-packet-header-too-large');
     return bytes;
@@ -103,9 +113,9 @@ export function createUdpSessionKey() {
     return crypto.randomBytes(32);
 }
 
-export function encodeUdpPacket({ type, sessionId, key, sequence = 0, header = {}, payload = Buffer.alloc(0) }) {
-    const normalizedSessionId = normalizeSessionId(sessionId);
-    const sessionBytes = Buffer.from(normalizedSessionId, 'utf8');
+export function encodeUdpPacket({ type, sessionId, key, sequence = 0, header = {}, payload = Buffer.alloc(0) }) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    const sessionBytes = Buffer.from(normalizedSessionId, 'utf8');
     const headerBytes = encodeHeader(header);
     const payloadBytes = asBuffer(payload);
     if (payloadBytes.length > UDP_MAX_PAYLOAD_BYTES) throw new Error('udp-packet-payload-too-large');
@@ -117,8 +127,8 @@ export function encodeUdpPacket({ type, sessionId, key, sequence = 0, header = {
     preamble[6] = sessionBytes.length;
     preamble.writeUInt16BE(headerBytes.length, 7);
     preamble.writeUInt16BE(payloadBytes.length, 9);
-    preamble.writeUInt32BE((Number(sequence) >>> 0), 11);
-    const nonce = crypto.randomBytes(UDP_NONCE_BYTES);
+    preamble.writeUInt32BE((Number(sequence) >>> 0), 11);
+    const nonce = crypto.randomBytes(UDP_NONCE_BYTES);
     const associatedData = Buffer.concat([preamble, nonce, sessionBytes, headerBytes]);
     const cipher = crypto.createCipheriv('aes-256-gcm', normalizeKey(key), nonce);
     cipher.setAAD(associatedData);
@@ -169,26 +179,41 @@ export function decodeUdpPacket(packet, key) {
     }
 }
 
-export class UdpReplayWindow {
+export class UdpReplayWindow {
     constructor(size = 512) {
         this.size = Math.max(32, Math.min(4096, Math.floor(Number(size) || 512)));
         this.highest = -1;
         this.seen = new Set();
     }
 
-    accept(sequence) {
-        const value = Number(sequence) >>> 0;
-        if (this.highest >= 0 && value + this.size < this.highest) return false;
-        if (this.seen.has(value)) return false;
-        this.seen.add(value);
-        if (this.highest < 0 || value > this.highest) this.highest = value;
-        const minimum = Math.max(0, this.highest - this.size);
-        for (const item of this.seen) {
-            if (item < minimum) this.seen.delete(item);
-        }
-        return true;
-    }
-}
+    accept(sequence) {
+        let value;
+        try {
+            value = normalizeSequence(sequence);
+        } catch {
+            return false;
+        }
+        if (this.seen.has(value)) return false;
+        if (this.highest >= 0) {
+            const forward = (value - this.highest + UDP_SERIAL_MODULUS) % UDP_SERIAL_MODULUS;
+            if (forward === 0 || forward === UDP_SERIAL_HALF_RANGE) return false;
+            if (forward > UDP_SERIAL_HALF_RANGE) {
+                const age = (this.highest - value + UDP_SERIAL_MODULUS) % UDP_SERIAL_MODULUS;
+                if (age > this.size) return false;
+            } else {
+                this.highest = value;
+            }
+        } else {
+            this.highest = value;
+        }
+        this.seen.add(value);
+        for (const item of this.seen) {
+            const age = (this.highest - item + UDP_SERIAL_MODULUS) % UDP_SERIAL_MODULUS;
+            if (age > this.size) this.seen.delete(item);
+        }
+        return true;
+    }
+}
 
 export class UdpFrameReassembler {
     constructor({ maxPending = 2, timeoutMs = 500, maxFrameBytes = 8 * 1024 * 1024 } = {}) {