@walkhi/code-relax 0.1.0-beta.66 → 0.1.0-beta.68

package/dist/src/self-relay/android-releases.mjs

@@ -1,61 +1,61 @@
-import fs from 'node:fs';
-
-const prefix = '/code-relax/android/';
-const webOrigin = 'https://www.coderelax.cn';
-
-export function readAndroidCatalog(file) {
-  const data = JSON.parse(fs.readFileSync(file, 'utf8'));
-  if (!Array.isArray(data.releases) || !data.releases.length) throw new Error('No Android releases');
-  const versions = new Set();
-  for (const item of data.releases) {
-    if (!Number.isSafeInteger(item.versionCode) || item.versionCode < 1 || item.versionCode > 2100000000
-      || versions.has(item.versionCode) || typeof item.versionName !== 'string' || !/^\d+\.\d+\.\d+\.\d+$/.test(item.versionName)
-      || !item.versionName.endsWith('.' + item.versionCode)
-      || !Number.isSafeInteger(item.size) || item.size <= 0 || !/^[a-f0-9]{64}$/.test(item.sha256)
-      || typeof item.objectKey !== 'string' || !/^code-relax\/android\/\d+\/[A-Za-z0-9._-]+\.apk$/.test(item.objectKey)
-      || typeof item.notes !== 'string' || item.notes.length > 10000) throw new Error('Invalid Android release catalog');
-    versions.add(item.versionCode);
-  }
-  if (!versions.has(data.latestVersionCode)) throw new Error('Latest Android release is missing');
-  return data;
-}
-
-export function createAndroidReleaseHandler({ catalogFile, signDownload, log = () => {} }) {
-  return async function handle(request, response, target) {
-    if (!target.pathname.startsWith(prefix)) return false;
-    const headers = { 'Cache-Control': 'no-store', 'Content-Type': 'application/json; charset=utf-8',
-      'X-Content-Type-Options': 'nosniff', 'Referrer-Policy': 'no-referrer',
-      'Access-Control-Allow-Origin': webOrigin, Vary: 'Origin' };
-    const reply = (code, data) => { response.writeHead(code, headers); response.end(JSON.stringify(data)); };
-    if (request.method !== 'GET') { reply(405, { error: 'Method not allowed' }); return true; }
-    if (![prefix + 'latest.json', prefix + 'download'].includes(target.pathname)) {
-      reply(404, { error: 'Not found' }); return true;
-    }
-    try {
-      if (!catalogFile || !signDownload) { reply(503, { error: 'Android release is not available' }); return true; }
-      const catalog = readAndroidCatalog(catalogFile);
-      const requested = target.searchParams.get('versionCode');
-      if (requested !== null && !/^[1-9]\d{0,9}$/.test(requested)) { reply(400, { error: 'Invalid version' }); return true; }
-      const code = target.pathname.endsWith('/latest.json') || requested === null ? catalog.latestVersionCode : Number(requested);
-      const release = catalog.releases.find(item => item.versionCode === code);
-      if (!release) { reply(404, { error: 'Release unavailable; check for updates again' }); return true; }
-      const { versionCode, versionName, size, sha256, notes } = release;
-      if (target.pathname.endsWith('/latest.json')) {
-        reply(200, { versionCode, versionName, size, sha256, notes }); return true;
-      }
-      // Sign only an explicitly published object, never a caller-supplied key or URL.
-      const ticket = await signDownload(release);
-      if (!ticket || new URL(ticket.url).protocol !== 'https:' || !Number.isSafeInteger(ticket.expiresAt) || ticket.expiresAt <= Date.now()) {
-        throw new Error('Invalid download ticket');
-      }
-      if (target.searchParams.get('redirect') === '1') {
-        response.writeHead(302, { ...headers, Location: ticket.url }); response.end();
-      } else reply(200, { versionCode, url: ticket.url, expiresAt: ticket.expiresAt });
-    } catch (error) {
-      // Provider errors may contain signed URLs or credentials. Never return or log them.
-      log({ event: 'android-release-error', type: error?.code === 'ENOENT' ? 'not-published' : 'configuration-or-storage' });
-      reply(503, { error: 'Android release is temporarily unavailable' });
-    }
-    return true;
-  };
-}
+import fs from 'node:fs';
+
+const prefix = '/code-relax/android/';
+const webOrigin = 'https://www.coderelax.cn';
+
+export function readAndroidCatalog(file) {
+  const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (!Array.isArray(data.releases) || !data.releases.length) throw new Error('No Android releases');
+  const versions = new Set();
+  for (const item of data.releases) {
+    if (!Number.isSafeInteger(item.versionCode) || item.versionCode < 1 || item.versionCode > 2100000000
+      || versions.has(item.versionCode) || typeof item.versionName !== 'string' || !/^\d+\.\d+\.\d+\.\d+$/.test(item.versionName)
+      || !item.versionName.endsWith('.' + item.versionCode)
+      || !Number.isSafeInteger(item.size) || item.size <= 0 || !/^[a-f0-9]{64}$/.test(item.sha256)
+      || typeof item.objectKey !== 'string' || !/^code-relax\/android\/\d+\/[A-Za-z0-9._-]+\.apk$/.test(item.objectKey)
+      || typeof item.notes !== 'string' || item.notes.length > 10000) throw new Error('Invalid Android release catalog');
+    versions.add(item.versionCode);
+  }
+  if (!versions.has(data.latestVersionCode)) throw new Error('Latest Android release is missing');
+  return data;
+}
+
+export function createAndroidReleaseHandler({ catalogFile, signDownload, log = () => {} }) {
+  return async function handle(request, response, target) {
+    if (!target.pathname.startsWith(prefix)) return false;
+    const headers = { 'Cache-Control': 'no-store', 'Content-Type': 'application/json; charset=utf-8',
+      'X-Content-Type-Options': 'nosniff', 'Referrer-Policy': 'no-referrer',
+      'Access-Control-Allow-Origin': webOrigin, Vary: 'Origin' };
+    const reply = (code, data) => { response.writeHead(code, headers); response.end(JSON.stringify(data)); };
+    if (request.method !== 'GET') { reply(405, { error: 'Method not allowed' }); return true; }
+    if (![prefix + 'latest.json', prefix + 'download'].includes(target.pathname)) {
+      reply(404, { error: 'Not found' }); return true;
+    }
+    try {
+      if (!catalogFile || !signDownload) { reply(503, { error: 'Android release is not available' }); return true; }
+      const catalog = readAndroidCatalog(catalogFile);
+      const requested = target.searchParams.get('versionCode');
+      if (requested !== null && !/^[1-9]\d{0,9}$/.test(requested)) { reply(400, { error: 'Invalid version' }); return true; }
+      const code = target.pathname.endsWith('/latest.json') || requested === null ? catalog.latestVersionCode : Number(requested);
+      const release = catalog.releases.find(item => item.versionCode === code);
+      if (!release) { reply(404, { error: 'Release unavailable; check for updates again' }); return true; }
+      const { versionCode, versionName, size, sha256, notes } = release;
+      if (target.pathname.endsWith('/latest.json')) {
+        reply(200, { versionCode, versionName, size, sha256, notes }); return true;
+      }
+      // Sign only an explicitly published object, never a caller-supplied key or URL.
+      const ticket = await signDownload(release);
+      if (!ticket || new URL(ticket.url).protocol !== 'https:' || !Number.isSafeInteger(ticket.expiresAt) || ticket.expiresAt <= Date.now()) {
+        throw new Error('Invalid download ticket');
+      }
+      if (target.searchParams.get('redirect') === '1') {
+        response.writeHead(302, { ...headers, Location: ticket.url }); response.end();
+      } else reply(200, { versionCode, url: ticket.url, expiresAt: ticket.expiresAt });
+    } catch (error) {
+      // Provider errors may contain signed URLs or credentials. Never return or log them.
+      log({ event: 'android-release-error', type: error?.code === 'ENOENT' ? 'not-published' : 'configuration-or-storage' });
+      reply(503, { error: 'Android release is temporarily unavailable' });
+    }
+    return true;
+  };
+}

