@walkhi/code-relax 0.1.0-beta.9 → 0.1.0-beta.91

package/dist/src/self-relay/mysql-state.mjs

@@ -0,0 +1,118 @@
+import fs from 'node:fs';
+import { createHash } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import mysql from 'mysql2/promise';
+import { deviceStore } from './device-store.mjs';
+import { relayAdminState } from './admin-state.mjs';
+import { relaySchemaVersions } from '../../database/versions.mjs';
+import { connectionInfo } from './device-info.mjs';
+
+const sqlTime = value => value.replace('T', ' ').replace(/Z$/, '');
+const isoTime = value => value.replace(' ', 'T') + 'Z';
+
+export async function openRelayMysql(configFile, initialMaxRelaySessions) {
+  const config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+  if (!config.database || !config.user || !config.password || !(config.socketPath || config.host)) {
+    throw new Error('Incomplete relay MySQL configuration');
+  }
+  const pool = mysql.createPool({ ...config, waitForConnections: true, connectionLimit: 4,
+    namedPlaceholders: false, dateStrings: true, timezone: 'Z', multipleStatements: false });
+  try {
+    const [versions] = await pool.query('SELECT version, sha256 FROM schema_migrations');
+    const knownVersions = relaySchemaVersions;
+    if (!versions.some(row => row.version === knownVersions[0]) || versions.length > knownVersions.length) throw new Error('Unexpected relay database schema');
+    for (const row of versions) {
+      if (!knownVersions.includes(row.version)) throw new Error('Unexpected relay database schema');
+      const source = fs.readFileSync(fileURLToPath(new URL(`../../database/${row.version}.sql`, import.meta.url)));
+      if (row.sha256 !== createHash('sha256').update(source).digest('hex')) throw new Error(`Unexpected relay database schema: ${row.version}`);
+    }
+    const [computers] = await pool.query('SELECT id, host_hash, status, revision, created_at, updated_at FROM computers');
+    const [clients] = await pool.query('SELECT computer_id, client_id, credential_hash, created_at, updated_at, last_connected_at, platform, device_name FROM mobile_authorizations ORDER BY created_at');
+    const [official] = await pool.query('SELECT computer_id, environment_id, name, hostname, updated_at FROM official_computers');
+    const records = new Map(computers.map(row => [row.id, { id: row.id, hostHash: row.host_hash, status: row.status,
+      revision: Number(row.revision), createdAt: isoTime(row.created_at), updatedAt: isoTime(row.updated_at), clients: [] }]));
+    for (const row of clients) {
+      const record = records.get(row.computer_id);
+      if (!record) throw new Error('Orphan mobile authorization');
+      record.clients.push({ id: row.client_id, hash: row.credential_hash,
+        createdAt: isoTime(row.created_at), updatedAt: isoTime(row.updated_at),
+        ...(row.last_connected_at ? { lastConnectedAt: isoTime(row.last_connected_at) } : {}),
+        ...(row.platform ? { platform: row.platform } : {}), ...(row.device_name ? { deviceName: row.device_name } : {}) });
+    }
+    for (const row of official) {
+      const record = records.get(row.computer_id);
+      if (!record) throw new Error('Orphan official computer');
+      record.officialComputer = { environmentId: row.environment_id, name: row.name,
+        hostname: row.hostname, updatedAt: isoTime(row.updated_at) };
+    }
+    const validator = deviceStore();
+    for (const record of records.values()) validator.save(record);
+
+    const [settings] = await pool.query('SELECT max_relay_sessions FROM relay_settings WHERE id = 1');
+    if (settings.length !== 1) throw new Error('Missing relay settings');
+    const [rows] = await pool.query('SELECT id, title, message, status, created_at, updated_at, published_at FROM announcements ORDER BY created_at DESC');
+    const announcements = rows.map(row => ({ id: row.id, title: row.title, message: row.message, status: row.status,
+      createdAt: isoTime(row.created_at), updatedAt: isoTime(row.updated_at),
+      publishedAt: row.published_at ? isoTime(row.published_at) : null }));
+    const active = announcements.find(item => item.status === 'active');
+    const initial = { version: 3, maxRelaySessions: settings[0].max_relay_sessions, announcements,
+      announcement: active ? { id: active.id, title: active.title, message: active.message, publishedAt: active.publishedAt } : null };
+    const admin = relayAdminState(undefined, initialMaxRelaySessions, { initial, persist: async next => {
+      const connection = await pool.getConnection();
+      try {
+        await connection.beginTransaction();
+        await connection.execute('UPDATE relay_settings SET max_relay_sessions = ?, updated_at = UTC_TIMESTAMP(3) WHERE id = 1', [next.maxRelaySessions]);
+        await connection.query('DELETE FROM announcements');
+        for (const item of next.announcements) await connection.execute(
+          'INSERT INTO announcements (id,title,message,status,created_at,updated_at,published_at) VALUES (?,?,?,?,?,?,?)',
+          [item.id, item.title, item.message, item.status, sqlTime(item.createdAt), sqlTime(item.updatedAt),
+            item.publishedAt ? sqlTime(item.publishedAt) : null]);
+        await connection.commit();
+      } catch (error) { await connection.rollback(); throw error; }
+      finally { connection.release(); }
+    } });
+    return {
+      pool,
+      schemaVersions: versions.map(row => row.version),
+      devices: {
+        entries: () => [...records.values()],
+        async recordConnection(id, clientId, at, info) {
+          const record = records.get(id), client = record?.clients.find(item => item.id === clientId);
+          if (!client) return;
+          const updated = connectionInfo(client, at, info);
+          await pool.execute('UPDATE mobile_authorizations SET last_connected_at=?,platform=?,device_name=? WHERE computer_id=? AND client_id=?',
+            [sqlTime(updated.lastConnectedAt), updated.platform || null, updated.deviceName || null, id, clientId]);
+          records.set(id, { ...record, clients: record.clients.map(item => item.id === clientId ? updated : item) });
+          return updated;
+        },
+        async save(record) {
+          validator.save(record);
+          const connection = await pool.getConnection();
+          try {
+            await connection.beginTransaction();
+            await connection.execute(`INSERT INTO computers (id,host_hash,status,revision,created_at,updated_at)
+              VALUES (?,?,?,?,?,?) ON DUPLICATE KEY UPDATE host_hash=VALUES(host_hash),status=VALUES(status),
+              revision=VALUES(revision),updated_at=VALUES(updated_at)`,
+            [record.id, record.hostHash, record.status, record.revision, sqlTime(record.createdAt), sqlTime(record.updatedAt)]);
+            await connection.execute('DELETE FROM mobile_authorizations WHERE computer_id = ?', [record.id]);
+            for (const client of record.clients) await connection.execute(
+              'INSERT INTO mobile_authorizations (computer_id,client_id,credential_hash,created_at,updated_at,last_connected_at,platform,device_name) VALUES (?,?,?,?,?,?,?,?)',
+              [record.id, client.id, client.hash, sqlTime(client.createdAt), sqlTime(client.updatedAt),
+                client.lastConnectedAt ? sqlTime(client.lastConnectedAt) : null, client.platform || null, client.deviceName || null]);
+            if (record.officialComputer) {
+              const item = record.officialComputer;
+              await connection.execute(`INSERT INTO official_computers (computer_id,environment_id,name,hostname,updated_at)
+                VALUES (?,?,?,?,?) ON DUPLICATE KEY UPDATE environment_id=VALUES(environment_id),name=VALUES(name),
+                hostname=VALUES(hostname),updated_at=VALUES(updated_at)`,
+              [record.id, item.environmentId, item.name, item.hostname, sqlTime(item.updatedAt)]);
+            }
+            await connection.commit(); records.set(record.id, record);
+          } catch (error) { await connection.rollback(); throw error; }
+          finally { connection.release(); }
+        },
+      },
+      admin,
+      close: () => pool.end(),
+    };
+  } catch (error) { await pool.end(); throw error; }
+}

