@walkhi/code-relax 0.1.0-beta.2 → 0.1.0-beta.20

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

@@ -1,16 +1,24 @@
-import http from 'node:http';
+import http from 'node:http';
+import fs from 'node:fs';
+import { isIP } from 'node:net';
 import { deviceStore, validId } from './device-store.mjs';
-import { randomUUID } from 'node:crypto';
+import { randomUUID, timingSafeEqual } from 'node:crypto';
 import { WebSocketServer } from 'ws';
 import { secret, digest, matches, validSecret, send, decode } from './wire.mjs';
 import { readDebugAllowlist, debugAllowed } from './debug-allowlist.mjs';
 import { validProbeSignal } from './p2p-probe.mjs';
 import { relayAdminState } from './admin-state.mjs';
+import { openRelayMysql } from './mysql-state.mjs';
+import { adminPage } from './admin-page.mjs';
+import { openEmailAccounts } from './email-accounts.mjs';
+import { usageMeter, usageReport } from './usage-meter.mjs';
+import { usageDiagnostics } from './usage-diagnostics.mjs';
 
 // Always loopback; a TLS reverse proxy supplies the private-trial Internet endpoint.
 export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlMs = 120000,
   maxConnections = 32, maxClientsPerHost = 16, maxPayload = 8 * 1024 * 1024, stateFile,
