@walkhi/code-relax 0.1.0-beta.21 → 0.1.0-beta.23

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

@@ -1,22 +1,19 @@
-import fs from 'node:fs';
 import path from 'node:path';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { randomBytes, randomUUID } from 'node:crypto';
-import { hostname } from 'node:os';
-import QRCode from 'qrcode';
-import { credentialStore } from '../platform/windows/credential-store.mjs';
-import { readRecord, writeRecord } from '../service-lifecycle.mjs';
-import { serviceHealth } from '../service-health.mjs';
+import serviceEndpoints from '../../shared/service-endpoints.cjs';
+import { randomBytes, randomUUID } from 'node:crypto';
+import { hostname } from 'node:os';
+import QRCode from 'qrcode';
+import { credentialStore } from '../platform/windows/credential-store.mjs';
+import { readRecord, writeRecord } from '../service-lifecycle.mjs';
+import { serviceHealth } from '../service-health.mjs';
 import { controlRequest } from '../service-control.mjs';
-import { connectBridgeRelay } from './connector.mjs';
-import { validProbeIceServers } from './p2p-probe.mjs';
-import { relayAddress, validSecret } from './wire.mjs';
-import { saveLanAuthorizations } from './lan-authorizations.mjs';
+import { connectBridgeRelay } from './connector.mjs';
+import { validProbeIceServers } from './p2p-probe.mjs';
+import { relayAddress, validSecret } from './wire.mjs';
+import { saveLanAuthorizations } from './lan-authorizations.mjs';
 import { lanNetworks } from '../platform/windows/network-info.mjs';
 