package/dist/src/self-relay/client.mjs

@@ -1,61 +1,61 @@
-import { EventEmitter } from 'node:events';
-import WebSocket from 'ws';
-import { decode, relayAddress, send } from './wire.mjs';
-
-// Headless mobile-side adapter for the local validation. No OpenAI credentials.
-export function connectRelayClient({ relayUrl, room, code, credential, clientId, accountToken, observe = false }) {
-  relayAddress(relayUrl);
-  const events = new EventEmitter(), pending = new Map();
-  const socket = new WebSocket(relayUrl, { maxPayload: 64 * 1024 * 1024, perMessageDeflate: true });
-  let serial = 0, connected = false, pairedCredential = credential, pairedClientId = clientId;
-  const ready = new Promise((resolve, reject) => {
-    const timer = setTimeout(() => { reject(new Error('Relay connection timeout')); socket.terminate(); }, 7000);
-    socket.on('open', () => send(socket, observe ? { type: 'observe', room, credential, clientId, accountToken }
-      : code ? { type: 'pair', room, code, credential, clientId, accountToken } : { type: 'resume', room, credential, clientId, accountToken }));
-    socket.on('error', error => { reject(error); events.emit('diagnostic', error.message); });
-    socket.on('close', () => {
-      clearTimeout(timer); connected = false; reject(new Error('Relay connection closed'));
-      for (const request of pending.values()) { clearTimeout(request.timer); request.reject(new Error('连接断开，操作结果未确认，不自动重发')); }
-      pending.clear(); events.emit('disconnected');
-    });
-    socket.on('message', (bytes, binary) => {
-      try {
-        const message = decode(bytes, binary);
-        if (message.type === 'paired') { if (message.credential) pairedCredential = message.credential; if (message.clientId) pairedClientId = message.clientId; }
-        else if (message.type === 'observing') { clearTimeout(timer); connected = true; events.emit('observing', message); resolve({ room, credential: pairedCredential, clientId: pairedClientId }); }
-        else if (message.type === 'computer-info') events.emit('computer-info', { hostName: message.hostName });
-        else if (message.type === 'lan-candidates') events.emit('lan-candidates', message.candidates);
-        else if (message.type === 'official-computer') events.emit('official-computer', message.computer);
-        else if (message.type === 'official-computer-saved') events.emit('official-computer-saved', message.computer);
-        else if (message.type === 'announcement') events.emit('announcement', message.announcement);
-        else if (message.type === 'ready') { clearTimeout(timer); connected = true; resolve({ room, credential: pairedCredential, clientId: pairedClientId }); }
-        else if (message.type === 'data') {
-          const body = decode(message.payload, false), request = pending.get(body.id);
-          if (body.type === 'response' && request) { clearTimeout(request.timer); pending.delete(body.id); request.resolve(body); }
-          else events.emit('message', body);
-        } else throw new Error('Invalid relay message');
-      } catch (error) { reject(error); events.emit('diagnostic', error.message); socket.close(1008, 'Invalid response'); }
-    });
-  });
-  return {
-    ready, events,
-    request(path, { method = 'GET', body, timeoutMs = 5000 } = {}) {
-      if (!connected) return Promise.reject(new Error('Relay not ready'));
-      const id = ++serial;
-      return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => { pending.delete(id); reject(new Error('请求超时，结果未确认，不自动重发')); }, timeoutMs);
-        pending.set(id, { resolve, reject, timer });
-        if (!send(socket, { type: 'data', payload: JSON.stringify({ type: 'request', id, path, method, ...(body ? { body } : {}) }) })) {
-          clearTimeout(timer); pending.delete(id); reject(new Error('Relay not connected'));
-        }
-      });
-    },
-    send(message) { if (!connected) throw new Error('Relay not ready'); return send(socket, { type: 'data', payload: JSON.stringify(message) }); },
-    routeDirect() { if (!connected) throw new Error('Relay not ready'); return send(socket, { type: 'p2p-route', direct: 1 }); },
-    recordOfficialComputer(computer) {
-      if (!connected || !observe) throw new Error('Metadata channel not ready');
-      return send(socket, { type: 'official-computer', ...computer });
-    },
-    close() { socket.terminate(); },
-  };
-}
+import { EventEmitter } from 'node:events';
+import WebSocket from 'ws';
+import { decode, relayAddress, send } from './wire.mjs';
+
+// Headless mobile-side adapter for the local validation. No OpenAI credentials.
+export function connectRelayClient({ relayUrl, room, code, credential, clientId, accountToken, observe = false }) {
+  relayAddress(relayUrl);
+  const events = new EventEmitter(), pending = new Map();
+  const socket = new WebSocket(relayUrl, { maxPayload: 64 * 1024 * 1024, perMessageDeflate: true });
+  let serial = 0, connected = false, pairedCredential = credential, pairedClientId = clientId;
+  const ready = new Promise((resolve, reject) => {
+    const timer = setTimeout(() => { reject(new Error('Relay connection timeout')); socket.terminate(); }, 7000);
+    socket.on('open', () => send(socket, observe ? { type: 'observe', room, credential, clientId, accountToken }
+      : code ? { type: 'pair', room, code, credential, clientId, accountToken } : { type: 'resume', room, credential, clientId, accountToken }));
+    socket.on('error', error => { reject(error); events.emit('diagnostic', error.message); });
+    socket.on('close', () => {
+      clearTimeout(timer); connected = false; reject(new Error('Relay connection closed'));
+      for (const request of pending.values()) { clearTimeout(request.timer); request.reject(new Error('连接断开，操作结果未确认，不自动重发')); }
+      pending.clear(); events.emit('disconnected');
+    });
+    socket.on('message', (bytes, binary) => {
+      try {
+        const message = decode(bytes, binary);
+        if (message.type === 'paired') { if (message.credential) pairedCredential = message.credential; if (message.clientId) pairedClientId = message.clientId; }
+        else if (message.type === 'observing') { clearTimeout(timer); connected = true; events.emit('observing', message); resolve({ room, credential: pairedCredential, clientId: pairedClientId }); }
+        else if (message.type === 'computer-info') events.emit('computer-info', { hostName: message.hostName });
+        else if (message.type === 'lan-candidates') events.emit('lan-candidates', message.candidates);
+        else if (message.type === 'official-computer') events.emit('official-computer', message.computer);
+        else if (message.type === 'official-computer-saved') events.emit('official-computer-saved', message.computer);
+        else if (message.type === 'announcement') events.emit('announcement', message.announcement);
+        else if (message.type === 'ready') { clearTimeout(timer); connected = true; resolve({ room, credential: pairedCredential, clientId: pairedClientId }); }
+        else if (message.type === 'data') {
+          const body = decode(message.payload, false), request = pending.get(body.id);
+          if (body.type === 'response' && request) { clearTimeout(request.timer); pending.delete(body.id); request.resolve(body); }
+          else events.emit('message', body);
+        } else throw new Error('Invalid relay message');
+      } catch (error) { reject(error); events.emit('diagnostic', error.message); socket.close(1008, 'Invalid response'); }
+    });
+  });
+  return {
+    ready, events,
+    request(path, { method = 'GET', body, timeoutMs = 5000 } = {}) {
+      if (!connected) return Promise.reject(new Error('Relay not ready'));
+      const id = ++serial;
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => { pending.delete(id); reject(new Error('请求超时，结果未确认，不自动重发')); }, timeoutMs);
+        pending.set(id, { resolve, reject, timer });
+        if (!send(socket, { type: 'data', payload: JSON.stringify({ type: 'request', id, path, method, ...(body ? { body } : {}) }) })) {
+          clearTimeout(timer); pending.delete(id); reject(new Error('Relay not connected'));
+        }
+      });
+    },
+    send(message) { if (!connected) throw new Error('Relay not ready'); return send(socket, { type: 'data', payload: JSON.stringify(message) }); },
+    routeDirect() { if (!connected) throw new Error('Relay not ready'); return send(socket, { type: 'p2p-route', direct: 1 }); },
+    recordOfficialComputer(computer) {
+      if (!connected || !observe) throw new Error('Metadata channel not ready');
+      return send(socket, { type: 'official-computer', ...computer });
+    },
+    close() { socket.terminate(); },
+  };
+}

