@walkhi/code-relax 0.1.0-beta.5 → 0.1.0-beta.50

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,13 +1,15 @@
 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 = () => {}, iceServers = [] }) {
+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', {
@@ -22,32 +24,68 @@ export async function createP2pProbe({ signal, report = () => {}, onData = () =>
   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); candidates = []; queuedBytes = 0; outbound.length = 0; framer.reset();
+    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);
-        if (!channel.sendMessage(frame)) return;
+        // 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 || !channel?.isOpen()) return false;
+    if (!verified || !remoteDirect || closed || purpose === 'file' || !channel?.isOpen()) return false;
     let item;
     try { item = framer.create(payload, `${dataPrefix}-${++dataSerial}`); }
     catch { return false; }
@@ -58,7 +96,11 @@ export async function createP2pProbe({ signal, report = () => {}, onData = () =>
   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 }); } });
+  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);
@@ -69,9 +111,11 @@ export async function createP2pProbe({ signal, report = () => {}, onData = () =>
     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) throw new Error('P2P transport not verified');
+        if (!verified || !remoteDirect || purpose === 'file') throw new Error('P2P transport not verified');
+        idle.received();
         if (data.complete) onData(data.payload);
         return;
       }
@@ -88,12 +132,14 @@ export async function createP2pProbe({ signal, report = () => {}, onData = () =>
     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);
@@ -109,15 +155,14 @@ export async function createP2pProbe({ signal, report = () => {}, onData = () =>
 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) &&
+  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 typeof value.candidate === 'string' && value.candidate.length <= 2048 &&
+  if (value.kind === 'candidate') return IcePolicy.candidate(value.candidate) &&
     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);
+  return IcePolicy.servers(value);
 }

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);
+  }
+}

package/dist/src/self-relay/rtc-file-bridge.mjs

@@ -0,0 +1,41 @@
+import WebSocket from 'ws';
+import { loopbackUrl } from './wire.mjs';
+
+// The RTC peer belongs to an authenticated relay chat session. Its teardown
+// closes this channel on logout, expiry, revocation or signaling disconnect.
+export function attachRtcFile(channel, connection, authorized) {
+  let local, authenticated = false;
+  const timer = setTimeout(() => channel.close(1008), 5000);
+  channel.addEventListener('close', () => { clearTimeout(timer); local?.terminate(); });
+  channel.onmessage = event => {
+    try {
+      if (!authorized()) throw new Error('File authorization expired');
+      if (!local) {
+        if (typeof event.data !== 'string') throw new Error('File authentication required');
+        const auth = JSON.parse(event.data);
+        if (auth.type !== 'auth' || !['upload', 'download'].includes(auth.purpose)) throw new Error('Invalid file purpose');
+        const url = new URL(connection.url); url.pathname = '/api/file-transfer';
+        loopbackUrl(url.href, '/api/file-transfer');
+        local = new WebSocket(url.href, { maxPayload: 512 * 1024, perMessageDeflate: false });
+        local.on('open', () => {
+          if (!authorized() || channel.readyState !== 1) { local.terminate(); return; }
+          local.send(JSON.stringify({ type: 'auth', token: connection.token, purpose: auth.purpose }));
+        });
+        local.on('message', (bytes, binary) => {
+          if (!authorized() || channel.readyState !== 1) { channel.close(4401); return; }
+          try {
+            if (!authenticated) {
+              if (binary || JSON.parse(bytes.toString()).type !== 'ready') throw new Error('File authentication failed');
+              authenticated = true; clearTimeout(timer);
+            }
+            channel.send(binary ? bytes : bytes.toString());
+          } catch { channel.close(1011); }
+        });
+        local.on('close', () => channel.close(1011)); local.on('error', () => channel.close(1011));
+        return;
+      }
+      if (!authenticated || local.readyState !== WebSocket.OPEN || local.bufferedAmount > 1024 * 1024) throw new Error('File channel unavailable');
+      local.send(typeof event.data === 'string' ? event.data : Buffer.from(event.data));
+    } catch { channel.close(1008); }
+  };
+}