-const exec = promisify(execFile);
-const officialConfig = { url: 'wss://api.uulife.site/relay' };
+const officialConfig = { url: serviceEndpoints.relayUrl };
 
 async function loadConfig(stateRoot) {
   const configPath = path.join(stateRoot, 'self-relay-config.json');
@@ -26,33 +23,16 @@ async function loadConfig(stateRoot) {
   if (config.p2pIceServers !== undefined && !validProbeIceServers(config.p2pIceServers)) throw new Error('p2pIceServers 只接受最多 4 个 stun:主机:端口地址');
   if (config.p2pWindowsRouteHelper !== undefined && typeof config.p2pWindowsRouteHelper !== 'boolean') throw new Error('p2pWindowsRouteHelper 必须是布尔值');
   if (config.p2pWindowsRouteHelper && !/^[A-Za-z0-9_-]{32,128}$/.test(config.p2pWindowsRouteHelperToken || '')) throw new Error('p2pWindowsRouteHelperToken 无效');
-  const url = process.env.RELAY_URL || config.url;
-  if (!url) throw new Error('请先配置 self-relay-config.json 的 url 和 hostKeyFile（或 sshHost、sshKeyPath），详见自建中继文档。');
-  relayAddress(url);
-  const resolved = relayAddress(url);
-  const pairingUrl = config.pairingUrl || `${resolved.startsWith('wss:') ? 'https:' : 'http:'}//${new URL(resolved).host}/pair`;
-  const pairing = new URL(pairingUrl);
-  if (!['https:', 'http:'].includes(pairing.protocol) || pairing.pathname !== '/pair' || pairing.search || pairing.hash || pairing.username || pairing.password ||
-      (pairing.protocol === 'http:' && pairing.hostname !== '127.0.0.1')) throw new Error('self-relay-config.json 的 pairingUrl 必须是 HTTPS /pair 地址。');
+  const url = process.env.RELAY_URL || serviceEndpoints.resolveRelayUrl(config.url);
+  if (!url) throw new Error('请先配置 self-relay-config.json 的 url，详见自建中继文档。');
+  relayAddress(url);
+  const resolved = relayAddress(url);
+  const pairingUrl = config.pairingUrl || (resolved === serviceEndpoints.relayUrl ? serviceEndpoints.pairingUrl : `${resolved.startsWith('wss:') ? 'https:' : 'http:'}//${new URL(resolved).host}/pair`);
+  const pairing = new URL(pairingUrl);
+  if (!['https:', 'http:'].includes(pairing.protocol) || pairing.pathname !== '/pair' || pairing.search || pairing.hash || pairing.username || pairing.password ||
+      (pairing.protocol === 'http:' && pairing.hostname !== '127.0.0.1')) throw new Error('self-relay-config.json 的 pairingUrl 必须是 HTTPS /pair 地址。');
   return { ...config, url: resolved, pairingUrl: pairing.href };
 }
-async function registrationKey(config) {
-  if (config.url === officialConfig.url) return undefined;
-  const hostKeyFile = process.env.RELAY_HOST_KEY_FILE || config.hostKeyFile;
-  let hostKey;
-  if (hostKeyFile) hostKey = fs.readFileSync(hostKeyFile, 'utf8').trim();
-  else {
-    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(config.sshHost || '') ||
-      !/^\/[a-zA-Z0-9/_.-]+$/.test(config.sshKeyPath || '')) throw new Error('中继注册凭据配置不完整或无效。');
-    try {
-      const result = await exec('ssh', ['-o', 'BatchMode=yes', '-o', 'ConnectTimeout=10', config.sshHost,
-        `sudo -n cat ${config.sshKeyPath}`], { encoding: 'utf8', timeout: 15000, windowsHide: true });
-      hostKey = result.stdout.trim();
-    } catch { throw new Error('无法通过已配置 SSH 读取中继注册凭据。'); }
-  }
-  if (!validSecret(hostKey)) throw new Error('中继注册凭据格式无效。');
-  return hostKey;
-}
 export async function selfRelay(command, stateRoot) {
   const session = readRecord(path.join(stateRoot, 'bridge-session.json'));
   if (!session) {
@@ -64,142 +44,162 @@ export async function selfRelay(command, stateRoot) {
 }
 
 async function createRelayRuntime(stateRoot) {
-  const config = await loadConfig(stateRoot);
-  const session = () => readRecord(path.join(stateRoot, 'bridge-session.json'));
-  let health = await serviceHealth(session());
+  const config = await loadConfig(stateRoot);
+  const configPath = path.join(stateRoot, 'self-relay-config.json');
+  const session = () => readRecord(path.join(stateRoot, 'bridge-session.json'));
+  let health = await serviceHealth(session());
   if (health?.status !== 'ok') throw new Error('桌面服务尚未运行，请先执行 relax start --json。');
   const stored = await credentialStore('load');
-  const identities = stored.record || { version: 1, servers: {} };
-  const validate = value => {
-    if (value?.version !== 1 || !value.servers || typeof value.servers !== 'object' || Array.isArray(value.servers)) throw new Error('本机设备身份损坏，未自动覆盖');
-    for (const [url, item] of Object.entries(value.servers)) {
-      relayAddress(url);
-      if (!validSecret(item.secret) || !/^[\w-]{16,128}$/.test(item.id)) throw new Error('本机设备身份损坏，未自动覆盖');
-    }
-  };
-  validate(identities);
-  let identity = identities.servers[config.url];
+  let identities = stored.record || { version: 2, devices: {} };
+  const validIdentity = (id, item) => /^[\w-]{16,128}$/.test(id) && item?.id === id &&
+    validSecret(item.secret) && typeof item.registered === 'boolean';
+  if (identities.version === 1 && identities.servers && typeof identities.servers === 'object' && !Array.isArray(identities.servers)) {
+    const devices = {};
+    for (const [url, item] of Object.entries(identities.servers)) {
+      relayAddress(url);
+      if (!validIdentity(item?.id, item) || devices[item.id]) throw new Error('本机设备身份损坏，未自动覆盖');
+      devices[item.id] = item;
+    }
+    const previous = identities.servers[config.url];
+    identities = { version: 2, devices };
+    await credentialStore('save', identities);
+    if (!config.deviceId && previous) config.deviceId = previous.id;
+  }
+  if (identities.version !== 2 || !identities.devices || typeof identities.devices !== 'object' || Array.isArray(identities.devices) ||
+      Object.entries(identities.devices).some(([id, item]) => !validIdentity(id, item))) throw new Error('本机设备身份损坏，未自动覆盖');
+  if (!config.deviceId) {
+    const known = Object.values(identities.devices);
+    if (known.length > 1) throw new Error('存在多个工作站身份，请在 self-relay-config.json 中指定 deviceId。');
+    config.deviceId = known[0]?.id || randomUUID();
+  }
+  const createIdentity = config.deviceId === 'new';
+  if (createIdentity) config.deviceId = randomUUID();
+  if (!/^[\w-]{16,128}$/.test(config.deviceId)) throw new Error('self-relay-config.json 的 deviceId 无效。');
+  let identity = identities.devices[config.deviceId];
   if (!identity) {
-    identity = { id: randomUUID(), secret: randomBytes(32).toString('base64url'), registered: false };
-    identities.servers[config.url] = identity; await credentialStore('save', identities);
+    if (!createIdentity && Object.keys(identities.devices).length) throw new Error('找不到配置指定的工作站身份，未自动创建新身份。');
+    identity = { id: config.deviceId, secret: randomBytes(32).toString('base64url'), registered: false };
+    identities.devices[identity.id] = identity;
+    await credentialStore('save', identities);
   }
-  const hostKey = identity.registered ? undefined : await registrationKey(config);
+  const persistedConfig = readRecord(configPath) || {};
+  if (persistedConfig.deviceId !== identity.id) writeRecord(configPath, { ...persistedConfig, deviceId: identity.id });
   let bridgeError = '';
-  async function refreshHealth() {
+  async function refreshHealth() {
     try { health = await serviceHealth(session()) || { transportMode: health.transportMode, status: 'offline' }; bridgeError = ''; }
     catch (error) { bridgeError = error.message; health = { transportMode: health.transportMode, status: 'offline' }; }
-  }
+  }
   let connector, qrPath, expiresAt = 0, paired = false, clientCount = 0, attachedCount = 0;
-  let closing = false, online = false, connecting = false, retryTimer, attempts = 0, lastError = '';
-  const audit = (event, details = {}) => console.log(JSON.stringify({ time: new Date().toISOString(), event, ...details }));
-  async function currentLanCandidates() {
-    try {
-      const bridge = session(), port = bridge?.port || 45831;
-      return (await lanNetworks()).map(network => ({ ...network, address: `http://${network.address}:${port}` }));
-    } catch (error) {
-      audit('lan-candidates-unavailable', { message: error.message }); return [];
-    }
-  }
-  const status = () => {
-    const available = online && !paired && qrPath && Date.now() < expiresAt;
-    const next = !online ? (lastError || '电脑连接器正在恢复中继连接，已保存授权。')
-      : paired ? '设备已授权，移动端可直接重连；网络断开不需要重新扫码。'
-        : available ? '用要添加的移动设备在有效期内扫描统一配对二维码。连接器在后台运行。'
+  let closing = false, online = false, connecting = false, retryTimer, attempts = 0, lastError = '';
+  const audit = (event, details = {}) => console.log(JSON.stringify({ time: new Date().toISOString(), event, ...details }));
+  async function currentLanCandidates() {
+    try {
+      const bridge = session(), port = bridge?.port || 45831;
+      return (await lanNetworks()).map(network => ({ ...network, address: `http://${network.address}:${port}` }));
+    } catch (error) {
+      audit('lan-candidates-unavailable', { message: error.message }); return [];
+    }
+  }
+  const status = () => {
+    const available = online && !paired && qrPath && Date.now() < expiresAt;
+    const next = !online ? (lastError || '电脑连接器正在恢复中继连接，已保存授权。')
+      : paired ? '设备已授权，移动端可直接重连；网络断开不需要重新扫码。'
+        : available ? '用要添加的移动设备在有效期内扫描统一配对二维码。连接器在后台运行。'
           : '尚未完成设备授权；调用 relax pair --json 生成配对二维码。';
-    return { running: !closing, relayConnected: online, mode: 'self-relay', transportMode: health.transportMode,
-      relayUrl: config.url, deviceId: identity.id, paired, clientCount, authorization: online ? (paired ? 'authorized' : 'unpaired') : 'unverified', phoneConnected: attachedCount > 0,
+    return { running: !closing, relayConnected: online, mode: 'self-relay', transportMode: health.transportMode,
+      relayUrl: config.url, deviceId: identity.id, paired, clientCount, authorization: online ? (paired ? 'authorized' : 'unpaired') : 'unverified', phoneConnected: attachedCount > 0,
       bridgeReady: health.status === 'ok' && health.execution?.ready === true && health.sharedAppServerConnected === true, bridgeError,
-      expiresAt: expiresAt ? new Date(expiresAt).toISOString() : null,
-      ...(available ? { qrPath } : {}), mobileAccess: 'unverified', lastError,
+      expiresAt: expiresAt ? new Date(expiresAt).toISOString() : null,
+      ...(available ? { qrPath } : {}), mobileAccess: 'unverified', lastError,
       displayText: `Code Relax 中继 · ${health.transportMode === 'lan-shared' ? 'Codex 内核已就绪' : 'Codex 内核未就绪'}\n${next}` };
-  };
-  async function shutdown() {
-    if (closing) return;
-    closing = true; clearTimeout(retryTimer);
-    connector?.events.removeAllListeners(); connector?.close();
-  }
-  async function saveInvitation(message) {
-    if (!message.code) return;
-    expiresAt = message.expires;
-    const link = new URL(config.pairingUrl);
-    link.searchParams.set('invite', message.code);
-    // Keep previously displayed files intact even when their invitation expires.
-    qrPath = path.join(stateRoot, `self-relay-qr-${randomUUID()}.png`);
-    await QRCode.toFile(qrPath, link.href, { width: 640, margin: 3 });
-  }
-  function scheduleRetry() {
-    if (closing || retryTimer) return;
-    const delay = Math.min(1000 * 2 ** Math.min(attempts++, 5), 30000) * (0.8 + Math.random() * 0.2);
-    retryTimer = setTimeout(() => { retryTimer = undefined; void connect(); }, delay);
-  }
-  async function connect() {
-    if (closing || connecting) return;
-    connecting = true;
-    let retryAfterAttempt = false;
-    try {
-      const bridge = session();
-      await refreshHealth();
-      const lanCandidates = await currentLanCandidates();
-      connector?.events.removeAllListeners(); connector?.close();
-      const current = connector = connectBridgeRelay({ relayUrl: config.url, hostKey: identity.registered ? undefined : hostKey, identity,
+  };
+  async function shutdown() {
+    if (closing) return;
+    closing = true; clearTimeout(retryTimer);
+    connector?.events.removeAllListeners(); connector?.close();
+  }
+  async function saveInvitation(message) {
+    if (!message.code) return;
+    expiresAt = message.expires;
+    const link = new URL(config.pairingUrl);
+    link.searchParams.set('invite', message.code);
+    // Keep previously displayed files intact even when their invitation expires.
+    qrPath = path.join(stateRoot, `self-relay-qr-${randomUUID()}.png`);
+    await QRCode.toFile(qrPath, link.href, { width: 640, margin: 3 });
+  }
+  function scheduleRetry() {
+    if (closing || retryTimer) return;
+    const delay = Math.min(1000 * 2 ** Math.min(attempts++, 5), 30000) * (0.8 + Math.random() * 0.2);
+    retryTimer = setTimeout(() => { retryTimer = undefined; void connect(); }, delay);
+  }
+  async function connect() {
+    if (closing || connecting) return;
+    connecting = true;
+    let retryAfterAttempt = false;
+    try {
+      const bridge = session();
+      await refreshHealth();
+      const lanCandidates = await currentLanCandidates();
+      connector?.events.removeAllListeners(); connector?.close();
+      const current = connector = connectBridgeRelay({ relayUrl: config.url, identity,
         usageCacheFile: path.join(stateRoot, 'relay-usage-tasks.json'),
-        bridgeUrl: `ws://127.0.0.1:${bridge?.port || 45831}/api/socket`, bridgeToken: bridge?.accessUrl ? new URL(bridge.accessUrl).searchParams.get('token') : 'unavailable',
-        bridgeConnection: () => { const latest = session(); return { url: `ws://127.0.0.1:${latest.port}/api/socket`, token: new URL(latest.accessUrl).searchParams.get('token') }; },
+        bridgeUrl: `ws://127.0.0.1:${bridge?.port || 45831}/api/socket`, bridgeToken: bridge?.accessUrl ? new URL(bridge.accessUrl).searchParams.get('token') : 'unavailable',
+        bridgeConnection: () => { const latest = session(); return { url: `ws://127.0.0.1:${latest.port}/api/socket`, token: new URL(latest.accessUrl).searchParams.get('token') }; },
         hostName: hostname(), lanCandidates, p2pProbe: config.p2pProbe === true, iceServers: config.p2pIceServers || [],
         p2pWindowsRouteHelper: config.p2pWindowsRouteHelper === true, p2pWindowsRouteHelperToken: config.p2pWindowsRouteHelperToken || '' });
-      current.events.on('p2p-probe', result => audit('p2p-probe', result));
-      current.events.on('diagnostic', message => audit('transport-error', { message }));
-      current.events.on('attached', () => { paired = true; attachedCount++; audit('phone-attached', { attachedCount }); });
-      current.events.on('detached', () => { attachedCount = Math.max(0, attachedCount - 1); audit('phone-detached', { attachedCount }); });
-      current.events.on('authorization-changed', update => {
-        saveLanAuthorizations(stateRoot, identity.id, update.clients, update.revision);
-        paired = update.clients.length > 0; clientCount = update.clients.length;
-        audit('mobile-authorizations-updated', { clientCount, revision: update.revision });
-      });
-      current.events.once('disconnected', event => {
-        if (connector !== current || closing) return;
-        online = false; attachedCount = 0; lastError = `电脑与中继连接断开（${event.code}）：${event.reason}`; audit('relay-disconnected', event);
-        if (![1008, 4401, 4406, 4409, 4429].includes(event.code)) scheduleRetry();
-      });
-      const registration = await current.ready;
+      current.events.on('p2p-probe', result => audit('p2p-probe', result));
+      current.events.on('diagnostic', message => audit('transport-error', { message }));
+      current.events.on('attached', () => { paired = true; attachedCount++; audit('phone-attached', { attachedCount }); });
+      current.events.on('detached', () => { attachedCount = Math.max(0, attachedCount - 1); audit('phone-detached', { attachedCount }); });
+      current.events.on('authorization-changed', update => {
+        saveLanAuthorizations(stateRoot, identity.id, update.clients, update.revision);
+        paired = update.clients.length > 0; clientCount = update.clients.length;
+        audit('mobile-authorizations-updated', { clientCount, revision: update.revision });
+      });
+      current.events.once('disconnected', event => {
+        if (connector !== current || closing) return;
+        online = false; attachedCount = 0; lastError = `电脑与中继连接断开（${event.code}）：${event.reason}`; audit('relay-disconnected', event);
+        if (![1008, 4401, 4406, 4409, 4429].includes(event.code)) scheduleRetry();
+      });
+      const registration = await current.ready;
       if (registration.protocolVersion !== 7 || registration.room !== identity.id) {
-        current.events.removeAllListeners(); current.close(); throw Object.assign(new Error('中继服务器尚未升级设备授权协议，未使用临时配对降级。'), { code: 4401 });
-      }
-      if (!identity.registered) {
-        const registeredIdentity = { ...identity, registered: true };
-        identities.servers[config.url] = registeredIdentity;
-        await credentialStore('save', identities); identity = registeredIdentity;
-      }
-      current.assertConnected();
-      online = true; attempts = 0; paired = registration.paired; clientCount = registration.clientCount || 0; lastError = '';
-      saveLanAuthorizations(stateRoot, identity.id, registration.clients || [], registration.revision);
-      await saveInvitation(registration); audit('relay-connected', { paired });
-    } catch (error) {
-      online = false; lastError = error.message; audit('connect-failed', { message: error.message });
-      if (![1008, 4401, 4406, 4409, 4429].includes(error.code)) retryAfterAttempt = true;
-      else { clearTimeout(retryTimer); retryTimer = undefined; }
-    } finally { connecting = false; if (retryAfterAttempt) scheduleRetry(); }
-  }
-  async function pair() {
-    if (!online || closing) throw new Error('中继尚未连接，设备授权保持不变。');
-    await saveInvitation(await connector.command('pair-code'));
-    // Each invitation adds or refreshes one mobile identity without revoking other devices.
-    return { ...status(), qrPath, expiresAt: new Date(expiresAt).toISOString(),
-      displayText: '用要添加的移动设备扫描此码。每台设备只需配对一次；已有设备授权保持不变。' };
-  }
-  async function revoke() {
-    if (!online || closing) throw new Error('中继尚未连接，未撤销授权。');
-    await connector.command('revoke'); paired = false; clientCount = 0; attachedCount = 0; qrPath = undefined; expiresAt = 0;
+        current.events.removeAllListeners(); current.close(); throw Object.assign(new Error('中继服务器尚未升级设备授权协议，未使用临时配对降级。'), { code: 4401 });
+      }
+      if (!identity.registered) {
+        const registeredIdentity = { ...identity, registered: true };
+        identities.devices[identity.id] = registeredIdentity;
+        await credentialStore('save', identities); identity = registeredIdentity;
+      }
+      current.assertConnected();
+      online = true; attempts = 0; paired = registration.paired; clientCount = registration.clientCount || 0; lastError = '';
+      saveLanAuthorizations(stateRoot, identity.id, registration.clients || [], registration.revision);
+      await saveInvitation(registration); audit('relay-connected', { paired });
+    } catch (error) {
+      online = false; lastError = error.message; audit('connect-failed', { message: error.message });
+      if (![1008, 4401, 4406, 4409, 4429].includes(error.code)) retryAfterAttempt = true;
+      else { clearTimeout(retryTimer); retryTimer = undefined; }
+    } finally { connecting = false; if (retryAfterAttempt) scheduleRetry(); }
+  }
+  async function pair() {
+    if (!online || closing) throw new Error('中继尚未连接，设备授权保持不变。');
+    await saveInvitation(await connector.command('pair-code'));
+    // Each invitation adds or refreshes one mobile identity without revoking other devices.
+    return { ...status(), qrPath, expiresAt: new Date(expiresAt).toISOString(),
+      displayText: '用要添加的移动设备扫描此码。每台设备只需配对一次；已有设备授权保持不变。' };
+  }
+  async function revoke() {
+    if (!online || closing) throw new Error('中继尚未连接，未撤销授权。');
+    await connector.command('revoke'); paired = false; clientCount = 0; attachedCount = 0; qrPath = undefined; expiresAt = 0;
     return { ...status(), displayText: '全部移动设备授权已撤销；重新添加请调用 relax pair --json。' };
-  }
-  async function refreshLan() {
-    if (!online || closing) throw new Error('中继尚未连接，未更新局域网候选。');
-    await refreshHealth();
-    const candidates = await currentLanCandidates();
-    connector.updateLanCandidates(candidates);
-    audit('lan-candidates-updated', { count: candidates.length });
-    return { ...status(), lanCandidateCount: candidates.length };
-  }
+  }
+  async function refreshLan() {
+    if (!online || closing) throw new Error('中继尚未连接，未更新局域网候选。');
+    await refreshHealth();
+    const candidates = await currentLanCandidates();
+    connector.updateLanCandidates(candidates);
+    audit('lan-candidates-updated', { count: candidates.length });
+    return { ...status(), lanCandidateCount: candidates.length };
+  }
   const inspect = async () => {
     if (online) {
       const remote = await connector.command('status'); paired = remote.paired;

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

@@ -4,6 +4,7 @@ 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';
 
 const sqlTime = value => value.replace('T', ' ').replace(/Z$/, '');
 const isoTime = value => value.replace(' ', 'T') + 'Z';
@@ -17,7 +18,7 @@ export async function openRelayMysql(configFile, initialMaxRelaySessions) {
     namedPlaceholders: false, dateStrings: true, timezone: 'Z', multipleStatements: false });
   try {
     const [versions] = await pool.query('SELECT version, sha256 FROM schema_migrations');
-    const knownVersions = ['001_relay_core', '002_email_accounts', '003_relay_usage', '004_relay_usage_actions', '005_relay_usage_diagnostics'];
+    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');

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

@@ -12,7 +12,7 @@ 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';
+import { relayDiagnostics } from './diagnostics.mjs';
 
 // Always loopback; a TLS reverse proxy supplies the private-trial Internet endpoint.
 export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlMs = 120000,
@@ -32,8 +32,8 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
   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 diagnostics = database?.schemaVersions.includes('006_relay_diagnostics')
+    ? relayDiagnostics(database.pool, error => log({ event: 'relay-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);
@@ -180,20 +180,22 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
     }
     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))) {
+      const view = target.searchParams.get('view') || 'user';
+      if (!Number.isSafeInteger(page) || page < 1 || page > 100000 ||
+          !['user', 'computer'].includes(view) || target.searchParams.has('user') ||
+          target.searchParams.has('computer')) {
         adminReply(response, 400, { error: 'Invalid usage query' }); return;
       }
-      adminReply(response, 200, await usageReport(database.pool, page, user)); return;
+      adminReply(response, 200, await usageReport(database.pool, page, view)); 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());
+      if (request.method === 'GET') adminReply(response, 200, await diagnostics.read('usage'));
+      else if (request.method === 'DELETE') adminReply(response, 200, await diagnostics.clear('usage'));
       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());
+      if (request.method === 'POST') adminReply(response, 200, await diagnostics.drain('usage'));
       else adminReply(response, 405, { error: 'Unsupported diagnostic request' });
       return;
     }
@@ -457,7 +459,6 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
             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 });
@@ -478,10 +479,9 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
             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');
+                diagnostics?.record('usage', '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);
@@ -489,30 +489,26 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
               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');
+                diagnostics?.record('usage', '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 (counted && message.turnKind === 'steer') diagnostics?.record('usage', 'turn-recovered', 'steer');
                     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);
@@ -523,10 +519,10 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
                     }
                   }
                 }