package/dist/src/self-relay/p2p-probe.mjs

@@ -1,123 +1,168 @@
-import { randomUUID } from 'node:crypto';
-import P2pDiagnostics from '../../shared/p2p-diagnostics.cjs';
-import P2pDataFramer from '../../shared/p2p-data-channel.cjs';
-
-const PROBE_UDP_PORT_RANGE = Object.freeze({ begin: 42000, end: 42031 });
-const HIGH_WATER = 1024 * 1024;
-const LOW_WATER = 512 * 1024;
-const MAX_QUEUED = 16 * 1024 * 1024;
-
-export async function createP2pProbe({ signal, report = () => {}, onData = () => {}, iceServers = [] }) {
-  if (!validProbeIceServers(iceServers)) throw new Error('Invalid probe STUN configuration');
-  const { default: rtc } = await import('node-datachannel');
-  const peer = new rtc.PeerConnection('code-relax-probe', {
-    iceServers,
-    maxMessageSize: 65536,
-    portRangeBegin: PROBE_UDP_PORT_RANGE.begin,
-    portRangeEnd: PROBE_UDP_PORT_RANGE.end
-  });
-  const diagnostic = new P2pDiagnostics();
-  const framer = new P2pDataFramer();
-  const dataPrefix = randomUUID().replaceAll('-', '');
-  let channel, closed = false, answered = false, candidates = [], verified = false, remoteDirect = false;
-  let pingReceived = false, pongReceived = false, dataSerial = 0, queuedBytes = 0;
-  const outbound = [];
-  const nonce = randomUUID();
-  const timer = setTimeout(() => finish(verified ? 'closed' : 'timeout'), 15000);
-  function finish(state) {
-    if (closed) return;
-    closed = true; clearTimeout(timer); candidates = []; queuedBytes = 0; outbound.length = 0; framer.reset();
-    const summary = diagnostic.snapshot(state);
-    channel?.close(); peer.close(); report(state, summary);
-  }
-  function verify() {
-    if (verified || !pingReceived || !pongReceived) return;
-    verified = true; clearTimeout(timer);
-    report(remoteDirect ? 'direct' : 'verified', diagnostic.snapshot('verified'));
-    pump();
-  }
-  function pump() {
-    if (!verified || !remoteDirect || closed || !channel?.isOpen()) return;
-    try {
-      while (outbound.length && channel.bufferedAmount() < HIGH_WATER) {
-        const item = outbound[0], frame = framer.frame(item);
-        if (!channel.sendMessage(frame)) return;
-        if (framer.commit(item)) { outbound.shift(); queuedBytes -= item.bytes; }
-      }
-    } catch { diagnostic.error = 'channel'; finish('failed'); }
-  }
-  function sendData(payload) {
-    if (!verified || !remoteDirect || closed || !channel?.isOpen()) return false;
-    let item;
-    try { item = framer.create(payload, `${dataPrefix}-${++dataSerial}`); }
-    catch { return false; }
-    if (queuedBytes + item.bytes > MAX_QUEUED) return false;
-    outbound.push(item); queuedBytes += item.bytes; pump(); return true;
-  }
-  peer.onIceStateChange(state => { if (!closed) diagnostic.ice = state; });
-  peer.onGatheringStateChange(state => { if (!closed) diagnostic.gathering = state; });
-  peer.onStateChange(state => { if (!closed && (state === 'failed' || state === 'closed')) { diagnostic.error = 'peer'; finish('failed'); } });
-  peer.onLocalDescription((sdp, type) => { if (!closed) { diagnostic.offer = type === 'offer'; signal({ kind: type, sdp, iceServers, direct: 1 }); } });
-  peer.onLocalCandidate((candidate, mid) => { if (!closed) { diagnostic.candidate('local', candidate); signal({ kind: 'candidate', candidate, mid }); } });
-  channel = peer.createDataChannel('code-relax-probe-v1');
-  channel.setBufferedAmountLowThreshold(LOW_WATER);
-  channel.onBufferedAmountLow(pump);
-  channel.onOpen(() => { if (!closed) { diagnostic.open = true; channel.sendMessage(JSON.stringify({ type: 'ping', nonce })); } });
-  channel.onError(() => { if (!closed) diagnostic.error = 'channel'; finish('failed'); });
-  channel.onClosed(() => finish('closed'));
-  channel.onMessage(value => {
-    try {
-      if (closed || typeof value !== 'string' || value.length > 65536) throw new Error('Invalid P2P frame');
-      const message = JSON.parse(value);
-      const data = framer.accept(message);
-      if (data.handled) {
-        if (!verified || !remoteDirect) throw new Error('P2P transport not verified');
-        if (data.complete) onData(data.payload);
-        return;
-      }
-      if (message.type === 'ping' && /^[\w-]{16,128}$/.test(message.nonce)) {
-        diagnostic.ping = true; pingReceived = true;
-        channel.sendMessage(JSON.stringify({ type: 'pong', nonce: message.nonce }));
-      } else if (message.type === 'pong' && message.nonce === nonce) {
-        diagnostic.pong = true; pongReceived = true;
-      } else throw new Error('Invalid P2P response');
-      verify();
-    } catch { diagnostic.error = 'frame'; finish('failed'); }
-  });
-  return {
-    receive(message) {
-      if (closed) return;
-      if (message.kind === 'answer' && !answered) {
-        try { peer.setRemoteDescription(message.sdp, 'answer'); }
-        catch { diagnostic.error = 'description'; finish('failed'); return; }
-        answered = true; remoteDirect = message.direct === 1; diagnostic.answer = true;
-        for (const item of candidates) peer.addRemoteCandidate(item.candidate, item.mid);
-        candidates = [];
-      } else if (message.kind === 'candidate') {
-        diagnostic.candidate('remote', message.candidate);
-        if (answered) peer.addRemoteCandidate(message.candidate, message.mid);
-        else if (candidates.length < 64) candidates.push(message);
-        else finish('failed');
-      } else if (message.kind === 'close') finish('closed');
-      else finish('failed');
-    },
-    send: sendData,
-    close() { finish('closed'); }
-  };
-}
-
-export function validProbeSignal(value) {
-  if (!value || value.version !== 1 || !/^[\w-]{16,128}$/.test(value.probeId || '')) return false;
-  if (['start', 'close'].includes(value.kind)) return true;
-  if (['offer', 'answer'].includes(value.kind)) return typeof value.sdp === 'string' && value.sdp.length <= 65536 &&
-    (value.direct === undefined || value.direct === 1) &&
-    (value.iceServers === undefined || validProbeIceServers(value.iceServers));
-  if (value.kind === 'candidate') return typeof value.candidate === 'string' && value.candidate.length <= 2048 &&
-    typeof value.mid === 'string' && value.mid.length <= 64;
-  return false;
-}
-
-export function validProbeIceServers(value) {
-  return Array.isArray(value) && value.length <= 4 && value.every(item =>
-    typeof item === 'string' && /^stun:[a-zA-Z0-9.-]+:[0-9]{1,5}$/.test(item) && Number(item.split(':').at(-1)) <= 65535);
-}
+import { randomUUID } from 'node:crypto';
+import P2pDiagnostics from '../../shared/p2p-diagnostics.cjs';
+import P2pDataFramer from '../../shared/p2p-data-channel.cjs';
+import FileChannel from '../../shared/p2p-file-channel.cjs';
+import IcePolicy from '../../shared/p2p-ice-policy.cjs';
+
+const PROBE_UDP_PORT_RANGE = Object.freeze({ begin: 42000, end: 42031 });
+const HIGH_WATER = 1024 * 1024;
+const LOW_WATER = 512 * 1024;
+const MAX_QUEUED = 16 * 1024 * 1024;
+
+export async function createP2pProbe({ signal, report = () => {}, onData = () => {}, onFileChannel, iceServers = [], purpose = '' }) {
+  if (!validProbeIceServers(iceServers)) throw new Error('Invalid probe STUN configuration');
+  const { default: rtc } = await import('node-datachannel');
+  const peer = new rtc.PeerConnection('code-relax-probe', {
+    iceServers,
+    maxMessageSize: 65536,
+    portRangeBegin: PROBE_UDP_PORT_RANGE.begin,
+    portRangeEnd: PROBE_UDP_PORT_RANGE.end
+  });
+  const diagnostic = new P2pDiagnostics();
+  const framer = new P2pDataFramer();
+  const dataPrefix = randomUUID().replaceAll('-', '');
+  let channel, closed = false, answered = false, candidates = [], verified = false, remoteDirect = false;
+  let pingReceived = false, pongReceived = false, dataSerial = 0, queuedBytes = 0;
+  const outbound = [];
+  const files = new Map();
+  const nonce = randomUUID();
+  const idle = new P2pDataFramer.IdleWatch(message => {
+    channel.sendMessage(JSON.stringify(message));
+  }, () => finish('idle-timeout'));
+  const timer = setTimeout(() => finish(verified ? 'closed' : 'timeout'), 15000);
+  function finish(state) {
+    if (closed) return;
+    closed = true; clearTimeout(timer); idle.close(); candidates = []; queuedBytes = 0; outbound.length = 0; framer.reset();
+    for (const socket of files.values()) socket.close(1011);
+    files.clear();
+    const summary = diagnostic.snapshot(state);
+    channel?.close(); peer.close(); report(state, summary);
+    signal({ kind: 'close' });
+  }
+  function verify() {
+    if (verified || !pingReceived || !pongReceived) return;
+    const pair = peer.getSelectedCandidatePair();
+    if (!pair || !IcePolicy.pair(pair.local.type, pair.remote.type)) { diagnostic.error = 'ice-policy'; finish('failed'); return; }
+    verified = true; clearTimeout(timer);
+    if (remoteDirect) idle.received();
+    report(remoteDirect ? 'direct' : 'verified', diagnostic.snapshot('verified'));
+    pump();
+    for (const raw of files.keys()) activateFile(raw);
+  }
+  function activateFile(raw) {
+    const socket = files.get(raw);
+    if (!socket || socket.readyState !== 0 || !raw.isOpen() || !verified || !remoteDirect || closed) return;
+    socket.opened();
+    raw.sendMessage('{"type":"rtc-file-ready"}');
+  }
+  peer.onDataChannel(raw => {
+    if (closed || purpose !== 'file' || !onFileChannel || raw.getLabel() !== 'code-relax-file-v1' || files.size >= 4) { raw.close(); return; }
+    const socket = new FileChannel({ buffered: () => raw.bufferedAmount(), maxMessageSize: () => peer.maxMessageSize(),
+      send: value => typeof value === 'string' ? raw.sendMessage(value) : raw.sendMessageBinary(value), close: () => raw.close(), received: () => idle.received() });
+    files.set(raw, socket);
+    socket.addEventListener('close', () => files.delete(raw));
+    try { onFileChannel(socket); }
+    catch { socket.close(1011); return; }
+    raw.setBufferedAmountLowThreshold(128 * 1024);
+    raw.onBufferedAmountLow(() => socket.pump());
+    raw.onOpen(() => activateFile(raw));
+    raw.onClosed(() => socket.close(1011)); raw.onError(() => socket.close(1011));
+    raw.onMessage(value => {
+      if (!verified || !remoteDirect || closed || socket.readyState !== 1) { socket.close(1008); return; }
+      socket.receive(value);
+    });
+    activateFile(raw);
+  });
+  function pump() {
+    if (!verified || !remoteDirect || closed || !channel?.isOpen()) return;
+    try {
+      while (outbound.length && channel.bufferedAmount() < HIGH_WATER) {
+        const item = outbound[0], frame = framer.frame(item);
+        // false means accepted into libdatachannel's buffer, not rejected. Never replay it.
+        channel.sendMessage(frame);
+        if (framer.commit(item)) { outbound.shift(); queuedBytes -= item.bytes; }
+      }
+    } catch { diagnostic.error = 'channel'; finish('failed'); }
+  }
+  function sendData(payload) {
+    if (!verified || !remoteDirect || closed || purpose === 'file' || !channel?.isOpen()) return false;
+    let item;
+    try { item = framer.create(payload, `${dataPrefix}-${++dataSerial}`); }
+    catch { return false; }
+    if (queuedBytes + item.bytes > MAX_QUEUED) return false;
+    outbound.push(item); queuedBytes += item.bytes; pump(); return true;
+  }
+  peer.onIceStateChange(state => { if (!closed) diagnostic.ice = state; });
+  peer.onGatheringStateChange(state => { if (!closed) diagnostic.gathering = state; });
+  peer.onStateChange(state => { if (!closed && (state === 'failed' || state === 'closed')) { diagnostic.error = 'peer'; finish('failed'); } });
+  peer.onLocalDescription((sdp, type) => { if (!closed) { diagnostic.offer = type === 'offer'; signal({ kind: type, sdp, iceServers, direct: 1 }); } });
+  peer.onLocalCandidate((candidate, mid) => {
+    if (closed) return;
+    if (!IcePolicy.candidate(candidate)) { diagnostic.error = 'ice-policy'; finish('failed'); return; }
+    diagnostic.candidate('local', candidate); signal({ kind: 'candidate', candidate, mid });
+  });
+  channel = peer.createDataChannel('code-relax-probe-v1');
+  channel.setBufferedAmountLowThreshold(LOW_WATER);
+  channel.onBufferedAmountLow(pump);
+  channel.onOpen(() => { if (!closed) { diagnostic.open = true; channel.sendMessage(JSON.stringify({ type: 'ping', nonce })); } });
+  channel.onError(() => { if (!closed) diagnostic.error = 'channel'; finish('failed'); });
+  channel.onClosed(() => finish('closed'));
+  channel.onMessage(value => {
+    try {
+      if (closed || typeof value !== 'string' || value.length > 65536) throw new Error('Invalid P2P frame');
+      const message = JSON.parse(value);
+      if (verified && remoteDirect && idle.accept(message)) return;
+      const data = framer.accept(message);
+      if (data.handled) {
+        if (!verified || !remoteDirect || purpose === 'file') throw new Error('P2P transport not verified');
+        idle.received();
+        if (data.complete) onData(data.payload);
+        return;
+      }
+      if (message.type === 'ping' && /^[\w-]{16,128}$/.test(message.nonce)) {
+        diagnostic.ping = true; pingReceived = true;
+        channel.sendMessage(JSON.stringify({ type: 'pong', nonce: message.nonce }));
+      } else if (message.type === 'pong' && message.nonce === nonce) {
+        diagnostic.pong = true; pongReceived = true;
+      } else throw new Error('Invalid P2P response');
+      verify();
+    } catch { diagnostic.error = 'frame'; finish('failed'); }
+  });
+  return {
+    receive(message) {
+      if (closed) return;
+      if (message.kind === 'answer' && !answered) {
+        if (!IcePolicy.sdp(message.sdp)) { diagnostic.error = 'ice-policy'; finish('failed'); return; }
+        try { peer.setRemoteDescription(message.sdp, 'answer'); }
+        catch { diagnostic.error = 'description'; finish('failed'); return; }
+        answered = true; remoteDirect = message.direct === 1; diagnostic.answer = true;
+        for (const item of candidates) peer.addRemoteCandidate(item.candidate, item.mid);
+        candidates = [];
+      } else if (message.kind === 'candidate') {
+        if (!IcePolicy.candidate(message.candidate)) { diagnostic.error = 'ice-policy'; finish('failed'); return; }
+        diagnostic.candidate('remote', message.candidate);
+        if (answered) peer.addRemoteCandidate(message.candidate, message.mid);
+        else if (candidates.length < 64) candidates.push(message);
+        else finish('failed');
+      } else if (message.kind === 'close') finish('closed');
+      else finish('failed');
+    },
+    send: sendData,
+    close() { finish('closed'); }
+  };
+}
+
+export function validProbeSignal(value) {
+  if (!value || value.version !== 1 || !/^[\w-]{16,128}$/.test(value.probeId || '')) return false;
+  if (['start', 'close'].includes(value.kind)) return true;
+  if (['offer', 'answer'].includes(value.kind)) return IcePolicy.sdp(value.sdp) &&
+    (value.direct === undefined || value.direct === 0 || value.direct === 1) &&
+    (value.iceServers === undefined || validProbeIceServers(value.iceServers));
+  if (value.kind === 'candidate') return IcePolicy.candidate(value.candidate) &&
+    typeof value.mid === 'string' && value.mid.length <= 64;
+  return false;
+}
+
+export function validProbeIceServers(value) {
+  return IcePolicy.servers(value);
+}