package/dist/src/self-relay/connection-reporting.mjs

@@ -1,38 +1,38 @@
-import path from 'node:path';
-import { EventEmitter } from 'node:events';
-import { randomUUID } from 'node:crypto';
-
-const reporters = new Map();
-
-// Workstation observations only. The bounded in-memory outbox covers cloud
-// reconnects, not process exit; no polling or message payloads are involved.
-export function connectionReporting(stateRoot) {
-  let key = path.resolve(stateRoot);
-  if (process.platform === 'win32') key = key.toLowerCase();
-  if (reporters.has(key)) return reporters.get(key);
-  const active = new Map(), pending = new Map(), events = new EventEmitter();
-  function record(connection, state) {
-    const event = { ...connection, id: randomUUID(), state, at: new Date().toISOString() };
-    pending.set(event.id, event);
-    if (pending.size > 128) pending.delete(pending.keys().next().value);
-    events.emit('change', event);
-  }
-  const reporter = {
-    connected(connectionId, clientId, mode) {
-      if (active.has(connectionId)) return;
-      const connection = { connectionId, clientId, mode };
-      active.set(connectionId, connection); record(connection, 'connected');
-    },
-    disconnected(connectionId) {
-      const connection = active.get(connectionId);
-      if (!connection) return;
-      active.delete(connectionId); record(connection, 'disconnected');
-    },
-    snapshot: () => [...active.values()],
-    pending: () => [...pending.values()],
-    acknowledge: id => pending.delete(id),
-    watch(listener) { events.on('change', listener); return () => events.off('change', listener); },
-  };
-  reporters.set(key, reporter);
-  return reporter;
-}
+import path from 'node:path';
+import { EventEmitter } from 'node:events';
+import { randomUUID } from 'node:crypto';
+
+const reporters = new Map();
+
+// Workstation observations only. The bounded in-memory outbox covers cloud
+// reconnects, not process exit; no polling or message payloads are involved.
+export function connectionReporting(stateRoot) {
+  let key = path.resolve(stateRoot);
+  if (process.platform === 'win32') key = key.toLowerCase();
+  if (reporters.has(key)) return reporters.get(key);
+  const active = new Map(), pending = new Map(), events = new EventEmitter();
+  function record(connection, state) {
+    const event = { ...connection, id: randomUUID(), state, at: new Date().toISOString() };
+    pending.set(event.id, event);
+    if (pending.size > 128) pending.delete(pending.keys().next().value);
+    events.emit('change', event);
+  }
+  const reporter = {
+    connected(connectionId, clientId, mode) {
+      if (active.has(connectionId)) return;
+      const connection = { connectionId, clientId, mode };
+      active.set(connectionId, connection); record(connection, 'connected');
+    },
+    disconnected(connectionId) {
+      const connection = active.get(connectionId);
+      if (!connection) return;
+      active.delete(connectionId); record(connection, 'disconnected');
+    },
+    snapshot: () => [...active.values()],
+    pending: () => [...pending.values()],
+    acknowledge: id => pending.delete(id),
+    watch(listener) { events.on('change', listener); return () => events.off('change', listener); },
+  };
+  reporters.set(key, reporter);
+  return reporter;
+}