-  maxRelaySessions = 8, adminStateFile, publicRelayUrl = '', appDownloadUrl = '', debugAllowlistFile, log = () => {} } = {}) {
+  maxRelaySessions = 8, adminStateFile, mysqlConfigFile, accountConfigFile, usageDiagnosticKeyFile,
+  publicRelayUrl = '', appDownloadUrl = '', debugAllowlistFile, log = () => {} } = {}) {
   if (!validSecret(hostKey)) throw new Error('Invalid host credential');
   if (!Number.isSafeInteger(maxClientsPerHost) || maxClientsPerHost < 1 || maxClientsPerHost > 64) throw new Error('Invalid mobile device limit');
   if (!Number.isSafeInteger(maxRelaySessions) || maxRelaySessions < 1 || maxRelaySessions > 256) throw new Error('Invalid relay session limit');
@@ -20,24 +28,39 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
   const nativeOrigins = publicRelayUrl ? ['http:', 'https:'].map(protocol => `${protocol}//${new URL(publicRelayUrl).host}`) : [];
   if (appDownloadUrl && !/^https:\/\/[^\s]+$/.test(appDownloadUrl)) throw new Error('Invalid app download URL');
   const hostHash = digest(hostKey), rooms = new Map();
-  const store = deviceStore(stateFile);
+  const database = mysqlConfigFile ? await openRelayMysql(mysqlConfigFile, maxRelaySessions) : null;
+  if (accountConfigFile && !database?.schemaVersions.includes('003_relay_usage')) throw new Error('Relay account and usage schema is required');
+  const accounts = accountConfigFile ? openEmailAccounts(database.pool, accountConfigFile) : null;
+  const meter = accounts ? usageMeter(database.pool) : null;
+  const diagnostics = database?.schemaVersions.includes('005_relay_usage_diagnostics')
+    ? usageDiagnostics(database.pool, error => log({ event: 'usage-diagnostic-error', message: error.message })) : null;
+  const diagnosticKey = usageDiagnosticKeyFile ? fs.readFileSync(usageDiagnosticKeyFile, 'utf8').trim() : '';
+  if (diagnosticKey && !/^[A-Za-z0-9_-]{43}$/.test(diagnosticKey)) throw new Error('Invalid usage diagnostic key');
+  const store = database?.devices || deviceStore(stateFile);
   const debugAllowlist = readDebugAllowlist(debugAllowlistFile);
-  const adminState = relayAdminState(adminStateFile, maxRelaySessions);
+  const adminState = database?.admin || relayAdminState(adminStateFile, maxRelaySessions);
   let activeRelaySessions = 0;
-  for (const record of store.entries()) rooms.set(record.id, { ...record, durable: true, connections: new Map(), observers: new Map() });
+  for (const record of store.entries()) rooms.set(record.id, { ...record, durable: true, connections: new Map(), observers: new Map(), uploadClients: new Map() });
+  let commitTail = Promise.resolve();
   function commit(room, changes) {
+    const operation = commitTail.then(async () => {
+    changes = typeof changes === 'function' ? changes(room) : changes;
     const next = { ...room, ...changes, updatedAt: new Date().toISOString() };
     if (room.durable) {
       const { id, hostHash, clients, revision, status, createdAt, updatedAt, officialComputer } = next;
-      store.save({ id, hostHash, clients, revision, status, createdAt, updatedAt, ...(officialComputer ? { officialComputer } : {}) });
+      await store.save({ id, hostHash, clients, revision, status, createdAt, updatedAt, ...(officialComputer ? { officialComputer } : {}) });
     }
-    Object.assign(room, changes, { updatedAt: next.updatedAt });
+    Object.assign(room, changes, { updatedAt: next.updatedAt });
+    });
+    commitTail = operation.catch(() => {});
+    return operation;
   }
   function invitation(room) {
     const code = secret(); room.pairingHash = digest(code); room.expires = Date.now() + pairingTtlMs;
     return { code, expires: room.expires };
   }
   let listenUrl = '';
+  let adminTail = Promise.resolve();
   function relayUrl(request) {
     if (publicRelayUrl) return relayPublicAddress(publicRelayUrl);
     const host = request.headers.host || new URL(listenUrl).host;
@@ -51,7 +74,14 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
   const server = http.createServer((request, response) => {
     const target = new URL(request.url || '/', `http://${request.headers.host || 'localhost'}`);
     if (target.pathname === '/admin' || target.pathname.startsWith('/admin/')) {
-      void handleAdmin(request, response, target); return;
+      adminTail = adminTail.then(() => handleAdmin(request, response, target)).catch(() => {
+        if (!response.headersSent) adminReply(response, 500, { error: 'Admin operation failed' });
+      });
+      return;
+    }
+    if (accounts && target.pathname.startsWith('/account/')) {
+      void handleAccount(request, response, target).catch(() => accountReply(response, 500, { error: 'Account operation failed' }));
+      return;
     }
     if (request.method === 'GET' && target.pathname === '/announcement') {
       const body = JSON.stringify({ announcement: adminState.read().announcement });
@@ -82,30 +112,123 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
       'X-Content-Type-Options': 'nosniff', 'Content-Security-Policy': "default-src 'self'; style-src 'unsafe-inline'; script-src 'unsafe-inline'; base-uri 'none'; frame-ancestors 'none'" });
     response.end(value);
   }
+  function accountReply(response, status, body) {
+    if (response.headersSent || response.destroyed) return;
+    const value = JSON.stringify(body);
+    response.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8', 'Content-Length': Buffer.byteLength(value),
+      'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff' });
+    response.end(value);
+  }
+  async function handleAccount(request, response, target) {
+    try {
+      if (target.pathname === '/account/config' && request.method === 'GET') {
+        accountReply(response, 200, { captchaAppId: accounts.captchaAppId }); return;
+      }
+      const bearer = /^Bearer ([A-Za-z0-9_-]{43})$/.exec(request.headers.authorization || '')?.[1];
+      if (target.pathname === '/account/me' && request.method === 'GET') {
+        const user = await accounts.current(bearer);
+        accountReply(response, 200, { user, usage: await accounts.usage(user.id) }); return;
+      }
+      if (target.pathname === '/account/logout' && request.method === 'POST') {
+        accountReply(response, 200, await accounts.logout(bearer)); return;
+      }
+      if (request.method !== 'POST' || request.headers['content-type'] !== 'application/json') {
+        accountReply(response, 404, { error: 'Account route not found' }); return;
+      }
+      const body = JSON.parse(await readBody(request, 4096));
+      if (!body || typeof body !== 'object' || Array.isArray(body)) { accountReply(response, 400, { error: 'Invalid request body' }); return; }
+      if (target.pathname === '/account/email/request') {
+        const ip = request.headers['x-real-ip'] || request.socket.remoteAddress || '';
+        if (typeof ip !== 'string' || !isIP(ip)) { accountReply(response, 400, { error: 'Invalid client address' }); return; }
+        accountReply(response, 202, await accounts.requestCode(body, ip));
+      } else if (target.pathname === '/account/email/verify') {
+        accountReply(response, 200, await accounts.verifyCode(body));
+      } else accountReply(response, 404, { error: 'Account route not found' });
+    } catch (failure) {
+      accountReply(response, failure.status || 503, { error: failure.status ? failure.message : 'Account service unavailable' });
+    }
+  }
   async function handleAdmin(request, response, target) {
     if (request.method === 'GET' && target.pathname === '/admin') {
       adminReply(response, 200, adminPage(), 'text/html; charset=utf-8'); return;
     }
+    if (target.pathname.startsWith('/admin/api/')) {
+      const token = /^Bearer ([A-Za-z0-9_-]{43})$/.exec(request.headers.authorization || '')?.[1];
+      const diagnosticRoute = target.pathname === '/admin/api/usage-diagnostics' ||
+        target.pathname === '/admin/api/usage-diagnostics/drain';
+      const keyAccepted = diagnosticRoute && diagnosticKey && token &&
+        timingSafeEqual(Buffer.from(token), Buffer.from(diagnosticKey));
+      let email;
+      if (!keyAccepted) {
+        try { email = (await accounts.current(token)).email; }
+        catch { adminReply(response, 401, { error: '请先登录管理员账号' }); return; }
+        const [allowed] = await database.pool.execute('SELECT email FROM relay_admin_emails WHERE email=?', [email]);
+        if (!allowed.length) { adminReply(response, 403, { error: '此账号没有后台管理权限' }); return; }
+      }
+      if (target.pathname === '/admin/api/session' && request.method === 'GET') {
+        adminReply(response, 200, { email }); return;
+      }
+    }
     if (request.method === 'GET' && target.pathname === '/admin/api/status') {
       const state = adminState.read();
       adminReply(response, 200, { maxRelaySessions: state.maxRelaySessions, activeRelaySessions,
         activeExemptRelaySessions: [...rooms.values()].reduce((sum, room) => sum + [...room.connections.values()].filter(connection => connection.relayExempt).length, 0),
         websocketConnections: wss.clients.size, onlineComputers: [...rooms.values()].filter(room => room.host).length,
-        activePhones: [...rooms.values()].reduce((sum, room) => sum + room.connections.size, 0), announcement: state.announcement }); return;
+        activePhones: [...rooms.values()].reduce((sum, room) => sum + room.connections.size, 0),
+        processRssBytes: process.memoryUsage().rss, processUptimeSeconds: process.uptime(),
+        announcement: state.announcement, announcements: state.announcements }); return;
+    }
+    if (request.method === 'GET' && target.pathname === '/admin/api/usage' && meter) {
+      const page = Number(target.searchParams.get('page') || '1');
+      const user = target.searchParams.get('user') || '';
+      if (!Number.isSafeInteger(page) || page < 1 || page > 100000 || (user && !/^[0-9a-f-]{36}$/.test(user))) {
+        adminReply(response, 400, { error: 'Invalid usage query' }); return;
+      }
+      adminReply(response, 200, await usageReport(database.pool, page, user)); return;
+    }
+    if (diagnostics && target.pathname === '/admin/api/usage-diagnostics') {
+      if (request.method === 'GET') adminReply(response, 200, await diagnostics.read());
+      else if (request.method === 'DELETE') adminReply(response, 200, await diagnostics.clear());
+      else adminReply(response, 405, { error: 'Unsupported diagnostic request' });
+      return;
+    }
+    if (diagnostics && target.pathname === '/admin/api/usage-diagnostics/drain') {
+      if (request.method === 'POST') adminReply(response, 200, await diagnostics.drain());
+      else adminReply(response, 405, { error: 'Unsupported diagnostic request' });
+      return;
     }
     if (!['PUT', 'DELETE'].includes(request.method || '') || request.headers['content-type'] !== 'application/json' ||
         request.headers['x-code-relax-admin'] !== '1') { adminReply(response, 405, { error: 'Unsupported admin request' }); return; }
     try {
       const body = request.method === 'DELETE' ? {} : JSON.parse(await readBody(request, 4096));
       if (target.pathname === '/admin/api/settings' && request.method === 'PUT') {
-        const state = adminState.setMaxRelaySessions(body.maxRelaySessions);
+        const state = await adminState.setMaxRelaySessions(body.maxRelaySessions);
         log({ event: 'admin-relay-limit-updated', maxRelaySessions: state.maxRelaySessions });
-      } else if (target.pathname === '/admin/api/announcement' && request.method === 'PUT') {
-        const state = adminState.publish(body.title, body.message); broadcastAnnouncement(state.announcement);
-        log({ event: 'admin-announcement-published', announcementId: state.announcement.id });
-      } else if (target.pathname === '/admin/api/announcement' && request.method === 'DELETE') {
-        const state = adminState.withdraw(); broadcastAnnouncement(state.announcement);
-        log({ event: 'admin-announcement-withdrawn' });
+      } else if (target.pathname === '/admin/api/announcements' && request.method === 'PUT') {
+        const state = await adminState.createAnnouncement(body.title, body.message, body.publish === true);
+        if (body.publish === true) {
+          broadcastAnnouncement(state.announcement);
+          log({ event: 'admin-announcement-published', announcementId: state.announcement.id });
+        } else log({ event: 'admin-announcement-draft-created', announcementId: state.announcements[0].id });
+      } else if (target.pathname.startsWith('/admin/api/announcements/')) {
+        const parts = target.pathname.slice('/admin/api/announcements/'.length).split('/');
+        const id = parts[0];
+        if (!/^[\w-]{16,128}$/.test(id)) { adminReply(response, 404, { error: 'Admin route not found' }); return; }
+        if (parts.length === 1 && request.method === 'PUT') {
+          await adminState.updateDraft(id, body.title, body.message);
+          log({ event: 'admin-announcement-draft-updated', announcementId: id });
+        } else if (parts.length === 1 && request.method === 'DELETE') {
+          await adminState.deleteAnnouncement(id);
+          log({ event: 'admin-announcement-deleted', announcementId: id });
+        } else if (parts.length === 2 && parts[1] === 'publish' && request.method === 'PUT') {
+          const state = await adminState.publishDraft(id, body.title, body.message);
+          broadcastAnnouncement(state.announcement);
+          log({ event: 'admin-announcement-published', announcementId: id });
+        } else if (parts.length === 2 && parts[1] === 'withdraw' && request.method === 'PUT') {
+          const state = await adminState.withdraw(id);
+          broadcastAnnouncement(state.announcement);
+          log({ event: 'admin-announcement-withdrawn', announcementId: id });
+        } else { adminReply(response, 404, { error: 'Admin route not found' }); return; }
       } else { adminReply(response, 404, { error: 'Admin route not found' }); return; }
       adminReply(response, 200, { ok: true });
     } catch (error) { adminReply(response, 400, { error: error.message }); }
