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

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

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

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

@@ -19,6 +19,8 @@ import { accountConnections } from './account-connections.mjs';
 import { usageMeter, usageReport } from './usage-meter.mjs';
 import { relayDiagnostics } from './diagnostics.mjs';
 import { connectionInfo, deviceInfo } from './device-info.mjs';
+import { listWorkstations, workstationDetail, workstationSummary, resolveWorkstationAccounts, resolveWorkstationConnections } from './admin-workstations.mjs';
+import { phoneConnectionEvents, validPhoneConnection } from './phone-connections.mjs';
 
 // Always loopback; a TLS reverse proxy supplies the private-trial Internet endpoint.
 export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlMs = 120000,
@@ -57,6 +59,7 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
   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 phoneEvents = phoneConnectionEvents(database?.pool);
   const debugAllowlist = readDebugAllowlist(debugAllowlistFile);
   const adminState = database?.admin || relayAdminState(adminStateFile, maxRelaySessions);
   let activeRelaySessions = 0;
@@ -295,6 +298,21 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
     const diagnosticAccess = diagnosticRoute && diagnosticKey && token &&
       timingSafeEqual(Buffer.from(token), Buffer.from(diagnosticKey));
     if (!internalAccess && !diagnosticAccess) { adminReply(response, 404, { error: 'Not found' }); return; }