package/dist/src/self-relay/debug-allowlist.mjs

@@ -1,33 +1,33 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { validId } from './device-store.mjs';
-
-export function readDebugAllowlist(file) {
-  if (!file || !fs.existsSync(file)) return { version: 1, devices: [] };
-  const value = JSON.parse(fs.readFileSync(file, 'utf8'));
-  if (value.version !== 1 || !Array.isArray(value.devices) || value.devices.some(entry => !validId(entry.deviceId))) {
-    throw new Error('Invalid debug allowlist');
-  }
-  return value;
-}
-
-export function debugAllowed(allowlist, deviceId, client) {
-  return Boolean(client && allowlist.devices.some(entry => entry.deviceId === deviceId));
-}
-
-// Administrator-only file; never invoked by the relay wire protocol or Desktop CLI.
-export function updateDebugAllowlist(file, deviceId, enabled) {
-  if (!validId(deviceId)) throw new Error('Invalid debug device');
-  const value = readDebugAllowlist(file);
-  const previous = fs.existsSync(file) ? fs.statSync(file) : null;
-  value.devices = value.devices.filter(entry => entry.deviceId !== deviceId);
-  if (enabled) value.devices.push({ deviceId });
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  const temporary = `${file}.${randomUUID()}.tmp`;
-  try {
-    fs.writeFileSync(temporary, JSON.stringify(value, null, 2) + '\n', { mode: 0o640, flag: 'wx' });
-    if (previous && process.platform !== 'win32') fs.chownSync(temporary, previous.uid, previous.gid);
-    fs.renameSync(temporary, file);
-  } finally { fs.rmSync(temporary, { force: true }); }
-}
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { validId } from './device-store.mjs';
+
+export function readDebugAllowlist(file) {
+  if (!file || !fs.existsSync(file)) return { version: 1, devices: [] };
+  const value = JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (value.version !== 1 || !Array.isArray(value.devices) || value.devices.some(entry => !validId(entry.deviceId))) {
+    throw new Error('Invalid debug allowlist');
+  }
+  return value;
+}
+
+export function debugAllowed(allowlist, deviceId, client) {
+  return Boolean(client && allowlist.devices.some(entry => entry.deviceId === deviceId));
+}
+
+// Administrator-only file; never invoked by the relay wire protocol or Desktop CLI.
+export function updateDebugAllowlist(file, deviceId, enabled) {
+  if (!validId(deviceId)) throw new Error('Invalid debug device');
+  const value = readDebugAllowlist(file);
+  const previous = fs.existsSync(file) ? fs.statSync(file) : null;
+  value.devices = value.devices.filter(entry => entry.deviceId !== deviceId);
+  if (enabled) value.devices.push({ deviceId });
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temporary = `${file}.${randomUUID()}.tmp`;
+  try {
+    fs.writeFileSync(temporary, JSON.stringify(value, null, 2) + '\n', { mode: 0o640, flag: 'wx' });
+    if (previous && process.platform !== 'win32') fs.chownSync(temporary, previous.uid, previous.gid);
+    fs.renameSync(temporary, file);
+  } finally { fs.rmSync(temporary, { force: true }); }
+}

