@walkhi/code-relax 0.1.0-beta.18 → 0.1.0-beta.19

package/dist/bin/migrate-relay-db.mjs

@@ -13,7 +13,7 @@ if (!['--schema', '--import', '--check'].includes(command) || !process.env.RELAY
 const config = JSON.parse(fs.readFileSync(process.env.RELAY_MYSQL_CONFIG_FILE, 'utf8'));
 const db = await mysql.createConnection({ ...config, dateStrings: true, timezone: 'Z', multipleStatements: false });
 const sqlTime = value => value.replace('T', ' ').replace(/Z$/, '');
-const migrations = ['001_relay_core', '002_email_accounts', '003_relay_usage', '004_relay_usage_actions'];
+const migrations = ['001_relay_core', '002_email_accounts', '003_relay_usage', '004_relay_usage_actions', '005_relay_usage_diagnostics'];
 try {
   if (command === '--schema') {
     const [existing] = await db.query("SHOW TABLES LIKE 'schema_migrations'");
@@ -42,6 +42,7 @@ try {
       if (versions.some(row => row.version === '002_email_accounts')) names.push('email_login_challenges', 'user_sessions', 'email_send_limits');
       if (versions.some(row => row.version === '003_relay_usage')) names.push('relay_admin_emails', 'relay_usage_settings', 'relay_usage_totals', 'relay_usage_computer_totals', 'relay_usage_entitlements', 'relay_usage_budgets', 'relay_usage_computer_budgets', 'relay_usage_sessions');
       if (versions.some(row => row.version === '004_relay_usage_actions')) names.push('relay_usage_actions');
+      if (versions.some(row => row.version === '005_relay_usage_diagnostics')) names.push('relay_usage_diagnostics');
       const counts = {};
       for (const name of names) { const [rows] = await db.query(`SELECT COUNT(*) AS count FROM ${name}`); counts[name] = rows[0].count; }
       if (process.env.RELAY_STATE_FILE && process.env.RELAY_ADMIN_STATE_FILE) {

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

@@ -52,6 +52,7 @@ if (revokeIndex >= 0) {
   console.log('Computer and phone authorization revoked'); process.exit(0);
 }
 const relay = await startSelfRelay({ port, hostKey, stateFile, mysqlConfigFile, accountConfigFile, debugAllowlistFile, adminStateFile, maxRelaySessions,
+  usageDiagnosticKeyFile: process.env.RELAY_USAGE_DIAGNOSTIC_KEY_FILE,
   publicRelayUrl: process.env.RELAY_PUBLIC_URL || '', appDownloadUrl: process.env.RELAY_APP_DOWNLOAD_URL || '',
   log: entry => console.log(JSON.stringify({ time: new Date().toISOString(), ...entry })) });
 console.log(JSON.stringify({ service: 'codex-self-relay', listen: relay.url, maxConnections: 32, maxRelaySessions,

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

@@ -25,7 +25,7 @@ export async function startAdminServer({ port = 45851, relayUrl = 'http://127.0.
     if (request.method === 'GET' && target.pathname === '/admin/usage') {
       reply(response, 200, adminUsagePage(), 'text/html; charset=utf-8'); return;
     }
-    if (request.method === 'GET' && ['/admin/api/status', '/admin/api/session', '/admin/api/usage'].includes(target.pathname)) {
+    if (request.method === 'GET' && ['/admin/api/status', '/admin/api/session', '/admin/api/usage', '/admin/api/usage-diagnostics'].includes(target.pathname)) {
       try {
         const upstream = await fetch(new URL(target.pathname + target.search, relayOrigin), {
           signal: AbortSignal.timeout(3000), headers: { Authorization: request.headers.authorization || '' } });
@@ -38,7 +38,7 @@ export async function startAdminServer({ port = 45851, relayUrl = 'http://127.0.
       }
       return;
     }
-    if (!target.pathname.startsWith('/admin/api/') || !['PUT', 'DELETE'].includes(request.method || '')) {
+    if (!target.pathname.startsWith('/admin/api/') || !['PUT', 'DELETE', 'POST'].includes(request.method || '')) {
       reply(response, 404, { error: 'Not found' }); return;
     }
     try {

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

@@ -228,8 +228,9 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
             const request = decode(payload, false);
             if (!['request', 'subscribe', 'unsubscribe'].includes(request.type)) throw new Error('Unsupported LAN message');
             if (request.type === 'request' && request.method === 'POST' && Number.isSafeInteger(request.id)) {
-              const existing = /^\/api\/threads\/([^/?]+)\/(?:messages|queue)$/.exec(request.path || '');
-              const created = /^\/api\/projects\/[^/?]+\/threads$/.test(request.path || '');
+              const path = (request.path || '').split('?')[0];
+              const existing = /^\/api\/threads\/([^/?]+)\/(?:messages|queue)$/.exec(path);
+              const created = /^\/api\/projects\/[^/?]+\/threads$/.test(path);
               if (existing || created) {
                 const threadId = existing ? decodeURIComponent(existing[1]) : null;
                 const messageKey = typeof request.body?.clientUserMessageId === 'string' && request.body.clientUserMessageId.length <= 64

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

@@ -17,7 +17,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'];
+    const knownVersions = ['001_relay_core', '002_email_accounts', '003_relay_usage', '004_relay_usage_actions', '005_relay_usage_diagnostics'];
     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

@@ -1,7 +1,8 @@
 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';
@@ -11,11 +12,13 @@ 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, mysqlConfigFile, accountConfigFile, 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');
@@ -29,6 +32,10 @@ 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 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 = database?.admin || relayAdminState(adminStateFile, maxRelaySessions);
@@ -147,11 +154,17 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
     }
     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;
-      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 (!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;
       }
@@ -173,6 +186,17 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
       }
       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 {
@@ -433,6 +457,7 @@ 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 });
@@ -453,27 +478,41 @@ 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)))) return;
+                  (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') { room.usageArms.delete(armKey); 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)) return;
+              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 (message.turnKind === 'start' && plainText(message.threadId, 80, false) && plainText(message.turnId, 80, false)) {
                   const key = `${message.threadId}:${message.turnId}`;
                   if (key.length <= 128 && !room.usageTasks.has(key)) {
                     const task = { userId: arm.userId, clientId: arm.clientId };
                     await meter.action(task, room.id, arm.clientId, 'turn', key);
+                    diagnostics?.record('turn-counted', 'confirmed');
                     if (message.observerReady === true) {
                       await meter.pulse(task, true, room.id, arm.clientId, key);
                       if (message.completed) await meter.pulse(task, false, room.id, arm.clientId);
@@ -481,7 +520,7 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
                     }
                   }
                 }
-              } catch (error) { log({ event: 'usage-error', message: error.message }); }
+              } 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) ||
@@ -492,12 +531,14 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
             try {
               if (message.method === 'resume' && !task) {
                 task = await meter.turnOrigin(room.id, key);
-                if (!task) return;
+                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 }); }

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walkhi/code-relax",
-  "version": "0.1.0-beta.18",
+  "version": "0.1.0-beta.19",
   "license": "UNLICENSED",
   "type": "module",
   "scripts": {