@walkhi/code-relax 0.1.0-beta.30 → 0.1.0-beta.32

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

@@ -1,37 +1,37 @@
-import http from 'node:http';
-import { randomUUID } from 'node:crypto';
-import { attachLanSocket } from '../lan-socket-server.mjs';
-import { startSelfRelay } from './server.mjs';
-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');
-  const token = secret(), calls = [];
-  const bridge = http.createServer((_request, response) => { response.writeHead(404); response.end(); });
-  const lan = attachLanSocket(bridge, { token, dispatch: async (request, reply) => {
-    calls.push(request);
-    if (dispatch) return dispatch(request, reply);
-    if (request.url === '/api/health') return reply.json(200, { ok: true, transportMode: mode, simulated: true });
-    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: '模拟桌面服务不执行真实任务' });
-  } });
-  await new Promise(resolve => bridge.listen(0, '127.0.0.1', resolve));
-  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 });
-  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; }
-  return {
-    relay, connector, pairing, bridgeUrl, calls,
-    connect(options = {}) { return connectRelayClient({ relayUrl: relay.url, room: pairing.room, code: pairing.code, ...(remoteRelay ? { clientId, credential } : {}), ...options }); },
-    async close() { if (remoteRelay) await connector.command('revoke'); connector.close(); await relay.close(); lan.close(); await new Promise(resolve => bridge.close(resolve)); },
-  };
-}
+import http from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { attachLanSocket } from '../lan-socket-server.mjs';
+import { startSelfRelay } from './server.mjs';
+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');
+  const token = secret(), calls = [];
+  const bridge = http.createServer((_request, response) => { response.writeHead(404); response.end(); });
+  const lan = attachLanSocket(bridge, { token, dispatch: async (request, reply) => {
+    calls.push(request);
+    if (dispatch) return dispatch(request, reply);
+    if (request.url === '/api/health') return reply.json(200, { ok: true, transportMode: mode, simulated: true });
+    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: '模拟桌面服务不执行真实任务' });
+  } });
+  await new Promise(resolve => bridge.listen(0, '127.0.0.1', resolve));
+  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 });
+  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; }
+  return {
+    relay, connector, pairing, bridgeUrl, calls,
+    connect(options = {}) { return connectRelayClient({ relayUrl: relay.url, room: pairing.room, code: pairing.code, ...(remoteRelay ? { clientId, credential } : {}), ...options }); },
+    async close() { if (remoteRelay) await connector.command('revoke'); connector.close(); await relay.close(); lan.close(); await new Promise(resolve => bridge.close(resolve)); },
+  };
+}

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