package/dist/src/self-relay/demo.mjs

@@ -6,8 +6,8 @@ import { connectBridgeRelay } from './connector.mjs';
 import { connectRelayClient } from './client.mjs';
 import { secret } from './wire.mjs';
 
-export async function startRelayDemo({ mode = 'lan-shared', pairingTtlMs, dispatch, remoteRelay, hostName = 'TEST-PC', lanCandidates = [], relayOptions = {} } = {}) {
-  if (mode !== 'lan-shared') throw new Error('Invalid demo mode');
+export async function startRelayDemo({ mode = 'lan-shared', pairingTtlMs, dispatch, remoteRelay, hostName = 'TEST-PC', lanCandidates = [], relayOptions = {} } = {}) {
+  if (mode !== 'lan-shared') throw new Error('Invalid demo mode');
   const token = secret(), calls = [];
   const bridge = http.createServer((_request, response) => { response.writeHead(404); response.end(); });
   const lan = attachLanSocket(bridge, { token, dispatch: async (request, reply) => {
@@ -17,15 +17,15 @@ export async function startRelayDemo({ mode = 'lan-shared', pairingTtlMs, dispat
     if (request.url.split('?')[0] === '/api/threads/demo/events') {
       reply.startEvents(); reply.event('update', { thread: { id: 'demo' }, simulated: true }); return;
     }
-    if (request.url === '/api/demo/stop') return reply.json(200, { stopped: true, simulated: true });
-    reply.json(404, { error: '模拟桌面服务不执行真实任务' });
+    if (request.url === '/api/demo/stop') return reply.json(200, { stopped: true, simulated: true });
+    reply.json(404, { error: '模拟桌面服务不执行真实任务' });
   } });
   await new Promise(resolve => bridge.listen(0, '127.0.0.1', resolve));
-  const relay = remoteRelay ? { ...remoteRelay, async close() {} } : await startSelfRelay({ pairingTtlMs, ...relayOptions });
+  const relay = remoteRelay ? { ...remoteRelay, async close() {} } : await startSelfRelay({ pairingTtlMs, ...relayOptions });
   const bridgeUrl = `ws://127.0.0.1:${bridge.address().port}/api/socket`;
   const identity = remoteRelay ? { id: randomUUID(), secret: secret() } : undefined;
   const clientId = randomUUID(), credential = secret();
-  const connector = connectBridgeRelay({ identity, relayUrl: relay.url, hostKey: relay.hostKey, bridgeUrl, bridgeToken: token, hostName, lanCandidates });
+  const connector = connectBridgeRelay({ identity, relayUrl: relay.url, hostKey: relay.hostKey, bridgeUrl, bridgeToken: token, hostName, lanCandidates });
   let pairing;
   try { pairing = await connector.ready; }
   catch (error) { connector.close(); await relay.close(); lan.close(); await new Promise(resolve => bridge.close(resolve)); throw error; }

package/dist/src/self-relay/device-info.mjs

@@ -1,27 +1,27 @@
-export function deviceInfo(value = {}) {
-  const info = {};
-  if (value.platform !== undefined && value.platform !== null) {
-    if (!['android', 'harmony', 'ios'].includes(value.platform)) throw new Error('Invalid mobile platform');
-    info.platform = value.platform;
-  }
-  if (value.deviceName !== undefined && value.deviceName !== null) {
-    if (typeof value.deviceName !== 'string' || value.deviceName.length > 80 || /[\u0000-\u001f\u007f]/.test(value.deviceName)) throw new Error('Invalid mobile device name');
-    if (value.deviceName.trim()) info.deviceName = value.deviceName.trim();
-  }
-  return info;
-}
-
-export function connectionInfo(client, at, info = {}) {
-  const time = Date.parse(at);
-  if (!Number.isFinite(time)) throw new Error('Invalid mobile connection time');
-  const next = deviceInfo(info);
-  if (client.lastConnectedAt && Date.parse(client.lastConnectedAt) > time) return client;
-  return { ...client, ...next, lastConnectedAt: new Date(time).toISOString() };
-}
-
-export function validConnectionInfo(client) {
-  try {
-    deviceInfo(client);
-    return client.lastConnectedAt == null || Number.isFinite(Date.parse(client.lastConnectedAt));
-  } catch { return false; }
-}
+export function deviceInfo(value = {}) {
+  const info = {};
+  if (value.platform !== undefined && value.platform !== null) {
+    if (!['android', 'harmony', 'ios'].includes(value.platform)) throw new Error('Invalid mobile platform');
+    info.platform = value.platform;
+  }
+  if (value.deviceName !== undefined && value.deviceName !== null) {
+    if (typeof value.deviceName !== 'string' || value.deviceName.length > 80 || /[\u0000-\u001f\u007f]/.test(value.deviceName)) throw new Error('Invalid mobile device name');
+    if (value.deviceName.trim()) info.deviceName = value.deviceName.trim();
+  }
+  return info;
+}
+
+export function connectionInfo(client, at, info = {}) {
+  const time = Date.parse(at);
+  if (!Number.isFinite(time)) throw new Error('Invalid mobile connection time');
+  const next = deviceInfo(info);
+  if (client.lastConnectedAt && Date.parse(client.lastConnectedAt) > time) return client;
+  return { ...client, ...next, lastConnectedAt: new Date(time).toISOString() };
+}
+
+export function validConnectionInfo(client) {
+  try {
+    deviceInfo(client);
+    return client.lastConnectedAt == null || Number.isFinite(Date.parse(client.lastConnectedAt));
+  } catch { return false; }
+}