@livedesk/hub 0.1.58 → 0.1.61

package/src/settings/settings-schema.js

@@ -1,7 +1,7 @@
 import os from 'node:os';
 import path from 'node:path';
 
-export const SETTINGS_SCHEMA_VERSION = 1;
+export const SETTINGS_SCHEMA_VERSION = 2;
 
 export const DEFAULT_LIVEDESK_SETTINGS = Object.freeze({
   settingsSchemaVersion: SETTINGS_SCHEMA_VERSION,
@@ -80,9 +80,9 @@ export const DEFAULT_LIVEDESK_SETTINGS = Object.freeze({
     includeRemoteCursor: true,
     captureSaveLocation: 'VuvoDesk Captures',
     captureAutoDelete: 'never'
-  },
-  agent: {
-    enabled: false,
+  },
+  agent: {
+    enabled: true,
     defaultPermissionMode: 'safe-auto',
     askBeforeDestructive: true,
     allowProcessManagement: true,
@@ -156,8 +156,27 @@ function normalizeSection(source, defaults, rules = {}) {
   return result;
 }
 
-const bools = keys => Object.fromEntries(keys.map(key => [key, { type: 'boolean' }]));
-const numbers = (entries) => Object.fromEntries(entries.map(([key, min, max]) => [key, { type: 'number', min, max }]));
+const bools = keys => Object.fromEntries(keys.map(key => [key, { type: 'boolean' }]));
+const numbers = (entries) => Object.fromEntries(entries.map(([key, min, max]) => [key, { type: 'number', min, max }]));
+
+export function migrateLiveDeskSettings(value = {}) {
+  const source = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+  const storedVersion = Math.max(0, Math.trunc(Number(source.settingsSchemaVersion) || 0));
+  if (storedVersion >= SETTINGS_SCHEMA_VERSION) return source;
+  const agent = source.agent && typeof source.agent === 'object' && !Array.isArray(source.agent)
+    ? source.agent
+    : {};
+  return {
+    ...source,
+    settingsSchemaVersion: SETTINGS_SCHEMA_VERSION,
+    agent: {
+      ...agent,
+      // Schema 1 shipped disabled-by-default. Schema 2 treats that old value
+      // as the retired default; a later explicit opt-out is stored as schema 2.
+      enabled: true
+    }
+  };
+}
 
 const RULES = {
   connection: {

package/src/settings/settings-store.js

@@ -1,6 +1,6 @@
 import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import { DEFAULT_LIVEDESK_SETTINGS, defaultSettingsPath, normalizeLiveDeskSettings, publicSettings } from './settings-schema.js';
+import { DEFAULT_LIVEDESK_SETTINGS, defaultSettingsPath, migrateLiveDeskSettings, normalizeLiveDeskSettings, publicSettings } from './settings-schema.js';
 
 export class SettingsConflictError extends Error {
   constructor(settings) {
@@ -27,13 +27,14 @@ export class LiveDeskSettingsStore {
 
   async getRecord() {
     if (this.record) return structuredClone(this.record);
-    try {
-      const raw = JSON.parse(await readFile(this.filePath, 'utf8'));
-      this.record = {
-        revision: Math.max(0, Number(raw?.revision) || 0),
-        updatedAt: String(raw?.updatedAt || ''),
-        settings: normalizeLiveDeskSettings(raw?.settings || raw)
-      };
+    try {
+      const raw = JSON.parse(await readFile(this.filePath, 'utf8'));
+      const migratedSettings = migrateLiveDeskSettings(raw?.settings || raw);
+      this.record = {
+        revision: Math.max(0, Number(raw?.revision) || 0),
+        updatedAt: String(raw?.updatedAt || ''),
+        settings: normalizeLiveDeskSettings(migratedSettings)
+      };
     } catch {
       this.record = { revision: 0, updatedAt: '', settings: normalizeLiveDeskSettings(DEFAULT_LIVEDESK_SETTINGS) };
     }

package/src/wall-source-restart-contract.test.mjs

@@ -0,0 +1,48 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import test from 'node:test';
+
+const [remoteHubSource, serverSource] = await Promise.all([
+  readFile(new URL('./remote-hub.js', import.meta.url), 'utf8'),
+  readFile(new URL('./server.js', import.meta.url), 'utf8')
+]);
+
+function sourceSlice(source, startMarker, endMarker) {
+  const start = source.indexOf(startMarker);
+  const end = source.indexOf(endMarker, start + startMarker.length);
+  assert.ok(start >= 0 && end > start, `missing source slice: ${startMarker}`);
+  return source.slice(start, end);
+}
+
+test('a recovered frame subscription asks the Hub to reuse its healthy source', () => {
+  const subscriptionStart = sourceSlice(
+    serverSource,
+    'function startFrameSubscriptionLive(',
+    'function restartFrameSubscriptionLive('
+  );
+  assert.match(
+    subscriptionStart,
+    /reuseExisting: liveOptions\.forceRestart !== true[\s\S]{0,180}reason === 'subscribe' \|\| reason === 'watchdog'/
+  );
+});
+
+test('the atomic Hub start decision reuses only a matching live source', () => {
+  const liveStart = sourceSlice(
+    remoteHubSource,
+    'function startLiveStream(deviceId, options = {})',
+    'function stopLiveStream('
+  );
+  assert.match(
+    liveStart,
+    /options\.reuseExisting === true[\s\S]{0,160}liveStreamMatchesOptions\(activeLiveStream, normalized\)[\s\S]{0,160}liveStreamIsReusable\(activeLiveStream\)[\s\S]{0,900}reused: true/
+  );
+  assert.match(
+    liveStart,
+    /!liveStreamIsReusable\(activeLiveStream\)[\s\S]{0,900}RemoteLiveStreamStaleRestart[\s\S]{0,900}const captureGeneration = nextCaptureGeneration\(device\)/
+  );
+});
+
+test('Wall lane recovery has no special native-restart wire option', () => {
+  assert.doesNotMatch(serverSource, /restartIfSourceStale|sourceFreshRestartSuppressed/);
+  assert.doesNotMatch(remoteHubSource, /restartIfSourceStale|sourceFreshRestartSuppressed/);
+});

package/src/wall-source-restart-runtime.test.mjs

@@ -0,0 +1,146 @@
+import assert from 'node:assert/strict';
+import net from 'node:net';
+import { once } from 'node:events';
+import test from 'node:test';
+import { createRemoteHub } from './remote-hub.js';
+
+test('a new Wall frame lane reuses a healthy exact capture', async () => {
+  const hub = createRemoteHub({
+    env: {
+      ...process.env,
+      LIVEDESK_REMOTE_HUB: '1',
+      REMOTE_HUB_HOST: '127.0.0.1',
+      REMOTE_HUB_PORT: '0'
+    },
+    pairToken: 'wall-source-reuse-token'
+  });
+  let socket;
+  try {
+    const status = await hub.start();
+    socket = net.createConnection({ host: '127.0.0.1', port: status.port });
+    await once(socket, 'connect');
+
+    const messages = [];
+    let buffer = '';
+    socket.on('data', chunk => {
+      buffer += chunk.toString('utf8');
+      let newline = buffer.indexOf('\n');
+      while (newline >= 0) {
+        const line = buffer.slice(0, newline).trim();
+        buffer = buffer.slice(newline + 1);
+        if (line) messages.push(JSON.parse(line));
+        newline = buffer.indexOf('\n');
+      }
+    });
+    const waitUntil = async predicate => {
+      const deadline = Date.now() + 2_000;
+      while (Date.now() < deadline) {
+        if (predicate()) return;
+        await new Promise(resolve => setTimeout(resolve, 10));
+      }
+      throw new Error('timed out waiting for Wall source reuse fixture');
+    };
+    const send = message => socket.write(`${JSON.stringify(message)}\n`);
+
+    send({
+      type: 'hello',
+      pairToken: 'wall-source-reuse-token',
+      deviceId: 'wall-source-device',
+      deviceName: 'Wall source reuse fixture',
+      hostname: 'wall-source-reuse',
+      platform: 'darwin',
+      arch: 'arm64',
+      protocol: 'mindexec.remote.agent',
+      protocolVersion: 2,
+      capabilities: { liveStream: true, frameProtocol: {}, frameModes: [] }
+    });
+    await waitUntil(() => messages.some(message => message.type === 'welcome'));
+
+    const streamId = 'wall-wall-source-device';
+    const options = {
+      streamId,
+      streamPurpose: 'wall',
+      mode: 'mode3-h264-hw',
+      frameMode: 'mode3-h264-hw',
+      fps: 30,
+      maxWidth: 960,
+      maxHeight: 540,
+      quality: 68,
+      monitorIndex: 0
+    };
+    const first = hub.startLiveStream('wall-source-device', {
+      ...options,
+      commandId: 'wall-command-1',
+      forceRestart: true,
+      restartToken: 'initial-wall-start'
+    });
+    assert.equal(first.ok, true);
+    await waitUntil(() => messages.some(message => (
+      message.type === 'command'
+      && message.command === 'stream.start'
+      && message.commandId === 'wall-command-1'
+    )));
+
+    send({
+      type: 'stream.open',
+      streamId,
+      commandId: 'wall-command-1',
+      captureGeneration: first.captureGeneration,
+      monitorIndex: 0,
+      streamPurpose: 'wall',
+      mode: 'mode3-h264-hw',
+      frameMode: 'mode3-h264-hw',
+      width: 960,
+      height: 540
+    });
+    send({
+      type: 'stream.frame',
+      streamId,
+      commandId: 'wall-command-1',
+      captureGeneration: first.captureGeneration,
+      monitorIndex: 0,
+      streamPurpose: 'wall',
+      frameSeq: 1,
+      frameMode: 'mode3-h264-hw',
+      mimeType: 'video/h264',
+      isKeyFrame: true,
+      chunkType: 'key',
+      width: 960,
+      height: 540,
+      data: Buffer.from([
+        0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00, 0x1f,
+        0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x06, 0xe2,
+        0x00, 0x00, 0x00, 0x01, 0x65, 0x88, 0x84
+      ]).toString('base64')
+    });
+    await waitUntil(() => hub.getDeviceLiveFrame('wall-source-device')?.currentGenerationVerified === true);
+
+    const commandCountBeforeReuse = messages.filter(message => message.command === 'stream.start').length;
+    const reused = hub.startLiveStream('wall-source-device', {
+      ...options,
+      reuseExisting: true
+    });
+    assert.equal(reused.ok, true);
+    assert.equal(reused.reused, true);
+    assert.equal(reused.commandId, first.commandId);
+    assert.equal(reused.captureGeneration, first.captureGeneration);
+    await new Promise(resolve => setTimeout(resolve, 20));
+    assert.equal(
+      messages.filter(message => message.command === 'stream.start').length,
+      commandCountBeforeReuse,
+      'a replacement browser lane must not restart a healthy shared capture'
+    );
+
+    const hardRestart = hub.startLiveStream('wall-source-device', {
+      ...options,
+      commandId: 'wall-command-hard-restart',
+      forceRestart: true,
+      restartToken: 'explicit-owner-restart'
+    });
+    assert.equal(hardRestart.ok, true);
+    assert.ok(hardRestart.captureGeneration > first.captureGeneration);
+  } finally {
+    socket?.destroy();
+    await hub.close();
+  }
+});