+    if (request.method === 'GET' && target.pathname === '/admin/api/workstations') {
+      const workstations = await resolveWorkstationAccounts(listWorkstations(rooms, { details: true }), database?.pool);
+      await resolveWorkstationConnections(workstations, phoneEvents);
+      adminReply(response, 200, { sampledAt: new Date().toISOString(), workstations: workstations.map(workstationSummary) }); return;
+    }
+    if (request.method === 'GET' && target.pathname.startsWith('/admin/api/workstations/')) {
+      const id = target.pathname.slice('/admin/api/workstations/'.length);
+      const room = validId(id) && rooms.get(id);
+      if (!room) { adminReply(response, 404, { error: '未找到工作站' }); return; }
+      const [workstation] = await resolveWorkstationAccounts([
+        workstationDetail(room, debugAllowlist.devices.some(entry => entry.deviceId === room.id))], database?.pool);
+      await resolveWorkstationConnections([workstation], phoneEvents);
+      workstation.connectionEvents = await phoneEvents.list(room.id);
+      adminReply(response, 200, { sampledAt: new Date().toISOString(), workstation }); return;
+    }
     if (request.method === 'GET' && target.pathname === '/admin/api/status') {
       const state = adminState.read();
       adminReply(response, 200, { maxRelaySessions: state.maxRelaySessions, activeRelaySessions,
@@ -402,10 +420,14 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
     if (wss.clients.size >= maxConnections || ++admissions > 240) {
       socket.end('HTTP/1.1 429 Too Many Requests\r\nConnection: close\r\n\r\n'); return;
     }
-    wss.handleUpgrade(request, socket, head, ws => wss.emit('connection', ws));
+    wss.handleUpgrade(request, socket, head, ws => wss.emit('connection', ws, request));
   });
-  wss.on('connection', ws => {
+  wss.on('connection', (ws, request) => {
+    const address = request.headers['x-real-ip'];
+    ws.adminInfo = { connectedAt: new Date().toISOString(),
+      address: typeof address === 'string' && isIP(address) ? address : request.socket.remoteAddress };
     let role, room, session, clientId, alive = true;
+    const phoneEventIds = new Set();
     let accountConnection;
     function invalidateAccountConnection() {
       if (role === 'client' && room?.connections.get(clientId)?.ws === ws) {
@@ -533,6 +555,7 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
               const user = await accounts.current(message.accountToken);
               if (!accountConnection.activate(user.expiresAt)) return;
               userId = user.id;
+              ws.adminInfo.account = { id: user.id, email: user.email };
             }
             catch { return fail(4431, 'Account session invalid'); }
             if (ws.readyState !== ws.OPEN) return;
@@ -591,6 +614,8 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
               room.usageTasks?.clear(); room.usageArms?.clear();
             }
             room.host = ws; room.hostName = hostName; room.lanCandidates = lanCandidates;
+            room.adminPhoneConnections = undefined;
+            room.adminLastOnlineAt = ws.adminInfo.connectedAt; room.adminLastHostName = hostName;
             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;
@@ -682,7 +707,8 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
           if (room.lanCandidates?.length) send(ws, { type: 'lan-candidates', candidates: room.lanCandidates });
           const announcement = adminState.read().announcement;
           if (announcement) send(ws, { type: 'announcement', announcement });
-          send(room.host, { type: 'attach', session, clientId, p2pProbe: room.connections.get(clientId).p2pProbe ? 1 : 0 }); return;
+          send(room.host, { type: 'attach', session, clientId, chat: Boolean(userId),
+            p2pProbe: room.connections.get(clientId).p2pProbe ? 1 : 0 }); return;
         }
         if (role === 'device-manager') {
           if (!room.clients.some(item => item.id === clientId)) return fail(4401, 'Device authorization revoked');
@@ -690,12 +716,44 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
           await manageDevices(room, ws, message, clientId); return;
         }
         if (role === 'host') {
+          if (['phone-connection', 'phone-connections'].includes(message.type)) {
+            if (room.host !== ws) return;
+            if (message.type === 'phone-connections') {
+              if (!Array.isArray(message.active) || message.active.length > 128 ||
+                  message.active.some(item => !validPhoneConnection(item))) return fail(1008, 'Invalid phone connection snapshot');
+              room.adminPhoneConnections = new Map(message.active.filter(item => room.clients.some(client => client.id === item.clientId))
+                .map(item => [item.connectionId, { connectionId: item.connectionId, clientId: item.clientId, mode: item.mode }]));
+              return;
+            }
+            const event = message.event;
+            if (!validPhoneConnection(event)) return fail(1008, 'Invalid phone connection event');
+            // Revocation can overtake the workstation's final close event.
+            if (!room.clients.some(client => client.id === event.clientId)) {
+              send(ws, { type: 'phone-connection-ack', id: event.id }); return;
+            }
+            try { await phoneEvents.record(room.id, event); }
+            catch (error) { log({ event: 'phone-connection-error', message: error.message }); return; }
+            if (room.host !== ws) return;
+            if (phoneEventIds.has(event.id)) { send(ws, { type: 'phone-connection-ack', id: event.id }); return; }
+            phoneEventIds.add(event.id);
+            if (phoneEventIds.size > 256) phoneEventIds.delete(phoneEventIds.values().next().value);
+            room.adminPhoneConnections ||= new Map();
+            if (event.state === 'connected') room.adminPhoneConnections.set(event.connectionId,
+              { connectionId: event.connectionId, clientId: event.clientId, mode: event.mode });
+            else room.adminPhoneConnections.delete(event.connectionId);
+            send(ws, { type: 'phone-connection-ack', id: event.id }); return;
+          }
           if (room.host !== ws) return;
           if (['devices-list', 'device-revoke'].includes(message.type)) { await manageDevices(room, ws, message); return; }
           if (message.type === 'device-connected') {
             const at = new Date(Math.min(Date.parse(message.at), Date.now())).toISOString();
             if (!validId(message.clientId)) return fail(1008, 'Invalid mobile identity');
             await recordConnection(room, message.clientId, at, deviceInfo(message));
+            room.adminLanConnections ||= new Map();
+            if (room.clients.some(client => client.id === message.clientId) &&
+                (!room.adminLanConnections.has(message.clientId) || room.adminLanConnections.get(message.clientId) < at)) {
+              room.adminLanConnections.set(message.clientId, at);
+            }
             return;
           }
           if (meter && ['usage-arm', 'usage-message', 'usage-cancel', 'usage-turn', 'usage-observer-lost'].includes(message.type)) {
@@ -874,12 +932,14 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
           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));
+          room.connections.get(clientId).adminRoute = 'direct';
         } else if (room.connections.get(clientId)?.ws === ws && message.type === 'data' && typeof message.payload === 'string') {
           const connection = room.connections.get(clientId);
           if (!connection.userId && !managementPayload(message.payload)) return fail(4431, 'Account login required');
           if (connection.userId && !controlPayload(message.payload) && !admitRelay(connection, room)) {
             ws.close(4428, 'Server busy'); return;
           }
+          if (connection.userId && !controlPayload(message.payload)) connection.adminRoute = 'relay';
           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'); }

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

@@ -1,141 +1,141 @@
-import { randomUUID } from 'node:crypto';
-import { recordDailyUsage } from './usage-daily.mjs';
-
-const epoch = value => new Date(`${value.replace(' ', 'T')}Z`).getTime();
-
-// Count confirmed intervals only; a lost connection never creates estimated time.
-export function usageMeter(pool) {
-  async function action(connection, computerId, clientId, kind, key) {
-    if (!connection.userId || !['message', 'turn'].includes(kind) || typeof key !== 'string' || !key || key.length > 128) return;
-    const column = kind === 'message' ? 'message_count' : 'turn_count';
-    const db = await pool.getConnection();
-    try {
-      await db.beginTransaction();
-      const [users] = await db.execute("SELECT id FROM users WHERE id=? AND status='active' FOR UPDATE", [connection.userId]);
-      if (!users.length) { await db.commit(); return false; }
-      const [result] = await db.execute(`INSERT IGNORE INTO relay_usage_actions
-        (computer_id,kind,action_key,user_id,client_id,occurred_at)
-        VALUES (?,?,?,?,?,UTC_TIMESTAMP(3))`,
-        [computerId, kind, key, connection.userId, clientId]);
-      if (result.affectedRows === 1) {
-        await db.execute(`INSERT INTO relay_usage_totals (user_id,${column},updated_at)
-          VALUES (?,1,UTC_TIMESTAMP(3)) ON DUPLICATE KEY UPDATE ${column}=${column}+1,
-          updated_at=VALUES(updated_at)`, [connection.userId]);
-        await db.execute(`INSERT INTO relay_usage_computer_totals (computer_id,${column},updated_at)
-          VALUES (?,1,UTC_TIMESTAMP(3)) ON DUPLICATE KEY UPDATE ${column}=${column}+1,
-          updated_at=VALUES(updated_at)`, [computerId]);
-      }
-      await db.commit();
-      return result.affectedRows === 1;
-    } catch (error) { await db.rollback(); throw error; }
-    finally { db.release(); }
-  }
-  async function turnOrigin(computerId, key) {
-    const [rows] = await pool.execute(`SELECT a.user_id,a.client_id FROM relay_usage_actions a JOIN users u ON u.id=a.user_id
-      WHERE a.computer_id=? AND a.kind='turn' AND a.action_key=? AND u.status='active'`, [computerId, key]);
-    return rows[0] ? { userId: rows[0].user_id, clientId: rows[0].client_id } : null;
-  }
-  async function pulse(connection, active, computerId, clientId, externalKey = null) {
-    if (!connection.userId) return;
-    if (!active && !connection.usageSessionId) return;
-    if (active && !connection.usageSessionId) {
-      const id = randomUUID();
-      const [inserted] = await pool.execute(`INSERT INTO relay_usage_sessions
-        (id,kind,external_key,user_id,computer_id,client_id,started_at,confirmed_until,charged_seconds)
-        SELECT ?,'task',?,?,?,?,UTC_TIMESTAMP(3),UTC_TIMESTAMP(3),0 FROM users WHERE id=? AND status='active'`, [id, externalKey, connection.userId, computerId, clientId, connection.userId]);
-      if (!inserted.affectedRows) return;
-      connection.usageSessionId = id;
-      return;
-    }
-    const id = connection.usageSessionId;
-    const db = await pool.getConnection();
-    try {
-      await db.beginTransaction();
-      const [users] = await db.execute("SELECT id FROM users WHERE id=? AND status='active' FOR UPDATE", [connection.userId]);
-      if (!users.length) { await db.commit(); connection.usageSessionId = undefined; return; }
-      const [rows] = await db.execute('SELECT user_id,computer_id,confirmed_until,ended_at FROM relay_usage_sessions WHERE id=? FOR UPDATE', [id]);
-      const row = rows[0];
-      if (!row || row.ended_at) throw new Error('Invalid relay usage session');
-      const [clock] = await db.query('SELECT UTC_TIMESTAMP(3) AS now');
-      const now = clock[0].now;
-      const nowMs = epoch(now);
-      const chargeStart = Math.max(epoch(row.confirmed_until), nowMs - 20000);
-      const seconds = Math.max(0, nowMs - chargeStart) / 1000;
-      const [plans] = await db.execute('SELECT tier,valid_until FROM relay_usage_entitlements WHERE user_id=?', [row.user_id]);
-      const subscribed = plans[0]?.tier === 'subscriber' && plans[0].valid_until && epoch(plans[0].valid_until) > epoch(now);
-      const freeSeconds = subscribed ? 0 : seconds;
-      await db.execute(`UPDATE relay_usage_sessions SET confirmed_until=?,ended_at=?,charged_seconds=charged_seconds+?,
-        free_charged_seconds=free_charged_seconds+? WHERE id=?`, [now, active ? null : now, seconds, freeSeconds, id]);
-      if (seconds > 0) {
-        await recordDailyUsage(db, row.user_id, row.computer_id, !subscribed,
-          chargeStart, nowMs, now);
-        await db.execute(`INSERT INTO relay_usage_totals (user_id,task_seconds,updated_at)
-          VALUES (?,?,?) ON DUPLICATE KEY UPDATE task_seconds=task_seconds+VALUES(task_seconds),
-          updated_at=VALUES(updated_at)`, [row.user_id, seconds, now]);
-        await db.execute(`INSERT INTO relay_usage_computer_totals (computer_id,task_seconds,free_task_seconds,updated_at)
-          VALUES (?,?,?,?) ON DUPLICATE KEY UPDATE task_seconds=task_seconds+VALUES(task_seconds),
-          free_task_seconds=free_task_seconds+VALUES(free_task_seconds),updated_at=VALUES(updated_at)`,
-          [row.computer_id, seconds, freeSeconds, now]);
-      }
-      await db.commit();
-      if (!active) connection.usageSessionId = undefined;
-    } catch (error) { await db.rollback(); throw error; }
-    finally { db.release(); }
-  }
-
-  async function lost(connection) {
-    const id = connection.usageSessionId;
-    connection.usageSessionId = undefined;
-    if (!id) return;
-    await pool.execute(`UPDATE relay_usage_sessions SET ended_at=confirmed_until
-      WHERE id=? AND ended_at IS NULL`, [id]);
-  }
-
-  return { action, turnOrigin, pulse, lost };
-}
-
-export async function usageReport(pool, page, view = 'user') {
-  if (view === 'computer') {
-    const offset = (page - 1) * 30;
-    const [counts] = await pool.query(`SELECT COUNT(*) AS total FROM relay_usage_computer_days
-      WHERE usage_date=DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) AND task_seconds>0`);
-    const [rows] = await pool.execute(`SELECT c.id,
-      d.task_seconds AS today_task_seconds,
-      d.free_task_seconds AS today_free_task_seconds,
-      COALESCE(a.message_count,0) AS message_count,
-      COALESCE(a.turn_count,0) AS turn_count,
-      COALESCE(GREATEST(s.last_used_at,a.last_used_at),s.last_used_at,a.last_used_at) AS last_used_at
-      FROM relay_usage_computer_days d JOIN computers c ON c.id=d.computer_id
-      LEFT JOIN (SELECT computer_id,SUM(kind='message') AS message_count,
-        SUM(kind='turn') AS turn_count,MAX(occurred_at) AS last_used_at FROM relay_usage_actions
-        WHERE occurred_at >= DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) - INTERVAL 8 HOUR
-          AND occurred_at < DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) + INTERVAL 16 HOUR
-        GROUP BY computer_id) a ON a.computer_id=c.id
-      LEFT JOIN (SELECT computer_id,MAX(confirmed_until) AS last_used_at
-        FROM relay_usage_sessions GROUP BY computer_id) s ON s.computer_id=c.id
-      WHERE d.usage_date=DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) AND d.task_seconds>0
-      ORDER BY d.task_seconds DESC,c.id LIMIT ? OFFSET ?`, [30, offset]);
-    return { page, pageSize: 30, total: counts[0].total, rows };
-  }
-  const offset = (page - 1) * 30;
-  const [counts] = await pool.query(`SELECT COUNT(*) AS total FROM relay_usage_user_days d
-    JOIN user_login_identities i ON i.user_id=d.user_id AND i.kind='email'
-    WHERE d.usage_date=DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) AND d.task_seconds>0`);
-  const [rows] = await pool.execute(`SELECT u.id,i.normalized_value AS email,
-    d.task_seconds AS today_task_seconds,
-    COALESCE(a.message_count,0) AS message_count,
-    COALESCE(a.turn_count,0) AS turn_count,
-    COALESCE(GREATEST(s.last_used_at,a.last_used_at),s.last_used_at,a.last_used_at) AS last_used_at
-    FROM relay_usage_user_days d JOIN users u ON u.id=d.user_id
-    JOIN user_login_identities i ON i.user_id=u.id AND i.kind='email'
-    LEFT JOIN (SELECT user_id,SUM(kind='message') AS message_count,
-      SUM(kind='turn') AS turn_count,MAX(occurred_at) AS last_used_at FROM relay_usage_actions
-      WHERE occurred_at >= DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) - INTERVAL 8 HOUR
-        AND occurred_at < DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) + INTERVAL 16 HOUR
-      GROUP BY user_id) a ON a.user_id=u.id
-    LEFT JOIN (SELECT user_id,MAX(confirmed_until) AS last_used_at
-      FROM relay_usage_sessions GROUP BY user_id) s ON s.user_id=u.id
-    WHERE d.usage_date=DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) AND d.task_seconds>0
-    ORDER BY d.task_seconds DESC,u.id LIMIT ? OFFSET ?`, [30, offset]);
-  return { page, pageSize: 30, total: counts[0].total, rows };
-}
+import { randomUUID } from 'node:crypto';
+import { recordDailyUsage } from './usage-daily.mjs';
+
+const epoch = value => new Date(`${value.replace(' ', 'T')}Z`).getTime();
+
+// Count confirmed intervals only; a lost connection never creates estimated time.
+export function usageMeter(pool) {
+  async function action(connection, computerId, clientId, kind, key) {
+    if (!connection.userId || !['message', 'turn'].includes(kind) || typeof key !== 'string' || !key || key.length > 128) return;
+    const column = kind === 'message' ? 'message_count' : 'turn_count';
+    const db = await pool.getConnection();
+    try {
+      await db.beginTransaction();
+      const [users] = await db.execute("SELECT id FROM users WHERE id=? AND status='active' FOR UPDATE", [connection.userId]);
+      if (!users.length) { await db.commit(); return false; }
+      const [result] = await db.execute(`INSERT IGNORE INTO relay_usage_actions
+        (computer_id,kind,action_key,user_id,client_id,occurred_at)
+        VALUES (?,?,?,?,?,UTC_TIMESTAMP(3))`,
+        [computerId, kind, key, connection.userId, clientId]);
+      if (result.affectedRows === 1) {
+        await db.execute(`INSERT INTO relay_usage_totals (user_id,${column},updated_at)
+          VALUES (?,1,UTC_TIMESTAMP(3)) ON DUPLICATE KEY UPDATE ${column}=${column}+1,
+          updated_at=VALUES(updated_at)`, [connection.userId]);
+        await db.execute(`INSERT INTO relay_usage_computer_totals (computer_id,${column},updated_at)
+          VALUES (?,1,UTC_TIMESTAMP(3)) ON DUPLICATE KEY UPDATE ${column}=${column}+1,
+          updated_at=VALUES(updated_at)`, [computerId]);
+      }
+      await db.commit();
+      return result.affectedRows === 1;
+    } catch (error) { await db.rollback(); throw error; }
+    finally { db.release(); }
+  }
+  async function turnOrigin(computerId, key) {
+    const [rows] = await pool.execute(`SELECT a.user_id,a.client_id FROM relay_usage_actions a JOIN users u ON u.id=a.user_id
+      WHERE a.computer_id=? AND a.kind='turn' AND a.action_key=? AND u.status='active'`, [computerId, key]);
+    return rows[0] ? { userId: rows[0].user_id, clientId: rows[0].client_id } : null;
+  }
+  async function pulse(connection, active, computerId, clientId, externalKey = null) {
+    if (!connection.userId) return;
+    if (!active && !connection.usageSessionId) return;
+    if (active && !connection.usageSessionId) {
+      const id = randomUUID();
+      const [inserted] = await pool.execute(`INSERT INTO relay_usage_sessions
+        (id,kind,external_key,user_id,computer_id,client_id,started_at,confirmed_until,charged_seconds)
+        SELECT ?,'task',?,?,?,?,UTC_TIMESTAMP(3),UTC_TIMESTAMP(3),0 FROM users WHERE id=? AND status='active'`, [id, externalKey, connection.userId, computerId, clientId, connection.userId]);
+      if (!inserted.affectedRows) return;
+      connection.usageSessionId = id;
+      return;
+    }
+    const id = connection.usageSessionId;
+    const db = await pool.getConnection();
+    try {
+      await db.beginTransaction();
+      const [users] = await db.execute("SELECT id FROM users WHERE id=? AND status='active' FOR UPDATE", [connection.userId]);
+      if (!users.length) { await db.commit(); connection.usageSessionId = undefined; return; }
+      const [rows] = await db.execute('SELECT user_id,computer_id,confirmed_until,ended_at FROM relay_usage_sessions WHERE id=? FOR UPDATE', [id]);
+      const row = rows[0];
+      if (!row || row.ended_at) throw new Error('Invalid relay usage session');
+      const [clock] = await db.query('SELECT UTC_TIMESTAMP(3) AS now');
+      const now = clock[0].now;
+      const nowMs = epoch(now);
+      const chargeStart = Math.max(epoch(row.confirmed_until), nowMs - 20000);
+      const seconds = Math.max(0, nowMs - chargeStart) / 1000;
+      const [plans] = await db.execute('SELECT tier,valid_until FROM relay_usage_entitlements WHERE user_id=?', [row.user_id]);
+      const subscribed = plans[0]?.tier === 'subscriber' && plans[0].valid_until && epoch(plans[0].valid_until) > epoch(now);
+      const freeSeconds = subscribed ? 0 : seconds;
+      await db.execute(`UPDATE relay_usage_sessions SET confirmed_until=?,ended_at=?,charged_seconds=charged_seconds+?,
+        free_charged_seconds=free_charged_seconds+? WHERE id=?`, [now, active ? null : now, seconds, freeSeconds, id]);
+      if (seconds > 0) {
+        await recordDailyUsage(db, row.user_id, row.computer_id, !subscribed,
+          chargeStart, nowMs, now);
+        await db.execute(`INSERT INTO relay_usage_totals (user_id,task_seconds,updated_at)
+          VALUES (?,?,?) ON DUPLICATE KEY UPDATE task_seconds=task_seconds+VALUES(task_seconds),
+          updated_at=VALUES(updated_at)`, [row.user_id, seconds, now]);
+        await db.execute(`INSERT INTO relay_usage_computer_totals (computer_id,task_seconds,free_task_seconds,updated_at)
+          VALUES (?,?,?,?) ON DUPLICATE KEY UPDATE task_seconds=task_seconds+VALUES(task_seconds),
+          free_task_seconds=free_task_seconds+VALUES(free_task_seconds),updated_at=VALUES(updated_at)`,
+          [row.computer_id, seconds, freeSeconds, now]);
+      }
+      await db.commit();
+      if (!active) connection.usageSessionId = undefined;
+    } catch (error) { await db.rollback(); throw error; }
+    finally { db.release(); }
+  }
+
+  async function lost(connection) {
+    const id = connection.usageSessionId;
+    connection.usageSessionId = undefined;
+    if (!id) return;
+    await pool.execute(`UPDATE relay_usage_sessions SET ended_at=confirmed_until
+      WHERE id=? AND ended_at IS NULL`, [id]);
+  }
+
+  return { action, turnOrigin, pulse, lost };
+}
+
+export async function usageReport(pool, page, view = 'user') {
+  if (view === 'computer') {
+    const offset = (page - 1) * 30;
+    const [counts] = await pool.query(`SELECT COUNT(*) AS total FROM relay_usage_computer_days
+      WHERE usage_date=DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) AND task_seconds>0`);
+    const [rows] = await pool.execute(`SELECT c.id,
+      d.task_seconds AS today_task_seconds,
+      d.free_task_seconds AS today_free_task_seconds,
+      COALESCE(a.message_count,0) AS message_count,
+      COALESCE(a.turn_count,0) AS turn_count,
+      COALESCE(GREATEST(s.last_used_at,a.last_used_at),s.last_used_at,a.last_used_at) AS last_used_at
+      FROM relay_usage_computer_days d JOIN computers c ON c.id=d.computer_id
+      LEFT JOIN (SELECT computer_id,SUM(kind='message') AS message_count,
+        SUM(kind='turn') AS turn_count,MAX(occurred_at) AS last_used_at FROM relay_usage_actions
+        WHERE occurred_at >= DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) - INTERVAL 8 HOUR
+          AND occurred_at < DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) + INTERVAL 16 HOUR
+        GROUP BY computer_id) a ON a.computer_id=c.id
+      LEFT JOIN (SELECT computer_id,MAX(confirmed_until) AS last_used_at
+        FROM relay_usage_sessions GROUP BY computer_id) s ON s.computer_id=c.id
+      WHERE d.usage_date=DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) AND d.task_seconds>0
+      ORDER BY d.task_seconds DESC,c.id LIMIT ? OFFSET ?`, [30, offset]);
+    return { page, pageSize: 30, total: counts[0].total, rows };
+  }
+  const offset = (page - 1) * 30;
+  const [counts] = await pool.query(`SELECT COUNT(*) AS total FROM relay_usage_user_days d
+    JOIN user_login_identities i ON i.user_id=d.user_id AND i.kind='email'
+    WHERE d.usage_date=DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) AND d.task_seconds>0`);
+  const [rows] = await pool.execute(`SELECT u.id,i.normalized_value AS email,
+    d.task_seconds AS today_task_seconds,
+    COALESCE(a.message_count,0) AS message_count,
+    COALESCE(a.turn_count,0) AS turn_count,
+    COALESCE(GREATEST(s.last_used_at,a.last_used_at),s.last_used_at,a.last_used_at) AS last_used_at
+    FROM relay_usage_user_days d JOIN users u ON u.id=d.user_id
+    JOIN user_login_identities i ON i.user_id=u.id AND i.kind='email'
+    LEFT JOIN (SELECT user_id,SUM(kind='message') AS message_count,
+      SUM(kind='turn') AS turn_count,MAX(occurred_at) AS last_used_at FROM relay_usage_actions
+      WHERE occurred_at >= DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) - INTERVAL 8 HOUR
+        AND occurred_at < DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) + INTERVAL 16 HOUR
+      GROUP BY user_id) a ON a.user_id=u.id
+    LEFT JOIN (SELECT user_id,MAX(confirmed_until) AS last_used_at
+      FROM relay_usage_sessions GROUP BY user_id) s ON s.user_id=u.id
+    WHERE d.usage_date=DATE(UTC_TIMESTAMP() + INTERVAL 8 HOUR) AND d.task_seconds>0
+    ORDER BY d.task_seconds DESC,u.id LIMIT ? OFFSET ?`, [30, offset]);
+  return { page, pageSize: 30, total: counts[0].total, rows };
+}

package/dist/src/server.mjs

@@ -9,6 +9,7 @@ import { fileURLToPath } from 'node:url';
 import vm from 'node:vm';
 import sharp from 'sharp';
 import { attachLanSocket } from './lan-socket-server.mjs';
+import { connectionReporting } from './self-relay/connection-reporting.mjs';
 import fileMentions from '../shared/file-mentions.cjs';
 import fileCitations from '../shared/file-citations.cjs';
 import { validateInlineImage } from './message-images.mjs';
@@ -92,6 +93,7 @@ function readRuntimeVersion() {
 
 const options = parseOptions(process.argv.slice(2));
 const runtimeVersion = readRuntimeVersion();
+const serviceInstanceId = crypto.randomUUID();
 
 const webRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'web');
 const projectRoot = os.homedir();
@@ -266,8 +268,8 @@ async function handleRequest(request, response) {
       const body = await readJsonBody(request);
       if (body.confirmed !== true) throw new RequestError(400, '请确认启动桌面端。');
       const result = await startDesktop({ stateRoot, host: desktopHost, restart: url.pathname === '/api/desktop/restart' });
-      await runtimeDiscovery.sample();
-      sendJson(response, 202, result); return;
+      const observed = await runtimeDiscovery.sample();
+      sendJson(response, 202, { ...result, desktop: observed.desktop, checkedAt: observed.checkedAt }); return;
     }
     if (request.method === 'POST' && url.pathname === '/api/shared-recovery') {
       const body = await readJsonBody(request);
@@ -283,7 +285,7 @@ async function handleRequest(request, response) {
     if (request.method === 'POST' && url.pathname === '/api/service/restart') {
       const body = await readJsonBody(request);
       if (body.confirmed !== true) throw new RequestError(400, '请确认重启工作站服务后再继续。');
-      sendJson(response, 202, await requestServiceRestart(stateRoot)); return;
+      sendJson(response, 202, { ...await requestServiceRestart(stateRoot), serviceInstanceId }); return;
     }
     if (request.method === 'POST' && url.pathname === '/api/managed-app-server/restart') {
       const body = await readJsonBody(request);
@@ -322,7 +324,7 @@ async function handleRequest(request, response) {
       // must not trigger PowerShell, process-identity, or app-server checks.
       const executionReady = executionHealth.state.ready && sharedServer?.ready === true;
       sendJson(response, 200, {
-        status: 'ok', resident: true, version: runtimeVersion,
+        status: 'ok', resident: true, version: runtimeVersion, serviceInstanceId,
         keepAwake: powerManager.snapshot(),
         serviceUpdate: serviceUpdateStatus(stateRoot),
         execution: { ...executionHealth.state, ready: executionReady, canWrite: executionReady,
@@ -392,7 +394,10 @@ async function handleRequest(request, response) {
         return;
       }
       const localPath = url.searchParams.get('path') || '';
-      if (localFileRequest && !/^[a-z]:[\\/]/i.test(localPath)) throw new RequestError(400, '无效的工作站文件路径。');
+      if (localFileRequest && (/[\x00-\x1f]/.test(localPath)
+        || !(process.platform === 'win32' ? /^[a-z]:[\\/]/i : /^\/(?!\/)/).test(localPath))) {
+        throw new RequestError(400, '无效的工作站文件路径。');
+      }
       const file = localFileRequest ? describeLocalFile(localPath) : fileCache.get(fileMatch[1]);
       if (!file) throw new RequestError(404, '电脑上的文件不存在或无法读取。');
       if (file.externalIdentity) await dotsImages.authorization(file.externalIdentity);
@@ -514,11 +519,16 @@ async function handleRequest(request, response) {
 
     if (request.method === 'GET' && url.pathname === '/api/file-local-copy') {
       const value = url.searchParams.get('source') || '';
-      const id = /^([a-f0-9]{64})(?:\?recovery=[A-Za-z0-9_-]{1,4096})?$/.exec(value)?.[1];
-      if (id && (fileCache.has(id) || attachmentCache.has(id) && !attachmentCache.get(id).dotsFile)) {
+      const match = /^([a-f0-9]{64})(?:\?recovery=([A-Za-z0-9_-]{1,4096}))?$/.exec(value);
+      if (!match) throw new RequestError(400, '无效的文件标识。');
+      const asset = attachmentCache.get(match[1])
+        || dotsImages.restore(match[1], match[2] || url.searchParams.get('recovery') || '');
+      // A missing process cache does not make a local image an external file.
+      // The actual image endpoint owns recovery and download authorization.
+      if (!asset?.dotsFile) {
         sendJson(response, 200, { external: false, localCopy: null }); return;
       }
-      const asset = await externalDownloadAsset(value, url.searchParams.get('recovery'));
+      await dotsImages.authorization(asset.identity);
       const copy = await workstationDownloads.copy(asset.id);
       sendJson(response, 200, { external: true, localCopy: copy ? workstationCopyReference(copy, asset) : null,
         cachedContent: asset.buffer ? { remotePath: asset.id, name: asset.name, size: asset.buffer.length, mimeType: asset.mimeType } : null });
@@ -759,7 +769,9 @@ async function handleRequest(request, response) {
           }
           const { input } = appServerTurnArguments('', body);
           messageSubmissionStarted = true;
-          const created = await appServerEvents.createThread(rpc, target, input, body, undefined, bindCreation);
+          const createRpc = (method, params) => method === 'thread/start'
+            ? execution.startThread(params) : rpc(method, params);
+          const created = await appServerEvents.createThread(createRpc, target, input, body, undefined, bindCreation);
           const prompt = input.filter(part => part.type === 'text').map(part => part.text).join('\n');
           void generateAndSetThreadTitle({
             request: rpc,
@@ -1021,6 +1033,8 @@ const lanSocket = attachLanSocket(server, { token: options.token, dispatch: hand
   uploadsRoot,
   authorizeDevice: (clientId, credential) => authorizeLanDevice(stateRoot, clientId, credential),
   onDeviceAuthorizationsChanged: listener => onLanAuthorizationsChanged(stateRoot, listener),
+  onPhoneConnected: (...args) => connectionReporting(stateRoot).connected(...args),
+  onPhoneDisconnected: id => connectionReporting(stateRoot).disconnected(id),
   onDeviceConnected: (clientId, info) => {
     try { recordLanConnection(stateRoot, clientId, info); }
     catch (error) { console.error('记录局域网设备连接失败：', error.message); }