-              } catch (error) { diagnostics?.record('message-error', 'database'); log({ event: 'usage-error', message: error.message }); }
+              } catch (error) { diagnostics?.record('usage', 'message-error', 'database'); log({ event: 'usage-error', message: error.message }); }
               return;
             }
-            if (!['turn/started', 'turn/completed', 'heartbeat', 'resume'].includes(message.method) ||
+            if (!['turn/started', 'turn/completed', 'heartbeat', 'resume', 'inactive'].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;
@@ -534,14 +530,17 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
             try {
               if (message.method === 'resume' && !task) {
                 task = await meter.turnOrigin(room.id, key);
-                if (!task) { diagnostics?.record('turn-resume', 'origin-missing'); return; }
+                if (!task) { diagnostics?.record('usage', 'turn-resume', 'origin-missing'); return; }
                 await meter.pulse(task, true, room.id, task.clientId, `${key}:${randomUUID()}`);
-                diagnostics?.record('turn-resume', 'confirmed');
+                diagnostics?.record('usage', '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 === 'inactive') {
+                await meter.lost(task);
+                room.usageTasks.delete(key);
+              }
               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 }); }

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

@@ -0,0 +1,55 @@
+const dayMs = 86400000;
+const chinaOffsetMs = 8 * 3600000;
+
+export function usageDaySlices(start, end) {
+  const slices = [];
+  for (let cursor = start; cursor < end;) {
+    const date = new Date(cursor + chinaOffsetMs).toISOString().slice(0, 10);
+    const nextDay = Date.parse(`${date}T00:00:00Z`) + dayMs - chinaOffsetMs;
+    const until = Math.min(end, nextDay);
+    slices.push({ date, start: cursor, end: until });
+    cursor = until;
+  }
+  return slices;
+}
+
+const readIntervals = value => Array.isArray(value) ? value : JSON.parse(value || '[]');
+
+export function mergeUsageIntervals(existing, start, end) {
+  const sorted = [...existing, [start, end]].sort((a, b) => a[0] - b[0]);
+  const merged = [];
+  for (const range of sorted) {
+    const last = merged.at(-1);
+    if (last && range[0] <= last[1]) last[1] = Math.max(last[1], range[1]);
+    else merged.push([...range]);
+  }
+  return { intervals: merged, seconds: merged.reduce((sum, [from, until]) => sum + until - from, 0) / 1000 };
+}
+
+export async function recordDailyUsage(db, userId, computerId, free, start, end, now) {
+  for (const slice of usageDaySlices(start, end)) {
+    await db.execute(`INSERT IGNORE INTO relay_usage_user_days
+      (user_id,usage_date,intervals,updated_at) VALUES (?,?,'[]',?)`, [userId, slice.date, now]);
+    const [userRows] = await db.execute(`SELECT intervals FROM relay_usage_user_days
+      WHERE user_id=? AND usage_date=? FOR UPDATE`, [userId, slice.date]);
+    const user = mergeUsageIntervals(readIntervals(userRows[0].intervals), slice.start, slice.end);
+    await db.execute(`UPDATE relay_usage_user_days SET intervals=?,task_seconds=?,updated_at=?
+      WHERE user_id=? AND usage_date=?`,
+      [JSON.stringify(user.intervals), user.seconds, now, userId, slice.date]);
+
+    await db.execute(`INSERT IGNORE INTO relay_usage_computer_days
+      (computer_id,usage_date,intervals,free_intervals,updated_at) VALUES (?,?,'[]','[]',?)`,
+      [computerId, slice.date, now]);
+    const [computerRows] = await db.execute(`SELECT intervals,free_intervals FROM relay_usage_computer_days
+      WHERE computer_id=? AND usage_date=? FOR UPDATE`, [computerId, slice.date]);
+    const computer = mergeUsageIntervals(readIntervals(computerRows[0].intervals), slice.start, slice.end);
+    const freeIntervals = readIntervals(computerRows[0].free_intervals);
+    const freeComputer = free ? mergeUsageIntervals(freeIntervals, slice.start, slice.end) : null;
+    await db.execute(`UPDATE relay_usage_computer_days SET intervals=?,task_seconds=?,
+      free_intervals=?,free_task_seconds=COALESCE(?,free_task_seconds),updated_at=?
+      WHERE computer_id=? AND usage_date=?`,
+      [JSON.stringify(computer.intervals), computer.seconds,
+        JSON.stringify(freeComputer?.intervals || freeIntervals), freeComputer?.seconds ?? null,
+        now, computerId, slice.date]);
+  }
+}