@@ -0,0 +1,27 @@
+export function deviceInfo(value = {}) {
+  const info = {};
+  if (value.platform !== undefined && value.platform !== null) {
+    if (!['android', 'harmony'].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; }
+}

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

@@ -1,84 +1,92 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { randomUUID } from 'node:crypto';
-
-export const validId = value => typeof value === 'string' && /^[\w-]{16,128}$/.test(value);
-const hash = value => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
-export function deviceStore(file, { initialize = false } = {}) {
-  let devices = new Map();
-  function validate(record) {
-    if (!validId(record.id) || !hash(record.hostHash) || !['active', 'revoked'].includes(record.status) ||
-        !Number.isSafeInteger(record.revision) || record.revision < 0 ||
-        !Array.isArray(record.clients) || record.clients.length > 16 ||
-        record.clients.some(client => !validId(client.id) || !hash(client.hash) ||
-          !Number.isFinite(Date.parse(client.createdAt)) || !Number.isFinite(Date.parse(client.updatedAt))) ||
-        new Set(record.clients.map(client => client.id)).size !== record.clients.length ||
-        !Number.isFinite(Date.parse(record.createdAt)) || !Number.isFinite(Date.parse(record.updatedAt)) ||
-        !validOfficialComputer(record.officialComputer)) {
-      throw new Error('Invalid relay device record');
-    }
-  }
-  function write(next) {
-    if (!file) return;
-    const temporary = `${file}.${randomUUID()}.tmp`;
-    let fd;
-    try {
-      fd = fs.openSync(temporary, 'wx', 0o600);
-      fs.writeFileSync(fd, JSON.stringify({ version: 4, devices: [...next.values()] }));
-      fs.fsyncSync(fd); fs.closeSync(fd); fd = undefined;
-      fs.renameSync(temporary, file);
-      if (process.platform !== 'win32') {
-        const directory = fs.openSync(path.dirname(file), 'r');
-        try { fs.fsyncSync(directory); } finally { fs.closeSync(directory); }
-      }
-    } finally {
-      if (fd !== undefined) fs.closeSync(fd);
-      fs.rmSync(temporary, { force: true });
-    }
-  }
-  if (file) {
-    if (!fs.existsSync(file)) {
-      if (!initialize) throw new Error('Device store missing; explicit --init-state required for first installation');
-      fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 }); write(devices);
-    } else {
-      if (initialize) throw new Error('Device store already exists; initialization refused');
-      const saved = JSON.parse(fs.readFileSync(file, 'utf8'));
-      if (![2, 3, 4].includes(saved.version) || !Array.isArray(saved.devices)) throw new Error('Invalid relay device store version');
-      for (const source of saved.devices) {
-        const record = saved.version === 2 ? {
-          ...source,
-          clients: source.clientHash == null ? [] : [{
-            id: source.clientId,
-            hash: source.clientHash,
-            createdAt: source.updatedAt,
-            updatedAt: source.updatedAt,
-          }],
-        } : source;
-        delete record.clientHash; delete record.clientId;
-        validate(record);
-        if (devices.has(record.id)) throw new Error('Duplicate relay device identity');
-        devices.set(record.id, record);
-      }
-    }
-  }
-  return {
-    entries: () => [...devices.values()],
-    // Synchronous single-writer commit: publish only after durable replacement.
-    save(record) {
-      validate(record);
-      const next = new Map(devices); next.set(record.id, record); write(next); devices = next;
-    },
-  };
-}
-
-function validOfficialComputer(value) {
-  if (value === undefined) return true;
-  return value && typeof value === 'object' && plain(value.environmentId, 256, false) &&
-    plain(value.name, 80, true) && plain(value.hostname, 80, true) &&
-    Number.isFinite(Date.parse(value.updatedAt));
-}
-
-function plain(value, limit, empty) {
-  return typeof value === 'string' && (empty || value.trim().length > 0) &&
-    value.trim().length <= limit && !/[\u0000-\u001f\u007f]/.test(value);
-}
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { connectionInfo, validConnectionInfo } from './device-info.mjs';
+
+export const validId = value => typeof value === 'string' && /^[\w-]{16,128}$/.test(value);
+const hash = value => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
+export function deviceStore(file, { initialize = false } = {}) {
+  let devices = new Map();
+  function validate(record) {
+    if (!validId(record.id) || !hash(record.hostHash) || !['active', 'revoked'].includes(record.status) ||
+        !Number.isSafeInteger(record.revision) || record.revision < 0 ||
+        !Array.isArray(record.clients) ||
+        record.clients.some(client => !validId(client.id) || !hash(client.hash) || !validConnectionInfo(client) ||
+          !Number.isFinite(Date.parse(client.createdAt)) || !Number.isFinite(Date.parse(client.updatedAt))) ||
+        new Set(record.clients.map(client => client.id)).size !== record.clients.length ||
+        !Number.isFinite(Date.parse(record.createdAt)) || !Number.isFinite(Date.parse(record.updatedAt)) ||
+        !validOfficialComputer(record.officialComputer)) {
+      throw new Error('Invalid relay device record');
+    }
+  }
+  function write(next) {
+    if (!file) return;
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    let fd;
+    try {
+      fd = fs.openSync(temporary, 'wx', 0o600);
+      fs.writeFileSync(fd, JSON.stringify({ version: 4, devices: [...next.values()] }));
+      fs.fsyncSync(fd); fs.closeSync(fd); fd = undefined;
+      fs.renameSync(temporary, file);
+      if (process.platform !== 'win32') {
+        const directory = fs.openSync(path.dirname(file), 'r');
+        try { fs.fsyncSync(directory); } finally { fs.closeSync(directory); }
+      }
+    } finally {
+      if (fd !== undefined) fs.closeSync(fd);
+      fs.rmSync(temporary, { force: true });
+    }
+  }
+  if (file) {
+    if (!fs.existsSync(file)) {
+      if (!initialize) throw new Error('Device store missing; explicit --init-state required for first installation');
+      fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 }); write(devices);
+    } else {
+      if (initialize) throw new Error('Device store already exists; initialization refused');
+      const saved = JSON.parse(fs.readFileSync(file, 'utf8'));
+      if (![2, 3, 4].includes(saved.version) || !Array.isArray(saved.devices)) throw new Error('Invalid relay device store version');
+      for (const source of saved.devices) {
+        const record = saved.version === 2 ? {
+          ...source,
+          clients: source.clientHash == null ? [] : [{
+            id: source.clientId,
+            hash: source.clientHash,
+            createdAt: source.updatedAt,
+            updatedAt: source.updatedAt,
+          }],
+        } : source;
+        delete record.clientHash; delete record.clientId;
+        validate(record);
+        if (devices.has(record.id)) throw new Error('Duplicate relay device identity');
+        devices.set(record.id, record);
+      }
+    }
+  }
+  return {
+    entries: () => [...devices.values()],
+    recordConnection(id, clientId, at, info) {
+      const record = devices.get(id), client = record?.clients.find(item => item.id === clientId);
+      if (!client) return;
+      const updated = connectionInfo(client, at, info);
+      this.save({ ...record, clients: record.clients.map(item => item.id === clientId ? updated : item) });
+      return updated;
+    },
+    // Synchronous single-writer commit: publish only after durable replacement.
+    save(record) {
+      validate(record);
+      const next = new Map(devices); next.set(record.id, record); write(next); devices = next;
+    },
+  };
+}
+
+function validOfficialComputer(value) {
+  if (value === undefined) return true;
+  return value && typeof value === 'object' && plain(value.environmentId, 256, false) &&
+    plain(value.name, 80, true) && plain(value.hostname, 80, true) &&
+    Number.isFinite(Date.parse(value.updatedAt));
+}
+
+function plain(value, limit, empty) {
+  return typeof value === 'string' && (empty || value.trim().length > 0) &&
+    value.trim().length <= limit && !/[\u0000-\u001f\u007f]/.test(value);
+}

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