@@ -168,26 +291,64 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
       }).catch(() => connection.ws.close(1011, 'Relay delivery failed'));
     };
     ws.on('error', () => {}); // close owns routing cleanup.
-    ws.on('close', (code, reason) => {
+    ws.on('close', (code, reason) => {
       log({ event: 'closed', role: role || 'unauthenticated', device: room?.id, code, reason: reason.toString() });
       clearTimeout(authTimer); clearInterval(heartbeat);
       if (role === 'host' && room?.host === ws) {
+        for (const task of room.usageTasks?.values() || []) {
+          void meter?.lost(task).catch(error => log({ event: 'usage-error', message: error.message }));
+        }
+        room.usageTasks?.clear(); room.usageArms?.clear();
         room.host = undefined; room.hostName = undefined; room.lanCandidates = [];
+        room.uploadHost?.close(4410, 'Computer offline');
+        for (const client of room.uploadClients?.values() || []) client.ws.close(4410, 'Computer offline');
         for (const observer of room.observers.values()) send(observer.ws, { type: 'observing', online: false });
         if (!room.durable) rooms.delete(room.id);
         for (const connection of room.connections.values()) connection.ws.close(4410, 'Computer offline; authorization retained');
       } else if (role === 'client' && room?.connections.get(clientId)?.ws === ws) {
-        releaseRelay(room.connections.get(clientId));
+        const connection = room.connections.get(clientId);
+        releaseRelay(connection);
         room.connections.delete(clientId);
         if (room.host) send(room.host, { type: 'detach', session });
       } else if (role === 'observer' && room?.observers.get(clientId)?.ws === ws) {
         room.observers.delete(clientId);
-      }
+      } else if (role === 'file-host' && room?.uploadHost === ws) {
+        room.uploadHost = undefined;
+        for (const client of room.uploadClients?.values() || []) client.ws.close(4410, 'File receiver offline');
+      } else if (role === 'file-client' && room?.uploadClients?.get(clientId)?.ws === ws) {
+        room.uploadClients.delete(clientId);
+        if (room.uploadHost) send(room.uploadHost, { type: 'file-close', session });
+      }
     });
-    ws.on('message', (bytes, binary) => {
-      try {
-        const message = decode(bytes, binary);
-        if (!role) {
+    let messageTail = Promise.resolve();
+    ws.on('message', (bytes, binary) => {
+      messageTail = messageTail.then(async () => {
+      try {
+        const message = decode(bytes, binary);
+        if (!role) {
+          if (message.type === 'file-host') {
+            room = rooms.get(message.deviceId);
+            if (!room?.host || room.status !== 'active' || !matches(message.deviceSecret, room.hostHash)) return fail();
+            role = 'file-host'; clearTimeout(authTimer);
+            room.uploadClients ||= new Map();
+            room.uploadHost?.close(4409, 'File receiver replaced');
+            room.uploadHost = ws;
+            send(ws, { type: 'file-host-ready' }); return;
+          }
+          if (message.type === 'file-client') {
+            room = rooms.get(message.room);
+            const client = room?.clients.find(item => item.id === message.clientId);
+            if (!room?.host || !room.uploadHost || room.status !== 'active' || !client ||
+                !matches(message.credential, client.hash)) return fail();
+            room.uploadClients ||= new Map();
+            if (room.uploadClients.has(message.clientId) ||
+                [...rooms.values()].reduce((sum, item) => sum + (item.uploadClients?.size || 0), 0) >= 2) {
+              return fail(4429, 'Too many file uploads');
+            }
+            role = 'file-client'; clientId = message.clientId; session = randomUUID(); clearTimeout(authTimer);
+            room.uploadClients.set(clientId, { ws, session });
+            send(room.uploadHost, { type: 'file-open', session }); return;
+          }
           if (message.type === 'host') {
             const durable = message.deviceId !== undefined;
             if (durable && (!validId(message.deviceId) || !validSecret(message.deviceSecret))) return fail();
@@ -198,20 +359,30 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
               hostName = normalizeHostName(message.hostName);
             }
             catch { return fail(1008, 'Invalid LAN candidates'); }
-            room = durable ? rooms.get(message.deviceId) : undefined;
-            if (room && (room.status !== 'active' || !matches(message.deviceSecret, room.hostHash))) return fail();
-            if (!room) {
-              if (!matches(message.key, hostHash)) return fail();
-              if (rooms.size >= 256) return fail(4429, 'Device limit reached');
+            room = durable ? rooms.get(message.deviceId) : undefined;
+            if (room && (room.status !== 'active' || !matches(message.deviceSecret, room.hostHash))) return fail();
+            if (!room) {
+              // Durable computers prove future ownership with their generated device secret.
+              // The legacy deployment key remains accepted, but is no longer required for first registration.
+              if (!durable && !matches(message.key, hostHash)) return fail();
+              if (rooms.size >= 256) return fail(4429, 'Device limit reached');
               const now = new Date().toISOString();
               room = { id: durable ? message.deviceId : randomUUID(), durable,
-                revision: 0, status: 'active', clients: [], connections: new Map(), observers: new Map(), createdAt: now, updatedAt: now,
+                revision: 0, status: 'active', clients: [], connections: new Map(), observers: new Map(), uploadClients: new Map(), createdAt: now, updatedAt: now,
                 ...(durable ? { hostHash: digest(message.deviceSecret) } : {}) };
-              commit(room, {}); rooms.set(room.id, room);
+              await commit(room, {}); rooms.set(room.id, room);
             }
             const oldHost = room.host;
             room.observers ||= new Map();
+            if (oldHost && oldHost !== ws) {
+              for (const task of room.usageTasks?.values() || []) {
+                try { await meter?.lost(task); } catch (error) { log({ event: 'usage-error', message: error.message }); }
+              }
+              room.usageTasks?.clear(); room.usageArms?.clear();
+            }
             room.host = ws; room.hostName = hostName; room.lanCandidates = lanCandidates;
+            room.usageTasks ||= new Map(); room.usageArms ||= new Map();
+            if (oldHost && oldHost !== ws) room.uploadHost?.close(4409, 'Computer connection replaced');
             room.p2pProbe = message.p2pProbe === 1; room.p2pProbeRepeat = message.p2pProbeRepeat === true;
             role = 'host'; clearTimeout(authTimer);
             if (oldHost && oldHost !== ws) {
@@ -230,7 +401,7 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
           room = rooms.get(message.room);
           if (!room || room.status !== 'active') return fail();
           let credential;
-          if (message.type === 'pair' && room.pairingHash && Date.now() < room.expires && matches(message.code, room.pairingHash)) {
+          if (message.type === 'pair' && !room.pairingInProgress && room.pairingHash && Date.now() < room.expires && matches(message.code, room.pairingHash)) {
             if (!room.host) return fail(4410, 'Computer offline; authorization retained');
             credential = message.credential || secret();
             clientId = message.clientId || (!room.durable ? randomUUID() : undefined);
@@ -239,8 +410,11 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
             if (!existing && room.clients.length >= maxClientsPerHost) return fail(4429, 'Mobile device limit reached');
             const now = new Date().toISOString();
             const client = { id: clientId, hash: digest(credential), createdAt: existing?.createdAt || now, updatedAt: now };
-            commit(room, { clients: [...room.clients.filter(item => item.id !== clientId), client], revision: room.revision + 1 });
-            room.pairingHash = undefined;
+            room.pairingInProgress = true;
+            try {
+              await commit(room, current => ({ clients: [...current.clients.filter(item => item.id !== clientId), client], revision: current.revision + 1 }));
+              room.pairingHash = undefined;
+            } finally { room.pairingInProgress = false; }
             send(room.host, { type: 'authorization-changed', clients: room.clients, revision: room.revision });
           } else {
             clientId = message.clientId;
@@ -266,6 +440,11 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
             return;
           }
           if (!room.host) return fail(4410, 'Computer offline; authorization retained');
+          let userId;
+          if (accounts && message.accountToken !== undefined) {
+            try { userId = (await accounts.current(message.accountToken)).id; }
+            catch { return fail(4431, 'Account session invalid'); }
+          }
           const oldConnection = room.connections.get(clientId);
           role = 'client'; clearTimeout(authTimer); session = randomUUID();
           if (oldConnection?.ws && oldConnection.ws !== ws) {
@@ -274,9 +453,11 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
             oldConnection.ws.close(4409, 'Phone connection replaced by same identity');
           }
           room.connections.set(clientId, { ws, session, p2pProbe: room.p2pProbe && message.p2pProbe === 1,
+            userId,
             repeat: room.p2pProbeRepeat, signals: 0, probeStarted: 0, outbound: Promise.resolve(), queuedBytes: 0,
             relayAdmitted: false, relayExempt: false,
             capacityExempt: debugAllowed(debugAllowlist, room.id, room.clients.find(client => client.id === clientId)) });
+          diagnostics?.record('client', userId ? 'account-linked' : 'anonymous');
           send(ws, { type: 'paired', protocolVersion: 7, room: room.id, clientId, revision: room.revision, ...(credential ? { credential } : {}) });
           send(ws, { type: 'computer-info', hostName: room.hostName });
           if (room.lanCandidates?.length) send(ws, { type: 'lan-candidates', candidates: room.lanCandidates });
@@ -286,6 +467,86 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
         }
         if (role === 'host') {
           if (room.host !== ws) return;
+          if (meter && ['usage-arm', 'usage-message', 'usage-cancel', 'usage-turn', 'usage-observer-lost'].includes(message.type)) {
+            if (message.type === 'usage-observer-lost') {
+              for (const task of room.usageTasks.values()) {
+                try { await meter.lost(task); } catch (error) { log({ event: 'usage-error', message: error.message }); }
+              }
+              room.usageTasks.clear();
+              return;
+            }
+            const armKey = `${message.session}:${message.requestId}`;
+            const connection = [...room.connections.values()].find(item => item.session === message.session);
+            if (message.type === 'usage-arm') {
+              diagnostics?.record('arm', connection?.userId ? 'account-linked' : 'anonymous');
+              if (!connection?.userId || !Number.isSafeInteger(message.requestId) || message.requestId < 1 ||
+                  (message.threadId !== null && (!plainText(message.threadId, 128, false)))) {
+                diagnostics?.record('arm-rejected', !connection?.userId ? 'account-missing' : 'invalid-request');
+                return;
+              }
+              for (const [key, arm] of room.usageArms) if (Date.now() - arm.at > 120000) room.usageArms.delete(key);
+              if (room.usageArms.size >= 256) return;
+              room.usageArms.set(armKey, { userId: connection.userId,
+                clientId: [...room.connections.entries()].find(([, item]) => item === connection)?.[0],
+                session: message.session, at: Date.now() });
+              diagnostics?.record('arm-accepted', 'ready');
+              return;
+            }
+            if (message.type === 'usage-cancel') {
+              diagnostics?.record('message-cancelled', room.usageArms.has(armKey) ? 'armed' : 'arm-missing');
+              room.usageArms.delete(armKey); return;
+            }
+            if (message.type === 'usage-message') {
+              const arm = room.usageArms.get(armKey);
+              diagnostics?.record('message', arm ? 'armed' : 'arm-missing');
+              room.usageArms.delete(armKey);
+              if (!arm || Date.now() - arm.at > 120000 || !plainText(message.messageKey, 128, false)) {
+                diagnostics?.record('message-rejected', !arm ? 'arm-missing' : 'expired-or-invalid');
+                return;
+              }
+              try {
+                await meter.action(arm, room.id, arm.clientId, 'message', message.messageKey);
+                diagnostics?.record('message-counted', 'confirmed');
+                if (['start', 'steer'].includes(message.turnKind) &&
+                    plainText(message.threadId, 80, false) && plainText(message.turnId, 80, false)) {
+                  const key = `${message.threadId}:${message.turnId}`;
+                  if (key.length <= 128) {
+                    const counted = await meter.action(arm, room.id, arm.clientId, 'turn', key);
+                    if (counted) diagnostics?.record('turn-counted', 'confirmed');
+                    if (!room.usageTasks.has(key) && message.observerReady === true && message.completed !== true &&
+                        (message.turnKind === 'start' || message.active === true)) {
+                      const task = await meter.turnOrigin(room.id, key);
+                      if (task) {
+                        await meter.pulse(task, true, room.id, task.clientId, key);
+                        room.usageTasks.set(key, task);
+                      }
+                    }
+                  }
+                }
+              } catch (error) { diagnostics?.record('message-error', 'database'); log({ event: 'usage-error', message: error.message }); }
+              return;
+            }
+            if (!['turn/started', 'turn/completed', 'heartbeat', 'resume'].includes(message.method) ||
+                !plainText(message.threadId, 80, false) || !plainText(message.turnId, 80, false)) return;
+            const key = `${message.threadId}:${message.turnId}`;
+            if (key.length > 128) return;
+            let task = room.usageTasks.get(key);
+            try {
+              if (message.method === 'resume' && !task) {
+                task = await meter.turnOrigin(room.id, key);
+                if (!task) { diagnostics?.record('turn-resume', 'origin-missing'); return; }
+                await meter.pulse(task, true, room.id, task.clientId, `${key}:${randomUUID()}`);
+                diagnostics?.record('turn-resume', 'confirmed');
+                room.usageTasks.set(key, task);
+              } else if (task && message.method === 'heartbeat') await meter.pulse(task, true, room.id, task.clientId);
+              else if (task && message.method === 'turn/completed') {
+                await meter.pulse(task, false, room.id, task.clientId);
+                diagnostics?.record('turn-completed', 'confirmed');
+                room.usageTasks.delete(key);
+              }
+            } catch (error) { log({ event: 'usage-error', message: error.message }); }
+            return;
+          }
           if (message.type === 'lan-candidates') {
             room.lanCandidates = normalizeLanCandidates(message.candidates);
             for (const connection of room.connections.values()) send(connection.ws, { type: 'lan-candidates', candidates: room.lanCandidates });
@@ -299,7 +560,7 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
             send(ws, { type: 'pair-code', commandId: message.commandId, room: room.id, ...invitation(room) }); return;
           }
           if (message.type === 'revoke') {
-            commit(room, { clients: [], revision: room.revision + 1 });
+            await commit(room, current => ({ clients: [], revision: current.revision + 1 }));
             room.pairingHash = undefined;
             for (const connection of room.connections.values()) {
               releaseRelay(connection);
@@ -307,6 +568,8 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
               connection.ws.close(4401, 'Device authorization revoked');
             }
             room.connections.clear();
+            for (const client of room.uploadClients?.values() || []) client.ws.close(4401, 'Device authorization revoked');
+            room.uploadClients?.clear();
             for (const observer of room.observers.values()) observer.ws.close(4401, 'Device authorization revoked');
             room.observers.clear();
             send(ws, { type: 'authorization-changed', clients: [], revision: room.revision });
@@ -318,28 +581,49 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
           else if (message.type === 'ready') queueClientMessage(connection, { type: 'ready', p2pProbe: connection.p2pProbe ? 1 : 0,
             p2pProbeRepeat: connection.p2pProbe && connection.repeat });
           else if (message.type === 'p2p-probe' && connection.p2pProbe && validProbeSignal(message)) {
-            if (connection.probeId !== message.probeId) return;
-            if (++connection.signals > 150) return fail(1008, 'Probe signal limit');
+            const diagnostic = message.purpose === 'diagnostic';
+            if (message.purpose && !diagnostic) return fail(1008, 'Invalid probe purpose');
+            if ((diagnostic ? connection.diagnosticProbeId : connection.probeId) !== message.probeId) return;
+            if (++connection[diagnostic ? 'diagnosticSignals' : 'signals'] > 150) return fail(1008, 'Probe signal limit');
             send(connection.ws, { ...message, session: undefined });
           }
           else if (message.type === 'detach') connection.ws.close(1011, 'Local Bridge unavailable');
           else fail();
+        } else if (role === 'file-host' && room.uploadHost === ws) {
+          const client = [...room.uploadClients.values()].find(item => item.session === message.session);
+          if (!client) return;
+          if (message.type === 'file-frame' && typeof message.payload === 'string' && message.payload.length <= 512 * 1024) {
+            if (client.ws.bufferedAmount > 1024 * 1024) return client.ws.close(1013, 'File receiver too slow');
+            send(client.ws, { type: 'file-frame', payload: message.payload });
+          } else if (message.type === 'file-close') client.ws.close(1011, 'File receiver unavailable');
+          else fail(1008, 'Invalid file frame');
+        } else if (role === 'file-client' && room.uploadClients?.get(clientId)?.ws === ws) {
+          if (message.type !== 'file-frame' || typeof message.payload !== 'string' || message.payload.length > 512 * 1024) return fail(1008, 'Invalid file frame');
+          if (room.uploadHost?.bufferedAmount > 1024 * 1024) return fail(1013, 'File receiver too slow');
+          send(room.uploadHost, { type: 'file-frame', session, payload: message.payload });
         } else if (role === 'observer' && room.observers.get(clientId)?.ws === ws && message.type === 'official-computer') {
           const computer = normalizeOfficialComputer(message);
-          commit(room, { officialComputer: computer });
+          await commit(room, { officialComputer: computer });
           send(ws, { type: 'official-computer-saved', computer });
         } else if (role === 'client' && room.connections.get(clientId)?.ws === ws && message.type === 'p2p-probe') {
           const connection = room.connections.get(clientId);
           if (!connection.p2pProbe || !validProbeSignal(message)) return fail(1008, 'Invalid probe signal');
+          const diagnostic = message.purpose === 'diagnostic';
+          if (message.purpose && !diagnostic) return fail(1008, 'Invalid probe purpose');
+          const idField = diagnostic ? 'diagnosticProbeId' : 'probeId';
+          const signalsField = diagnostic ? 'diagnosticSignals' : 'signals';
+          const startedField = diagnostic ? 'diagnosticProbeStarted' : 'probeStarted';
           if (message.kind === 'start') {
-            if (connection.probeId && (!connection.repeat || Date.now() - connection.probeStarted < 2000)) {
-              send(ws, { type: 'p2p-probe', version: 1, probeId: message.probeId, kind: 'close' }); return;
+            if (connection[idField] && (!connection.repeat || Date.now() - connection[startedField] < 2000)) {
+              send(ws, { type: 'p2p-probe', version: 1, probeId: message.probeId,
+                ...(diagnostic ? { purpose: 'diagnostic' } : {}), kind: 'close' }); return;
             }
-            connection.probeId = message.probeId; connection.signals = 0; connection.probeStarted = Date.now();
+            connection[idField] = message.probeId; connection[signalsField] = 0; connection[startedField] = Date.now();
           }
-          if (connection.probeId !== message.probeId) return;
-          if (++connection.signals > 150) return fail(1008, 'Probe signal limit');
+          if (connection[idField] !== message.probeId) return;
+          if (++connection[signalsField] > 150) return fail(1008, 'Probe signal limit');
           send(room.host, { ...message, session });
+          if (diagnostic && message.kind === 'close') connection.diagnosticProbeId = undefined;
         } else if (room.connections.get(clientId)?.ws === ws && message.type === 'p2p-route' && message.direct === 1) {
           releaseRelay(room.connections.get(clientId));
         } else if (room.connections.get(clientId)?.ws === ws && message.type === 'data' && typeof message.payload === 'string') {
@@ -349,17 +633,19 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
           }
           send(room.host, { type: 'data', session, payload: message.payload });
         } else fail();
-      } catch (error) { log({ event: 'request-error', role, message: 'Relay operation failed' }); ws.close(1011, 'Relay operation failed'); }
-    });
+      } catch (error) { log({ event: 'request-error', role, message: 'Relay operation failed' }); ws.close(1011, 'Relay operation failed'); }
+      }).catch(() => ws.close(1011, 'Relay operation failed'));
+    });
   });
   await new Promise((resolve, reject) => { server.once('error', reject); server.listen(port, '127.0.0.1', resolve); });
   listenUrl = `ws://127.0.0.1:${server.address().port}/relay`;
   return {
     url: listenUrl, hostKey,
-    async close() {
-      for (const ws of wss.clients) ws.terminate();
-      await new Promise(resolve => wss.close(resolve));
-      await new Promise(resolve => server.close(resolve));
+    async close() {
+      for (const ws of wss.clients) ws.terminate();
+      await new Promise(resolve => wss.close(resolve));
+      await new Promise(resolve => server.close(resolve));
+      if (database) await database.close();
     },
   };
 }
@@ -454,13 +740,3 @@ function readBody(request, limit) {
     request.on('end', () => resolve(value)); request.on('error', reject);
   });
 }
-
-function adminPage() {
-  return `<!doctype html><html lang="zh-CN"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Code Relax 管理</title><style>
-body{margin:0;background:#0d1210;color:#eef4f0;font:15px system-ui,sans-serif}main{max-width:760px;margin:40px auto;padding:0 20px}section{background:#151d19;border:1px solid #2a3931;border-radius:14px;padding:18px;margin:16px 0}h1{font-size:24px}h2{font-size:17px}label{display:block;margin:12px 0 6px;color:#aab7af}input,textarea{box-sizing:border-box;width:100%;padding:11px;border:1px solid #43564b;border-radius:9px;background:#0d1210;color:#eef4f0}textarea{min-height:120px;resize:vertical}button{margin:12px 8px 0 0;padding:10px 16px;border:0;border-radius:9px;background:#2c7653;color:white}button.secondary{background:#39443e}pre{white-space:pre-wrap;color:#b9c8bf}.row{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:10px}.metric{padding:12px;background:#0d1210;border-radius:9px}.metric b{display:block;font-size:22px}</style><main><h1>Code Relax 管理</h1><section><h2>运行状态</h2><div id="metrics" class="row"></div><button onclick="load()">刷新</button></section><section><h2>服务器转发容量</h2><label>最大并发 WSS 转发会话</label><input id="limit" type="number" min="1" max="256"><button onclick="saveLimit()">保存</button></section><section><h2>系统公告</h2><label>标题</label><input id="title" maxlength="80"><label>正文</label><textarea id="message" maxlength="2000"></textarea><button onclick="publish()">发布</button><button class="secondary" onclick="withdraw()">撤下</button><pre id="current"></pre></section><pre id="result"></pre><script>
-const request=async(path,options={})=>{const response=await fetch(path,options);const body=await response.json();if(!response.ok)throw new Error(body.error||('HTTP '+response.status));return body};
-async function load(){try{const s=await request('/admin/api/status');limit.value=s.maxRelaySessions;metrics.innerHTML='<div class="metric"><b>'+s.activeRelaySessions+'</b>受限转发 / '+s.maxRelaySessions+'</div><div class="metric"><b>'+s.activeExemptRelaySessions+'</b>白名单转发</div><div class="metric"><b>'+s.websocketConnections+'</b>WebSocket</div><div class="metric"><b>'+s.onlineComputers+'</b>在线工作站</div><div class="metric"><b>'+s.activePhones+'</b>活动手机</div>';current.textContent=s.announcement?s.announcement.title+'\\n'+s.announcement.message+'\\n'+s.announcement.publishedAt:'当前无公告';}catch(e){result.textContent=e.message}}
-const write=(method,path,body)=>request(path,{method,headers:{'Content-Type':'application/json','X-Code-Relax-Admin':'1'},body:JSON.stringify(body)}).then(()=>{result.textContent='已保存';return load()}).catch(e=>result.textContent=e.message);
-function saveLimit(){return write('PUT','/admin/api/settings',{maxRelaySessions:Number(limit.value)})}function publish(){return write('PUT','/admin/api/announcement',{title:title.value,message:message.value})}function withdraw(){return write('DELETE','/admin/api/announcement',{})}load();
-</script></main></html>`;
-}

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

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