package/dist/src/self-relay/phone-connections.mjs

@@ -0,0 +1,55 @@
+import { validId } from './device-store.mjs';
+
+export function validPhoneConnection(value) {
+  return value && validId(value.connectionId) && validId(value.clientId) && ['lan', 'self-relay'].includes(value.mode);
+}
+
+export function phoneConnectionEvents(pool) {
+  const recent = new Map();
+  const lastConnections = new Map();
+  return {
+    async record(computerId, event) {
+      if (!validPhoneConnection(event) || !validId(event.id) ||
+          !['connected', 'disconnected'].includes(event.state) ||
+          typeof event.at !== 'string' || !/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/.test(event.at) ||
+          !Number.isFinite(Date.parse(event.at)) || new Date(event.at).toISOString() !== event.at) throw new Error('Invalid phone connection event');
+      const item = { id: event.id, connectionId: event.connectionId, clientId: event.clientId,
+        mode: event.mode, state: event.state, at: event.at, receivedAt: new Date().toISOString() };
+      if (pool) await pool.execute(`INSERT INTO workstation_phone_events
+        (event_id,computer_id,client_id,connection_id,mode,state,occurred_at,received_at) VALUES (?,?,?,?,?,?,?,?)
+        ON DUPLICATE KEY UPDATE event_id=event_id`,
+      [item.id, computerId, item.clientId, item.connectionId, item.mode, item.state,
+        item.at.slice(0, 23).replace('T', ' '), item.receivedAt.slice(0, 23).replace('T', ' ')]);
+      else {
+        const items = recent.get(computerId) || [];
+        if (!items.some(value => value.id === item.id)) items.push(item);
+        recent.set(computerId, items.slice(-20));
+        if (item.state === 'connected') {
+          const phones = lastConnections.get(computerId) || new Map();
+          if (!phones.has(item.clientId) || phones.get(item.clientId).at <= item.at) phones.set(item.clientId, item);
+          lastConnections.set(computerId, phones);
+        }
+      }
+    },
+    async latest(computerIds) {
+      if (!computerIds.length) return [];
+      if (!pool) return computerIds.flatMap(computerId => [...(lastConnections.get(computerId)?.values() || [])]
+        .map(item => ({ computerId, clientId: item.clientId, mode: item.mode, at: item.at })));
+      const [rows] = await pool.execute(`SELECT computer_id,client_id,mode,occurred_at FROM (
+        SELECT computer_id,client_id,mode,occurred_at,
+          ROW_NUMBER() OVER (PARTITION BY computer_id,client_id ORDER BY occurred_at DESC,sequence_id DESC) AS connection_rank
+        FROM workstation_phone_events WHERE state='connected' AND computer_id IN (${computerIds.map(() => '?').join(',')})
+      ) latest WHERE connection_rank=1`, computerIds);
+      return rows.map(row => ({ computerId: row.computer_id, clientId: row.client_id,
+        mode: row.mode, at: row.occurred_at.replace(' ', 'T') + 'Z' }));
+    },
+    async list(computerId) {
+      if (!pool) return [...(recent.get(computerId) || [])].reverse();
+      const [rows] = await pool.execute(`SELECT event_id,client_id,connection_id,mode,state,occurred_at,received_at
+        FROM workstation_phone_events WHERE computer_id=? ORDER BY sequence_id DESC LIMIT 20`, [computerId]);
+      return rows.map(row => ({ id: row.event_id, clientId: row.client_id, connectionId: row.connection_id,
+        mode: row.mode, state: row.state, at: row.occurred_at.replace(' ', 'T') + 'Z',
+        receivedAt: row.received_at.replace(' ', 'T') + 'Z' }));
+    },
+  };
+}