@@ -1,54 +1,54 @@
-const MAX_BATCH = 200;
-
-export function relayDiagnostics(pool, onError = () => {}) {
-  let tail = Promise.resolve();
-  function validSource(source) {
-    if (!/^[a-z-]{1,32}$/.test(source)) throw new Error('Invalid diagnostic source');
-    return source;
-  }
-  function serialize(action) {
-    const result = tail.then(action);
-    tail = result.catch(error => { onError(error); });
-    return result;
-  }
-  function record(source, event, detail) {
-    validSource(source);
-    if (!/^[a-z-]{1,32}$/.test(event) || !/^[a-z0-9=;.-]{1,64}$/.test(detail)) throw new Error('Invalid diagnostic event');
-    return serialize(async () => {
-      await pool.execute('INSERT INTO relay_diagnostics (created_at,source,event,detail) VALUES (UTC_TIMESTAMP(3),?,?,?)', [source, event, detail]);
-      await pool.execute('DELETE FROM relay_diagnostics WHERE created_at < UTC_TIMESTAMP(3) - INTERVAL 1 DAY');
-    }).catch(() => {});
-  }
-  async function read(source) {
-    validSource(source);
-    return serialize(async () => {
-      const [rows] = await pool.execute(`SELECT id,created_at,source,event,detail FROM relay_diagnostics
-        WHERE source=? ORDER BY id LIMIT ${MAX_BATCH + 1}`, [source]);
-      return { rows: rows.slice(0, MAX_BATCH), hasMore: rows.length > MAX_BATCH };
-    });
-  }
-  async function clear(source) {
-    validSource(source);
-    return serialize(async () => {
-      const [result] = await pool.execute('DELETE FROM relay_diagnostics WHERE source=?', [source]);
-      return { cleared: result.affectedRows };
-    });
-  }
-  async function drain(source) {
-    validSource(source);
-    return serialize(async () => {
-      const db = await pool.getConnection();
-      try {
-        await db.beginTransaction();
-        const [rows] = await db.execute(`SELECT id,created_at,source,event,detail FROM relay_diagnostics
-          WHERE source=? ORDER BY id LIMIT ${MAX_BATCH + 1} FOR UPDATE`, [source]);
-        const selected = rows.slice(0, MAX_BATCH);
-        if (selected.length) await db.execute('DELETE FROM relay_diagnostics WHERE source=? AND id <= ?', [source, selected.at(-1).id]);
-        await db.commit();
-        return { rows: selected, hasMore: rows.length > MAX_BATCH };
-      } catch (error) { await db.rollback(); throw error; }
-      finally { db.release(); }
-    });
-  }
-  return { record, read, clear, drain };
-}
+const MAX_BATCH = 200;
+
+export function relayDiagnostics(pool, onError = () => {}) {
+  let tail = Promise.resolve();
+  function validSource(source) {
+    if (!/^[a-z-]{1,32}$/.test(source)) throw new Error('Invalid diagnostic source');
+    return source;
+  }
+  function serialize(action) {
+    const result = tail.then(action);
+    tail = result.catch(error => { onError(error); });
+    return result;
+  }
+  function record(source, event, detail) {
+    validSource(source);
+    if (!/^[a-z-]{1,32}$/.test(event) || !/^[a-z0-9=;.-]{1,64}$/.test(detail)) throw new Error('Invalid diagnostic event');
+    return serialize(async () => {
+      await pool.execute('INSERT INTO relay_diagnostics (created_at,source,event,detail) VALUES (UTC_TIMESTAMP(3),?,?,?)', [source, event, detail]);
+      await pool.execute('DELETE FROM relay_diagnostics WHERE created_at < UTC_TIMESTAMP(3) - INTERVAL 1 DAY');
+    }).catch(() => {});
+  }
+  async function read(source) {
+    validSource(source);
+    return serialize(async () => {
+      const [rows] = await pool.execute(`SELECT id,created_at,source,event,detail FROM relay_diagnostics
+        WHERE source=? ORDER BY id LIMIT ${MAX_BATCH + 1}`, [source]);
+      return { rows: rows.slice(0, MAX_BATCH), hasMore: rows.length > MAX_BATCH };
+    });
+  }
+  async function clear(source) {
+    validSource(source);
+    return serialize(async () => {
+      const [result] = await pool.execute('DELETE FROM relay_diagnostics WHERE source=?', [source]);
+      return { cleared: result.affectedRows };
+    });
+  }
+  async function drain(source) {
+    validSource(source);
+    return serialize(async () => {
+      const db = await pool.getConnection();
+      try {
+        await db.beginTransaction();
+        const [rows] = await db.execute(`SELECT id,created_at,source,event,detail FROM relay_diagnostics
+          WHERE source=? ORDER BY id LIMIT ${MAX_BATCH + 1} FOR UPDATE`, [source]);
+        const selected = rows.slice(0, MAX_BATCH);
+        if (selected.length) await db.execute('DELETE FROM relay_diagnostics WHERE source=? AND id <= ?', [source, selected.at(-1).id]);
+        await db.commit();
+        return { rows: selected, hasMore: rows.length > MAX_BATCH };
+      } catch (error) { await db.rollback(); throw error; }
+      finally { db.release(); }
+    });
+  }
+  return { record, read, clear, drain };
+}