@livedesk/hub 0.1.66 → 0.1.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/hub",
-  "version": "0.1.66",
+  "version": "0.1.68",
   "description": "VuvoDesk local Hub API and browser frame bridge",
   "type": "module",
   "main": "src/server.js",
@@ -12,11 +12,11 @@
     "dev": "node src/server.js",
     "start": "node src/server.js",
     "check": "node --check src/server.js && node --check src/remote-hub.js && node --check src/remote-clipboard-contract.mjs && node --check src/console-direct.js",
-    "prepublishOnly": "node ../../scripts/livedesk-release-git-gate.mjs"
+    "prepublishOnly": "node ../../scripts/vuvodesk-release-git-gate.mjs"
   },
   "dependencies": {
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
-    "@livedesk/runtime-core": "0.1.8",
+    "@livedesk/runtime-core": "0.1.9",
     "@openai/codex-sdk": "0.145.0",
     "cors": "^2.8.5",
     "express": "^4.21.2",

package/src/captures/capture-store.js

@@ -86,7 +86,7 @@ export class CaptureStore {
       throw Object.assign(new Error('capture-mime-type-unsupported'), { status: 415 });
     }
     const extension = MIME_EXTENSIONS.get(mimeType) || (kind === 'screenshot' ? '.png' : '.webm');
-    const fileNameBase = safeName(metadata.fileName, `LiveDesk_${kind}`);
+    const fileNameBase = safeName(metadata.fileName, `VuvoDesk_${kind}`);
     const fileName = fileNameBase.toLowerCase().endsWith(extension) ? fileNameBase : `${fileNameBase}${extension}`;
     const id = randomUUID();
     const folder = kind === 'screenshot' ? 'images' : kind === 'timelapse' ? 'timelapses' : 'recordings';
@@ -122,7 +122,7 @@ export class CaptureStore {
     const sessionId = randomUUID();
     const tempPath = path.join(this.root, '.tmp', `${sessionId}.webm.part`);
     await writeFile(tempPath, Buffer.alloc(0), { mode: 0o600 });
-    const fileNameBase = safeName(metadata.fileName, `LiveDesk_${kind}`);
+    const fileNameBase = safeName(metadata.fileName, `VuvoDesk_${kind}`);
     const session = {
       sessionId,
       kind,

package/src/console-direct.js

@@ -29,6 +29,7 @@ const MAX_SHARED_ASSEMBLY_BYTES = 12 * 1024 * 1024;
 const MAX_FRAME_MESSAGE_BYTES = (8 * 1024 * 1024) + DIRECT_CONSOLE_WIRE_CHUNK_BYTES;
 const MAX_PENDING_MEDIA_WIRE_MESSAGES = 8;
 const MAX_DATA_CHANNEL_BUFFERED_BYTES = 12 * 1024 * 1024;
+const CONTROL_HEADROOM_BUFFERED_BYTES = 4 * 1024 * 1024;
 const MAX_LOCAL_WS_BUFFERED_BYTES = 4 * 1024 * 1024;
 const HTTP_TIMEOUT_MS = 15_000;
 const ICE_CONNECT_TIMEOUT_MS = 10_000;
@@ -169,6 +170,7 @@ function allowedHttpRequest(method, pathname) {
     || pathname === '/api/auth/session'
     || pathname === '/api/remote/status'
     || pathname === '/api/hub/status'
+    || pathname === '/api/remote/pwa-diagnostics'
     || pathname === '/api/update/status'
     || pathname === '/api/update/apply') {
     return true;
@@ -369,6 +371,8 @@ export function createHubConsoleDirect(options = {}) {
   let lastHttpStatus = 0;
   let rejectedRelayCandidates = 0;
   let dataChannelBackpressureCloses = 0;
+  let dataChannelSendFailures = 0;
+  let lastDataChannelSendFailure = null;
   let malformedWireCloses = 0;
   let wireBudgetCleanupFailures = 0;
 
@@ -651,7 +655,7 @@ export function createHubConsoleDirect(options = {}) {
         || channelBufferedAmount(right) - channelBufferedAmount(left)
       ));
     for (const state of candidates) {
-      if (ownerBufferedAmount(owner) + requiredBytes <= MAX_DATA_CHANNEL_BUFFERED_BYTES) break;
+      if (ownerBufferedAmount(owner) + requiredBytes <= CONTROL_HEADROOM_BUFFERED_BYTES) break;
       dataChannelBackpressureCloses += 1;
       closeLogicalChannel(owner, state, {
         code: 1013,
@@ -680,8 +684,39 @@ export function createHubConsoleDirect(options = {}) {
       return false;
     }
     const wireBytes = chunks.reduce((total, chunk) => total + chunk.byteLength, 0);
+    const partialMedia = channelState.purpose === 'frame' || channelState.purpose === 'atlas';
+    if (partialMedia
+      && (wireBytes > MAX_DATA_CHANNEL_BUFFERED_BYTES
+        || ownerBufferedAmount(owner) + wireBytes > MAX_DATA_CHANNEL_BUFFERED_BYTES)) {
+      dataChannelBackpressureCloses += 1;
+      if (options.closeOnFailure !== false) {
+        closeLogicalChannel(owner, channelState, {
+          code: 1013,
+          reason: 'console-direct-datachannel-backpressure',
+          notify: false
+        });
+      }
+      return false;
+    }
+    const mediaBufferedBytes = partialMedia ? channelBufferedAmount(channelState) : 0;
+    if (partialMedia
+      && mediaBufferedBytes > 0
+      && mediaBufferedBytes + wireBytes > CONTROL_HEADROOM_BUFFERED_BYTES) {
+      // Retire only the media lane that owns the stale SCTP backlog. Its
+      // browser socket recovery requests a current key frame while the
+      // reliable peer and every healthy lane keep their own owners.
+      dataChannelBackpressureCloses += 1;
+      if (options.closeOnFailure !== false) {
+        closeLogicalChannel(owner, channelState, {
+          code: 1013,
+          reason: 'console-direct-media-headroom',
+          notify: false
+        });
+      }
+      return false;
+    }
     if (channelState === owner.control
-      && ownerBufferedAmount(owner) + wireBytes > MAX_DATA_CHANNEL_BUFFERED_BYTES) {
+      && ownerBufferedAmount(owner) + wireBytes > CONTROL_HEADROOM_BUFFERED_BYTES) {
       releaseLogicalBacklogForControl(owner, wireBytes);
     }
     if (wireBytes > MAX_DATA_CHANNEL_BUFFERED_BYTES
@@ -697,11 +732,28 @@ export function createHubConsoleDirect(options = {}) {
       }
       return false;
     }
-    for (const chunk of chunks) {
+    for (const [chunkIndex, chunk] of chunks.entries()) {
       if (!isOwnerActive(owner) || channelState.closed || !channelIsOpen(channelState.channel)) return false;
       try {
-        if (channelState.channel.sendMessageBinary(chunk) !== true) throw new Error('send-rejected');
-      } catch {
+        // Normalize the node-datachannel native boundary to its documented
+        // Node Buffer shape. Share the exact encoded bytes without copying or
+        // retaining a second application queue.
+        const nativeChunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+        if (channelState.channel.sendMessageBinary(nativeChunk) !== true) throw new Error('send-rejected');
+      } catch (error) {
+        dataChannelSendFailures += 1;
+        lastDataChannelSendFailure = Object.freeze({
+          purpose: channelState.purpose,
+          channelId: channelState.channelId,
+          generation: owner.generation,
+          messageId: (channelState.nextSendMessageId - 1) >>> 0,
+          chunkIndex,
+          chunkCount: chunks.length,
+          chunkBytes: chunk.byteLength,
+          bufferedBytes: channelBufferedAmount(channelState),
+          error: String(error instanceof Error ? error.message : error).slice(0, 120),
+          occurredAt: Date.now()
+        });
         if (options.closeOnFailure !== false) {
           if (channelState === owner.control) retirePeer(owner, 'console-direct-control-send-failed');
           else closeLogicalChannel(owner, channelState, {
@@ -1950,6 +2002,8 @@ export function createHubConsoleDirect(options = {}) {
         + Number(signalHeartbeatTimerActive),
       rejectedRelayCandidates,
       dataChannelBackpressureCloses,
+      dataChannelSendFailures,
+      lastDataChannelSendFailure,
       malformedWireCloses,
       wireBudgetCleanupFailures,
       lastConnectedAt,
@@ -1982,6 +2036,7 @@ export const consoleDirectContract = Object.freeze({
   maxFrameMessageBytes: MAX_FRAME_MESSAGE_BYTES,
   maxPendingMediaWireMessages: MAX_PENDING_MEDIA_WIRE_MESSAGES,
   maxBufferedBytes: MAX_DATA_CHANNEL_BUFFERED_BYTES,
+  controlHeadroomBufferedBytes: CONTROL_HEADROOM_BUFFERED_BYTES,
   maxLocalWebSocketBufferedBytes: MAX_LOCAL_WS_BUFFERED_BYTES,
   maxDefaultRetryDelayMs: DEFAULT_RETRY_DELAYS_MS.at(-1),
   accessTokenTimeoutMs: ACCESS_TOKEN_TIMEOUT_MS,

package/src/console-direct.test.mjs

@@ -23,6 +23,7 @@ const CONSOLE_ID = '22222222-2222-4222-8222-222222222222';
 const CONNECTION_ONE = '33333333-3333-4333-8333-333333333333';
 const CONNECTION_TWO = '44444444-4444-4444-8444-444444444444';
 const CHANNEL_ID = '55555555-5555-4555-8555-555555555555';
+const CHANNEL_ID_TWO = '55555555-5555-4555-8555-555555555556';
 const REQUEST_ID = '66666666-6666-4666-8666-666666666666';
 const TEAM_WORKSPACE_ID = '88888888-8888-4888-8888-888888888888';
 const TEAM_OWNER_USER_ID = '99999999-9999-4999-8999-999999999999';
@@ -123,6 +124,7 @@ class FakeDataChannel {
 
   sendMessageBinary(value) {
     if (!this.isOpen()) return false;
+    if (!Buffer.isBuffer(value)) throw new TypeError('Buffer expected');
     this.sent.push(new Uint8Array(value));
     return true;
   }
@@ -627,6 +629,48 @@ test('reliable control channel bridges bounded HTTP over fragmented wire message
   direct.close();
 });
 
+test('reliable control channel admits the authenticated PWA diagnostic route', async () => {
+  let fetchCalls = 0;
+  const diagnosticBody = JSON.stringify({ schema: 'livedesk.pwa-runtime-diagnostics.v1', events: [] });
+  const { direct, signal } = await connectedDirect({
+    fetchImpl: async (url, init) => {
+      fetchCalls += 1;
+      assert.equal(url, 'http://127.0.0.1:5179/api/remote/pwa-diagnostics');
+      assert.equal(init.method, 'POST');
+      assert.equal(init.headers['content-type'], 'application/json');
+      assert.equal(Buffer.from(init.body).toString('utf8'), diagnosticBody);
+      return new Response('{"ok":true,"accepted":true}', {
+        status: 202,
+        statusText: 'Accepted',
+        headers: { 'Content-Type': 'application/json' }
+      });
+    }
+  });
+  const peer = offer(signal);
+  const control = new FakeDataChannel('livedesk-control-v1');
+  peer.emitDataChannel(control);
+  control.open();
+
+  sendWire(control, {
+    type: 'http-request',
+    requestId: REQUEST_ID,
+    method: 'POST',
+    path: '/api/remote/pwa-diagnostics',
+    headers: { 'content-type': 'application/json' },
+    bodyBase64: Buffer.from(diagnosticBody).toString('base64')
+  });
+  await settle();
+  const response = decodeWireMessages(control.sent)
+    .map(message => JSON.parse(message.data))
+    .find(message => message.type === 'http-response');
+  assert.equal(fetchCalls, 1, 'The PWA diagnostic request must reach the local Hub API.');
+  assert.equal(response.requestId, REQUEST_ID);
+  assert.equal(response.status, 202);
+  assert.equal(Buffer.from(response.bodyBase64, 'base64').toString('utf8'), '{"ok":true,"accepted":true}');
+  assert.equal(direct.inspect().pendingHttpRequests, 0);
+  direct.close();
+});
+
 test('Team Operator can use Wall and Control but cannot mutate the Hub owner runtime', async () => {
   const teamWorkspaceAccess = {
     workspaceId: TEAM_WORKSPACE_ID,
@@ -1184,6 +1228,56 @@ test('the peer-wide DataChannel buffer cap closes only the overflowing logical l
   direct.close();
 });
 
+test('media pressure retires only its stale logical lane while preserving the control peer and a healthy lane', async () => {
+  const { direct, signal } = await connectedDirect();
+  const peer = offer(signal);
+  const control = new FakeDataChannel('livedesk-control-v1');
+  peer.emitDataChannel(control);
+  control.open();
+  const lane = new FakeDataChannel(`livedesk-ws-v1:${CHANNEL_ID}:frame`);
+  peer.emitDataChannel(lane);
+  lane.open();
+  sendWire(control, {
+    type: 'ws-open',
+    connectionId: CONNECTION_ONE,
+    hubEpoch: HUB_EPOCH,
+    channelId: CHANNEL_ID,
+    purpose: 'frame',
+    path: '/api/remote/frames/ws'
+  });
+  const local = FakeLocalSocket.instances[0];
+  local.open();
+  const healthyLane = new FakeDataChannel(`livedesk-ws-v1:${CHANNEL_ID_TWO}:frame`);
+  peer.emitDataChannel(healthyLane);
+  healthyLane.open();
+  sendWire(control, {
+    type: 'ws-open',
+    connectionId: CONNECTION_ONE,
+    hubEpoch: HUB_EPOCH,
+    channelId: CHANNEL_ID_TWO,
+    purpose: 'frame',
+    path: '/api/remote/frames/ws'
+  });
+  const healthyLocal = FakeLocalSocket.instances[1];
+  healthyLocal.open();
+  lane.buffered = consoleDirectContract.controlHeadroomBufferedBytes;
+
+  healthyLocal.receive('healthy-frame');
+  assert.ok(healthyLane.sent.length > 0);
+  assert.equal(healthyLane.closed, false);
+  assert.equal(lane.closed, false);
+
+  local.receive('newest-frame');
+
+  assert.equal(lane.sent.length, 0);
+  assert.equal(lane.closed, true);
+  assert.equal(healthyLane.closed, false);
+  assert.equal(control.closed, false);
+  assert.equal(peer.closed, false);
+  assert.equal(direct.inspect().dataChannelBackpressureCloses, 1);
+  direct.close();
+});
+
 test('a reliable control response drops stale media backlog without retiring the peer', async () => {
   const { direct, signal } = await connectedDirect({
     fetchImpl: async () => new Response('{"online":true}', {
@@ -1405,7 +1499,7 @@ test('native node-datachannel peers carry the fragmented control wire over loopb
       kind: 'control'
     });
     assert.ok(chunks.length > 1);
-    for (const chunk of chunks) assert.equal(offerChannel.sendMessageBinary(chunk), true);
+    for (const chunk of chunks) assert.equal(offerChannel.sendMessageBinary(Buffer.from(chunk)), true);
     const message = await received;
     clearTimeout(messageTimer);
     messageTimer = null;