package/dist/src/self-relay/privacy-page.mjs

@@ -0,0 +1,26 @@
+// Public policy page: no scripts, cookies, external assets or native bridge.
+export const privacyPage = `<!doctype html>
+<html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta name="color-scheme" content="light dark"><title>Code Relax 隐私政策</title>
+<style>:root{--page-background:#ffffff;--primary-text:#202520;--secondary-text:#667066;--surface-border:#d5ddd8;--space:16px;--body:14px;--title:20px}@media(prefers-color-scheme:dark){:root{--page-background:#181d1a;--primary-text:#eef4ef;--secondary-text:#a5afa7;--surface-border:#354139}}*{box-sizing:border-box}body{margin:0;padding:24px var(--space);background:var(--page-background);color:var(--primary-text);font:var(--body)/1.8 system-ui,sans-serif;overflow-wrap:anywhere}main{max-width:720px;margin:auto}h1{font-size:var(--title)}h2{font-size:16px;margin-top:24px}p,li{margin-block:8px}.meta{color:var(--secondary-text)}a{color:inherit}footer{margin-top:24px;border-top:1px solid var(--surface-border);padding-top:var(--space)}</style></head><body><main>
+<h1>Code Relax 隐私政策</h1><p class="meta">更新及生效日期：2026 年 9 月 26 日<br>运营者：房鹤<br>联系邮箱：wyshmily@126.com</p>
+<p>Code Relax 用于通过手机访问您已授权的电脑上的 Codex。本文说明当前私测版本如何处理信息。请在使用邮箱账号、配对、语音、图片或文件功能前阅读；相关权限在您使用对应功能时申请。</p>
+<h2>一、我们处理哪些信息</h2>
+<ul><li><strong>邮箱账号：</strong>邮箱地址、验证状态、账号标识、登录会话及验证码校验记录，用于登录、身份校验和注销。验证码不以明文保存；服务端保存登录令牌的哈希。</li>
+<li><strong>工作站配对：</strong>工作站标识、名称、连接地址和配对授权标识，用于发现、鉴权和重新连接。工作站及手机凭据保存在各自设备的受保护存储中，云端保存凭据哈希。</li>
+<li><strong>聊天与附件：</strong>您输入的文本、所选图片或文件、Codex 的回复和工具状态，用于远程交互。局域网直连不经过 Code Relax 云中继；使用 Code Relax 中继时，业务数据可能经服务器转发，采用 TLS 传输，目前不提供端到端加密。中继不以聊天历史库或附件库的形式保存这些内容。工作站会保存收到的附件，Codex 历史由电脑上的 Codex 管理。</li>
+<li><strong>用量与诊断：</strong>账号、工作站、手机授权标识、消息/轮次标识、数量、任务时长及时间记录，用于展示服务用量与排障；服务还会产生必要的连接、错误和访问日志，可能包含 IP 地址、设备标识和时间。我们不以用量统计为目的记录聊天正文。</li>
+<li><strong>手机缓存：</strong>手机保留配对记录、账号凭据、展示历史、缩略图和诊断日志，以支持恢复和显示。当前历史与图片缓存有容量淘汰策略，缓存并非电脑原始历史的唯一副本。</li></ul>
+<h2>二、权限与第三方服务</h2>
+<p>扫码时使用相机，语音录入时使用麦克风与华为系统语音识别，添加附件时读取您选择的图片或文件。语音识别由手机系统能力完成，识别结果用于输入框；Code Relax 不建立云端录音库。系统服务自身的信息处理以对应服务说明为准。</p>
+<p>邮箱验证码使用腾讯云邮件推送；人机验证使用腾讯云验证码服务，涉及邮箱、IP 及验证票据等完成验证所需信息。服务部署于腾讯云基础设施。使用 OpenAI 登录、官方中继及 Codex 时，相关账号与业务数据由 OpenAI 按其政策处理；Code Relax 邮箱账号不等于 OpenAI 账号。我们不出售您的个人信息，不使用广告 SDK。</p>
+<h2>三、保存和删除</h2>
+<p>邮箱账号信息与账号用量明细在账号存续期间保存。注销后账号立即停用，相关个人信息及账号用量记录将在7天内删除。清理期间该邮箱暂时无法注册或登录；清理完成后，同一邮箱可重新注册为新用户，不继承原账号记录或额度。登录会话有效期为 30 天，邮件验证码有效期为 10 分钟；有效期指授权或验证有效时间，不代表数据库记录恰好在该时刻物理清除。安全限流记录、诊断及系统日志按其用途和清理策略保留；您可通过上述邮箱申请查询或删除与您相关的信息。</p>
+<p>服务器部署会生成受访问限制的数据库备份，仅用于故障恢复；这些备份定时过期清理，注销相关账号数据及备份副本的清理纳入上述7天期限。</p>
+<h2>四、账号注销与您的选择</h2>
+<p>您可在“我的账号 → 注销账号”确认注销。确认后账号被标记为已注销，全部登录会话失效，停止账号计时并断开该账号中继业务连接；如有管理员权限，也不能继续使用。邮箱登录身份、会话、账号用量和账号关联记录将在7天内删除；7天是最长期限，不代表必须保留满7天。清理完成前不能用同一邮箱注册或登录，清理完成后可重新注册。</p>
+<p><strong>注销 Code Relax 账号不会删除电脑上的 Codex 对话和文件、OpenAI 账号，也不会撤销独立的工作站与手机配对授权。</strong>如需撤销配对，请在工作站授权管理中处理。工作站级汇总统计与独立设备授权记录可能继续保留；这些记录不应被理解为完全匿名数据。手机已有历史缓存也不会因邮箱账号注销而全部清除；可通过清除 App 数据或卸载清理本地数据，此操作会丢失本机保存的配对凭据。</p>
+<p>您可联系运营者申请查询、更正、删除相关个人信息、说明保存期限或提出投诉。我们会核验请求者身份，并在收到有效请求后 15 个工作日内答复处理情况；必要的核验只用于保护您的账号与数据。</p>
+<h2>五、政策更新</h2>
+<p>当处理目的、信息类型或服务发生变化时，我们会更新本页面，并按变化情况在应用中告知、取得必要的授权。本页面的说明必须与实际功能一致；未启用的社区、广告或付费功能不作为本政策已实施的内容。</p>
+<footer>运营者：房鹤<br>个人信息与账号问题：wyshmily@126.com</footer>
+</main></body></html>`;

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

@@ -0,0 +1,67 @@
+import fs from 'node:fs';
+
+export const publicManifestFile = '/var/www/coderelax-homepage/release-status.json';
+export function readPublicManifest(file = publicManifestFile) {
+  const manifest = JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (manifest.schemaVersion !== 1 || ['windows', 'macos', 'linux', 'harmonyos', 'android', 'ios']
+    .some(key => !manifest[key] || typeof manifest[key].statusText?.zh !== 'string'
+      || typeof manifest[key].statusText?.en !== 'string')) throw new Error('Invalid public platform manifest');
+  return manifest;
+}
+
+export function updatePublicAndroid(release, file = publicManifestFile) {
+  if (!Number.isSafeInteger(release.versionCode) || release.versionCode <= 0
+    || !/^\d+\.\d+\.\d+\.\d+$/.test(release.versionName)
+    || !Number.isSafeInteger(release.size) || release.size <= 0
+    || !/^[a-f0-9]{64}$/.test(release.sha256)) throw new Error('Invalid public Android release');
+  return updateMobileManifest('android', release, file);
+}
+
+export function updatePublicHarmony(release, file = publicManifestFile) {
+  if (!Number.isSafeInteger(release.versionCode) || !/^\d+\.\d+\.\d+$/.test(release.versionName)
+    || !/^[a-f0-9]{64}$/.test(release.sha256) || !Number.isSafeInteger(release.size) || release.size <= 0
+    || release.manifestUrl !== `https://download.coderelax.cn/code-relax/harmony/${release.versionCode}/manifest.json5`)
+    throw Error('Invalid public Harmony release');
+  return updateMobileManifest('harmonyos', release, file);
+}
+
+function updateMobileManifest(platform, release, file) {
+  return updatePublicManifest(manifest => {
+    if (manifest[platform].versionCode > release.versionCode) throw new Error('Public Android version would go backwards');
+    manifest[platform] = { status: 'published', statusText: { zh: '', en: '' }, version: release.versionName,
+      versionCode: release.versionCode, size: release.size, sha256: release.sha256,
+      url: `https://api.coderelax.cn/code-relax/android/download?versionCode=${release.versionCode}&redirect=1`, action: 'download' };
+    if (platform === 'harmonyos') {
+      manifest.harmonyos.statusText = { zh: '指定设备测试版', en: 'Registered-device test' };
+      manifest.harmonyos.url = 'https://www.coderelax.cn/code-relax/install';
+      manifest.harmonyos.manifestUrl = release.manifestUrl;
+    }
+  }, file);
+}
+
+export function updatePublicWorkstations(version, file = publicManifestFile) {
+  if (!/^\d+\.\d+\.\d+-beta\.\d+$/.test(version)) throw Error('Invalid npm version');
+  return updatePublicManifest(manifest => {
+    for (const platform of ['windows', 'macos', 'linux']) {
+      if (manifest[platform].status === 'published') manifest[platform].version = version;
+    }
+  }, file);
+}
+
+export function updatePublicManifest(update, file = publicManifestFile) {
+  const lock = file + '.lock', temporary = file + '.new';
+  const handle = fs.openSync(lock, 'wx', 0o600);
+  try {
+    const manifest = readPublicManifest(file);
+    update(manifest);
+    const owner = fs.statSync(file);
+    fs.writeFileSync(temporary, JSON.stringify(manifest, null, 2) + '\n', { mode: owner.mode & 0o777 });
+    fs.chmodSync(temporary, owner.mode & 0o777);
+    if (process.platform !== 'win32') fs.chownSync(temporary, owner.uid, owner.gid);
+    fs.renameSync(temporary, file);
+  } finally {
+    fs.closeSync(handle);
+    fs.unlinkSync(lock);
+    if (fs.existsSync(temporary)) fs.unlinkSync(temporary);
+  }
+}