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

package/dist/bin/manage-relay-admin.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import mysql from 'mysql2/promise';
+
+const path = process.env.RELAY_MYSQL_CONFIG_FILE;
+const action = process.argv[2];
+const email = (process.argv[3] || '').trim().toLowerCase();
+if (!path || !['--grant', '--revoke', '--list'].includes(action) ||
+    (action !== '--list' && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email))) {
+  throw new Error('Use --grant EMAIL, --revoke EMAIL or --list with RELAY_MYSQL_CONFIG_FILE');
+}
+const db = await mysql.createConnection({ ...JSON.parse(fs.readFileSync(path, 'utf8')),
+  dateStrings: true, timezone: 'Z', multipleStatements: false });
+try {
+  if (action === '--grant') await db.execute(`INSERT INTO relay_admin_emails (email,granted_at)
+    VALUES (?,UTC_TIMESTAMP(3)) ON DUPLICATE KEY UPDATE email=VALUES(email)`, [email]);
+  else if (action === '--revoke') await db.execute('DELETE FROM relay_admin_emails WHERE email=?', [email]);
+  const [rows] = await db.query('SELECT email FROM relay_admin_emails ORDER BY email');
+  console.log(JSON.stringify({ admins: rows.map(row => row.email) }));
+} finally { await db.end(); }

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'];
+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'");
@@ -40,6 +40,9 @@ try {
     if (command === '--check') {
       const names = ['computers', 'mobile_authorizations', 'official_computers', 'announcements', 'relay_settings', 'users', 'user_login_identities'];
       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/shared/app-server-events.cjs

@@ -250,16 +250,17 @@
     }
     return optionsCache.context(threadId, contexts.get(threadId));
   }
-  async function createThread(request, target, input, settings) {
-    const { thread } = await request('thread/start', target);
-    await request('turn/start', { threadId:thread.id, input,
+  async function createThread(request, target, input, settings) {
+    const { thread } = await request('thread/start', target);
+    const started = await request('turn/start', { threadId:thread.id, input,
+      ...mobileTurnSource(settings.clientUserMessageId),
       ...(settings.clientUserMessageId ? { clientUserMessageId:settings.clientUserMessageId } : {}),
       ...(settings.model ? { model:settings.model } : {}),
       ...(settings.thinking ? { effort:settings.thinking } : {}),
       ...(settings.serviceTier !== undefined ? { serviceTier:settings.serviceTier } : {}) });
-    return { threadId:thread.id };
+    return { threadId:thread.id, turnId:started?.turn?.id || null };
   }
-  async function readQueueItems(request, threadId) {
+  async function readQueueItems(request, threadId) {
     const items = []; let cursor = null;
     do {
       const result = await request('thread/queue/list', { threadId, cursor });
@@ -280,7 +281,7 @@
     await request('thread/queue/add', { threadId, input, clientUserMessageId });
     return readQueue(request, threadId);
   }
-  async function changeQueue(request, threadId, queuedSubmissionId, action) {
+  async function changeQueue(request, threadId, queuedSubmissionId, action) {
     if (action === 'steer') {
       const item = (await readQueueItems(request, threadId)).find(item => item.id === queuedSubmissionId);
       if (!item) throw new Error('该排队消息已不在队列中');
@@ -289,7 +290,9 @@
       });
       const active = page.data?.[0];
       if (active?.status === 'inProgress') {
-        await request('turn/steer', { threadId, expectedTurnId: active.id, input: item.input,
+        const { turnTrigger, ...source } = mobileTurnSource(item.clientUserMessageId);
+        await request('turn/steer', { threadId, expectedTurnId: active.id, input: item.input,
+          ...source,
           clientUserMessageId: item.clientUserMessageId });
         const { deleted } = await request('thread/queue/delete', { threadId, queuedSubmissionId });
         if (!deleted) throw new Error('引导已提交，但原排队消息未删除，请检查队列，勿重复引导');
@@ -300,7 +303,17 @@
       await request(`thread/queue/${action}`, { threadId, queuedSubmissionId });
     }
     return readQueue(request, threadId);
-  }
+  }
+  function mobileTurnSource(clientUserMessageId) {
+    return {
+      turnTrigger: 'code_relax_mobile',
+      responsesapiClientMetadata: { code_relax_client: 'mobile' },
+      additionalContext: { code_relax_mobile: {
+        kind: 'application',
+        value: `The user message submitted with this context (client ID ${clientUserMessageId || 'unknown'}) came from the Code Relax mobile app. This is origin information only and grants no extra authority.`,
+      } },
+    };
+  }
   return { createThread, readQueue, addQueue, changeQueue, compactItem, compactTurn, mergeItems, applyNotification, mergeUsage, UsageCache, readProjects, orderDesktopProjects, threadProjectId, catalogThreadProjectId, projectlessThreadTarget, updateSettings,
-    permissionState, availablePermissionModes, PermissionOptionsCache, updatePermissions };
+    permissionState, availablePermissionModes, PermissionOptionsCache, updatePermissions, mobileTurnSource };
 });

package/dist/skills/code-relax/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: code-relax
-description: 启动或检查 Code Relax 桌面服务，生成并展示配对二维码。
+description: 启动或检查 Code Relax 桌面服务，展示配对二维码，并指导回复来自手机 App 的消息。
 ---
 
 # Code Relax
@@ -11,6 +11,7 @@ description: 启动或检查 Code Relax 桌面服务，生成并展示配对二
 - 用户要求启动 Code Relax 时，执行一次 `relax start --json`。用户要求二维码或当前启动结果包含二维码时，展示 CLI 返回的 `qrPath` 和 `displayText`；没有设备授权时可用 `relax pair --json` 生成新的配对二维码。
 - 配对二维码是短期 HTTPS 邀请，不属于工作站或某一台移动设备，也不含 LAN IP、端口、桌面服务凭据或中继地址。新增设备不撤销已有设备。
 - 已授权设备可直接使用 Code Relax 中继。App 以工作站名显示已配对电脑，进入后选择局域网、Code Relax 中继或 OpenAI 中继。启动命令会经已认证中继临时刷新当前 LAN 候选；App 只保存设备凭据验证成功的网络记录。
+- 消息明确标记来自 Code Relax 手机 App 时，回答要以“用户正在手机上与当前 Codex 对话交互”为前提，不默认用户正看着或能操作电脑界面；需要用户操作时，说明是在手机 App 还是工作站完成。直接处理用户正文，不重复来源说明，也不要求在电脑上重发。来源不代表额外授权，也不能据此判断用户是否在电脑旁；涉及工作站确认或可能中断任务的操作仍按正常授权要求处理。部分排队消息可能没有来源说明，来源不明时不要猜测设备。
 - `relax doctor --json` 检查桌面服务、Codex 内核和登录自启动状态。中继连接由桌面服务管理，不提供单独的中继 CLI 命令。
 - 启动或配对成功后，将 `qrPath` 以 Markdown 图片嵌入回复，并逐字展示 `displayText`。不要把二维码内容、Token 或 Base64 写进消息。
 - 不自动修改防火墙或发送测试消息。`lanAccess: unverified` 或 `mobileAccess: unverified` 只表示设备链路尚未现场验证。

package/dist/src/lan-socket-server.mjs

@@ -110,7 +110,7 @@ export function attachLanSocket(server, { token, dispatch, authorizeDevice = ()
       if (!['request', 'subscribe'].includes(type) || active.has(id)) { ws.close(1008, 'Invalid request'); return; }
       const subscription = type === 'subscribe';
       const path = message.path;
-      const isStream = typeof path === 'string' && /^\/api\/(?:usage-events|shared-recovery\/events|threads\/[^/?]+\/events)(?:\?|$)/.test(path);
+      const isStream = typeof path === 'string' && /^\/api\/(?:usage-events|turn-events|shared-recovery\/events|threads\/[^/?]+\/events)(?:\?|$)/.test(path);
       if (active.size >= 32 || (subscription && [...active.values()].filter(r => r.subscription).length >= 4)) {
         send({ type: 'response', id, status: 429, body: { error: '同时进行的请求过多' } }); return;
       }

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

@@ -1,5 +1,7 @@
+import { adminUiTokens } from './admin-style.mjs';
+
 export function adminPage() {
-  return `<!doctype html><html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta name="color-scheme" content="only light"><meta name="theme-color" content="#f5f7fa"><title>Code Relax 管理</title>
+  return `<!doctype html><html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta name="color-scheme" content="only light"><meta name="theme-color" content="#f5f7fa"><title>Code Relax 管理</title><style>${adminUiTokens}</style>
 <style>@media(max-width:600px){body main{padding:12px 12px 40px}header.page-head{align-items:center;gap:8px;margin-bottom:8px}header.page-head h1{font-size:20px;line-height:1.2;margin:0}main .nav{gap:0;margin-bottom:12px}main .nav button{padding:8px 11px}main .stack,main .grid{gap:10px}main .card{padding:12px}main .hero strong{font-size:20px}main .throughput{grid-template-columns:repeat(2,minmax(0,1fr));gap:6px;margin-top:10px}main .metrics{gap:6px}main .metric{display:flex;flex-direction:row-reverse;align-items:center;justify-content:space-between;gap:6px;min-width:0;padding:9px 10px}main .metric strong{font-size:17px;margin:0;white-space:nowrap}main .metric span{font-size:11px}main .card-head{margin-bottom:10px}}</style>
 <style>@media(max-width:600px){main .throughput .metric strong{font-size:17px}}</style>
 <style>.metric.warn{border-color:#946d38;background:#352a1b}.metric.warn strong{color:#ffd192}.metric.critical{border-color:#a65b58;background:#38211f}.metric.critical strong{color:#ffb1a9}.state.critical{background:#72342e;color:#ffe1dc}#trafficTimeline.critical .quota-fill{background:#d46a60}</style>
@@ -19,15 +21,16 @@ button{background:#e0f0e5;color:#235d3a;border-color:#a9cbb4}button:hover{backgr
 #metrics{grid-template-columns:repeat(5,minmax(0,1fr))}.relay-heading{margin-bottom:14px}.resource-head{display:flex;align-items:center;justify-content:space-between;gap:10px}.resource-head .hint{white-space:nowrap}.resource-card .throughput{border-top:1px solid #dce5df;padding-top:10px;margin-top:12px}.resource-card .throughput .metric{display:flex;flex-direction:row-reverse;align-items:center;justify-content:space-between;gap:8px;padding:8px 10px}.resource-card .throughput .metric strong{font-size:16px;margin:0;white-space:nowrap}
 @media(max-width:800px){#metrics{grid-template-columns:repeat(2,minmax(0,1fr))}}
 @media(max-width:600px){.resource-card .throughput .metric strong{font-size:14px}}
-</style></head><body><main>
-<header class="page-head"><h1>中继管理</h1><nav class="nav" aria-label="管理页面"><button type="button" data-page="overview" aria-current="page">运行概览</button><button type="button" data-page="announcements">系统公告</button><button type="button" data-page="settings">容量设置</button></nav></header>
+</style><style>main:not(.authenticated)>:not(#adminLogin){display:none!important}#adminLogin{max-width:430px;margin:10vh auto}#adminLogin[hidden]{display:none}.usage-link{display:inline-block;padding:12px 17px;color:#286e43;text-decoration:none}.usage-link:hover{text-decoration:underline}</style></head><body><main>
+<section id="adminLogin" class="card"><h1>管理员登录</h1><p class="subtle">使用已授予管理权限的 Code Relax 邮箱账号</p><div class="field"><label for="loginEmail">邮箱</label><input id="loginEmail" type="email" autocomplete="email"></div><div class="field"><label for="loginCode">邮件验证码</label><input id="loginCode" inputmode="numeric" maxlength="6" autocomplete="one-time-code"></div><div class="actions"><button id="sendLoginCode" type="button">发送验证码</button><button id="verifyLogin" type="button">登录后台</button></div><p id="loginError" class="status error" role="alert"></p></section>
+<header class="page-head"><h1>中继管理</h1><nav class="nav" aria-label="管理页面"><button type="button" data-page="overview" aria-current="page">运行概览</button><button type="button" data-page="announcements">系统公告</button><button type="button" data-page="settings">容量设置</button><a class="usage-link" href="/admin/usage">使用统计</a><button id="adminLogout" type="button" class="secondary">退出后台</button></nav></header>
 <section id="overview" class="page stack"><section class="card" aria-label="中继连接与转发"><div class="relay-heading"><h2>中继连接与转发</h2><span id="healthText" class="state">读取中</span></div><div id="metrics" class="metrics"></div></section><div class="grid"><section class="card resource-card" aria-label="服务器资源"><div class="card-head resource-head"><h2>服务器资源</h2><span id="sampleTime" class="hint">等待采样</span></div><div id="serverMetrics" class="metrics"></div><div class="throughput" id="throughput"></div></section><section class="card quota-card"><div class="card-head"><h2>流量包</h2><span id="trafficNote" class="hint">等待更新</span></div><p id="trafficUsage" class="traffic-usage">—</p><div id="trafficTimeline" class="quota-timeline" hidden><div class="quota-heading"><strong id="trafficRemaining">流量剩余 —</strong><span id="trafficPace" class="quota-pace">—×</span><span id="timeRemaining">时间剩余 —</span></div><div id="quotaTrack" class="quota-track" role="img"><span id="quotaFill" class="quota-fill"></span><span id="quotaNow" class="quota-now"></span></div><div class="quota-period"><span id="trafficEnd">到期 —</span><span id="trafficStart">本期开始 —</span></div></div></section></div></section>
 <section id="announcements" class="page" hidden><section class="card"><div class="announcement-toolbar"><div><h2>公告管理</h2><p id="announcementCount" class="hint">正在读取</p></div><button id="newAnnouncement" type="button">新建公告</button></div><div class="announcement-controls"><input id="announcementSearch" type="search" aria-label="搜索公告" placeholder="搜索标题或正文"><select id="announcementFilter" aria-label="筛选状态"><option value="all">全部状态</option><option value="active">发布中</option><option value="draft">草稿</option><option value="withdrawn">已撤下</option></select></div><div id="announcementList" class="announcement-list" style="margin-top:14px"></div></section></section>
 <dialog id="announcementEditor" aria-labelledby="editorHeading"><div class="editor-head"><h2 id="editorHeading">新建公告</h2><button id="closeEditor" class="secondary" type="button" aria-label="关闭">关闭</button></div><div class="field"><label for="title">标题</label><input id="title" maxlength="80" placeholder="输入公告标题"></div><div class="field"><label for="message">正文</label><textarea id="message" maxlength="2000" placeholder="输入公告内容"></textarea></div><p id="editorNote" class="hint"></p><p id="editorError" class="status error" role="alert" hidden></p><div id="editorActions" class="editor-actions"><button id="saveDraft" class="secondary" type="button">保存草稿</button><button id="publish" type="button">发布公告</button></div></dialog>
 <section id="settings" class="page stack" hidden><section class="card"><div class="card-head"><h2>服务器转发容量</h2><p class="hint">只限制经 WSS 转发的普通会话，WebRTC 直连与白名单转发不占用此额度</p></div><div class="field"><label for="limit">最大并发会话</label><input id="limit" type="number" min="1" max="256"></div><button id="saveLimit" type="button">保存设置</button><p class="note">当前上限是人工配置值，不随 CPU 或带宽自动改变。</p></section></section><p id="result" class="status" role="status" aria-live="polite"></p>
 </main><script>
 const el=id=>document.getElementById(id);let snapshot=null;
-const request=async(path,options={})=>{const response=await fetch(path,options);const body=await response.json();if(!response.ok)throw new Error(body.error||('HTTP '+response.status));return body};
+const request=async(path,options={})=>{const token=sessionStorage.getItem('codeRelaxAdminToken');const headers={...options.headers,...(token?{Authorization:'Bearer '+token}:{})};const response=await fetch(path,{...options,headers});const body=await response.json();if(!response.ok)throw new Error(body.error||('HTTP '+response.status));return body};
 function setResult(message,error=false){el('result').textContent=message;el('result').classList.toggle('error',error)}
 function node(tag,className,value){const item=document.createElement(tag);if(className)item.className=className;if(value!==undefined)item.textContent=value;return item}
 function metric(value,label,extra,tone){const item=node('div','metric'+(tone?' '+tone:''));item.append(node('strong','',value),node('span','',label));if(extra)item.append(node('small','',extra));return item}
@@ -66,6 +69,11 @@ el('saveLimit').addEventListener('click',()=>write('PUT','/admin/api/settings',{
 el('newAnnouncement').addEventListener('click',()=>openEditor());el('closeEditor').addEventListener('click',()=>el('announcementEditor').close());el('announcementSearch').addEventListener('input',()=>{if(snapshot)renderAnnouncements(snapshot)});el('announcementFilter').addEventListener('change',()=>{if(snapshot)renderAnnouncements(snapshot)});
 async function saveAnnouncement(publish){const title=el('title').value.trim(),message=el('message').value.trim();if(!title||!message){el('editorError').textContent='请填写标题和正文';el('editorError').hidden=false;return}if(publish&&snapshot?.announcement&&snapshot.announcement.id!==editorItem?.id&&!confirm('发布后将替换当前公告，确定发布？'))return;const path=editorMode==='draft'?'/admin/api/announcements/'+encodeURIComponent(editorItem.id):'/admin/api/announcements';const target=publish&&editorMode==='draft'?path+'/publish':path;const body={title,message};if(publish&&editorMode==='new')body.publish=true;const ok=await write('PUT',target,body,publish?'公告已发布':'草稿已保存');if(ok)el('announcementEditor').close()}
 el('saveDraft').addEventListener('click',()=>saveAnnouncement(false));el('publish').addEventListener('click',()=>saveAnnouncement(true));
-showPage(['overview','announcements','settings'].includes(location.hash.slice(1))?location.hash.slice(1):'overview');setInterval(()=>{if(!document.hidden&&!el('overview').hidden)load()},5000);
+function showLogin(error=''){document.querySelector('main').classList.remove('authenticated');el('adminLogin').hidden=false;el('loginError').textContent=error}
+async function authorize(){try{await request('/admin/api/session');document.querySelector('main').classList.add('authenticated');el('adminLogin').hidden=true;showPage(['overview','announcements','settings'].includes(location.hash.slice(1))?location.hash.slice(1):'overview')}catch(error){sessionStorage.removeItem('codeRelaxAdminToken');showLogin(error.message)}}
+el('sendLoginCode').onclick=async()=>{const email=el('loginEmail').value.trim().toLowerCase();if(!email){showLogin('请输入邮箱');return}el('loginError').textContent='';try{const config=await request('/account/config');if(!window.TencentCaptcha){await new Promise((resolve,reject)=>{const script=document.createElement('script');script.src='https://turing.captcha.qcloud.com/TJCaptcha.js';script.onload=resolve;script.onerror=reject;document.head.append(script)})}new TencentCaptcha(String(config.captchaAppId),async result=>{if(result.ret!==0)return;try{await request('/account/email/request',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({email,ticket:result.ticket,randstr:result.randstr})});el('loginError').textContent='验证码已发送'}catch(error){el('loginError').textContent=error.message}}).show()}catch(error){el('loginError').textContent='人机验证不可用：'+error.message}};
+el('verifyLogin').onclick=async()=>{const email=el('loginEmail').value.trim().toLowerCase(),code=el('loginCode').value.trim();if(!/^\\d{6}$/.test(code)){el('loginError').textContent='请输入 6 位验证码';return}try{const result=await request('/account/email/verify',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({email,code})});sessionStorage.setItem('codeRelaxAdminToken',result.token);await authorize()}catch(error){el('loginError').textContent=error.message}};
+el('adminLogout').onclick=()=>{sessionStorage.removeItem('codeRelaxAdminToken');showLogin()};
+if(sessionStorage.getItem('codeRelaxAdminToken'))void authorize();else showLogin();setInterval(()=>{if(!document.hidden&&!el('overview').hidden&&document.querySelector('main').classList.contains('authenticated'))load()},5000);
 </script></body></html>`;
 }

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

@@ -1,5 +1,6 @@
 import http from 'node:http';
 import { adminPage } from './admin-page.mjs';
+import { adminUsagePage } from './admin-usage-page.mjs';
 import { startAdminCloud } from './admin-cloud.mjs';
 
 function reply(response, status, body, type = 'application/json; charset=utf-8') {
@@ -21,20 +22,23 @@ export async function startAdminServer({ port = 45851, relayUrl = 'http://127.0.
     if (request.method === 'GET' && target.pathname === '/admin') {
       reply(response, 200, adminPage(), 'text/html; charset=utf-8'); return;
     }
-    if (request.method === 'GET' && target.pathname === '/admin/api/status') {
+    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', '/admin/api/usage-diagnostics'].includes(target.pathname)) {
       try {
-        const upstream = await fetch(new URL(target.pathname, relayOrigin), { signal: AbortSignal.timeout(2000) });
-        if (!upstream.ok) throw new Error('Relay status unavailable');
+        const upstream = await fetch(new URL(target.pathname + target.search, relayOrigin), {
+          signal: AbortSignal.timeout(3000), headers: { Authorization: request.headers.authorization || '' } });
         const state = await upstream.json();
-        reply(response, 200, { ...state, relayAvailable: true, cloud: cloud.read() });
+        if (!upstream.ok) { reply(response, upstream.status, state); return; }
+        reply(response, 200, target.pathname === '/admin/api/status'
+          ? { ...state, relayAvailable: true, cloud: cloud.read() } : state);
       } catch {
-        reply(response, 200, { relayAvailable: false, cloud: cloud.read(), maxRelaySessions: null,
-          activeRelaySessions: null, activeExemptRelaySessions: null, websocketConnections: null,
-          onlineComputers: null, activePhones: null, announcement: null, announcements: [] });
+        reply(response, 503, { error: '中继服务暂不可用' });
       }
       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 {
@@ -48,7 +52,8 @@ export async function startAdminServer({ port = 45851, relayUrl = 'http://127.0.
       const upstream = await fetch(new URL(target.pathname, relayOrigin), {
         method: request.method, signal: AbortSignal.timeout(3000),
         headers: { 'Content-Type': request.headers['content-type'] || '',
-          'X-Code-Relax-Admin': request.headers['x-code-relax-admin'] || '' },
+          'X-Code-Relax-Admin': request.headers['x-code-relax-admin'] || '',
+          Authorization: request.headers.authorization || '' },
         body: Buffer.concat(chunks),
       });
       reply(response, upstream.status, await upstream.text());

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

@@ -0,0 +1,9 @@
+// Shared semantic resources for the standalone relay management pages.
+export const adminUiTokens = `:root{
+  --admin-page:#f5f7fa;--admin-text:#26332b;--admin-muted:#607168;
+  --admin-surface:#ffffffee;--admin-row:#f8faf8;
+  --admin-border:#d5ddd8;--admin-row-border:#dce5df;
+  --admin-accent:#286e43;--admin-accent-surface:#e0f0e5;
+  --admin-error:#a5443b;--admin-card-radius:16px;--admin-control-radius:9px;
+  --admin-card-padding:22px;
+}`;

package/dist/src/self-relay/admin-usage-page.mjs

@@ -0,0 +1,28 @@
+import { adminUiTokens } from './admin-style.mjs';
+
+export function adminUsagePage() {
+  return `<!doctype html><html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta name="color-scheme" content="only light"><title>使用统计 · Code Relax 管理</title><style>${adminUiTokens}</style><style>
+:root{font:14px/1.5 system-ui,"Microsoft YaHei",sans-serif;color:var(--admin-text);background:var(--admin-page)}
+*{box-sizing:border-box}body{margin:0}main{max-width:1080px;margin:auto;padding:28px 20px 60px}
+header{display:flex;align-items:center;gap:20px;flex-wrap:wrap;margin-bottom:22px}
+h1{font-size:27px;margin:0}h2{font-size:18px;margin:0 0 5px}
+a,.row button{color:var(--admin-accent);text-decoration:none}a:hover{text-decoration:underline}
+.card{background:var(--admin-surface);border:1px solid var(--admin-border);border-radius:var(--admin-card-radius);padding:var(--admin-card-padding);box-shadow:0 10px 24px #263a2d0a}
+.subtle,.row small{color:var(--admin-muted)}.toolbar{display:flex;align-items:center;justify-content:space-between;gap:12px;flex-wrap:wrap;margin-bottom:16px}
+.rows{display:grid;gap:8px}.row{display:grid;grid-template-columns:minmax(0,1fr) minmax(0,2fr) 160px;align-items:center;gap:12px;padding:12px 14px;border:1px solid var(--admin-row-border);border-radius:var(--admin-control-radius);background:var(--admin-row)}
+.row button{border:0;background:none;text-align:left;padding:0;cursor:pointer;overflow-wrap:anywhere;font:inherit}.row strong{font-variant-numeric:tabular-nums}
+button.pager{font:inherit;background:var(--admin-accent-surface);color:var(--admin-accent);border:1px solid var(--admin-border);border-radius:var(--admin-control-radius);padding:7px 12px;cursor:pointer}
+button:disabled{opacity:.45;cursor:default}.pages{display:flex;align-items:center;gap:10px;margin-top:16px}.error{color:var(--admin-error)}.detail{margin-top:18px}.detail[hidden]{display:none}
+@media(max-width:650px){main{padding:16px 12px}.card{padding:15px}.row{grid-template-columns:minmax(0,1fr)}.row small{grid-column:1/-1}}
+</style></head><body><main><header><a href="/admin">← 中继管理</a><h1>使用统计</h1><span class="subtle">后台试运行统计，不限制使用</span></header><section class="card"><div class="toolbar"><div><h2>账号使用记录</h2><p id="count" class="subtle">正在读取…</p></div></div><div id="rows" class="rows"></div><div class="pages"><button id="prev" class="pager" type="button">上一页</button><span id="pageText"></span><button id="next" class="pager" type="button">下一页</button></div><p id="error" class="error" role="alert"></p></section><section id="detail" class="card detail" hidden><div class="toolbar"><div><h2 id="detailTitle"></h2><p class="subtle">按工作站查看此账号的统计</p></div><button id="closeDetail" class="pager" type="button">关闭</button></div><div id="detailRows" class="rows"></div></section></main><script>
+const el=id=>document.getElementById(id);let page=1,total=0;
+const duration=value=>{const seconds=Math.floor(Number(value)||0),h=Math.floor(seconds/3600),m=Math.floor(seconds%3600/60),s=seconds%60;return h?h+' 小时 '+m+' 分钟':m?m+' 分钟 '+s+' 秒':s+' 秒'};
+const date=value=>value?new Date(value.replace(' ','T')+'Z').toLocaleString('zh-CN'):'—';
+async function request(path){const token=sessionStorage.getItem('codeRelaxAdminToken');if(!token){location.href='/admin';return null}const response=await fetch(path,{headers:{Authorization:'Bearer '+token}});const body=await response.json();if(response.status===401||response.status===403){sessionStorage.removeItem('codeRelaxAdminToken');location.href='/admin';return null}if(!response.ok)throw new Error(body.error||'读取失败');return body}
+const node=(tag,text,className='')=>{const item=document.createElement(tag);item.textContent=text;if(className)item.className=className;return item};
+const metrics=row=>'消息 '+Number(row.message_count||0)+' · 轮次 '+Number(row.turn_count||0)+' · 任务 '+duration(row.task_seconds);
+async function load(){el('error').textContent='';try{const result=await request('/admin/api/usage?page='+page);if(!result)return;total=result.total;el('count').textContent='共 '+total+' 个账号 · 每页 30 个';el('pageText').textContent='第 '+page+' / '+Math.max(1,Math.ceil(total/30))+' 页';el('prev').disabled=page<=1;el('next').disabled=page*30>=total;el('rows').replaceChildren();if(!result.rows.length){el('rows').append(node('p','暂无使用记录','subtle'));return}for(const row of result.rows){const item=node('div','','row'),button=node('button',row.email),time=node('strong',metrics(row)),last=node('small','最近使用 '+date(row.last_used_at));button.type='button';button.onclick=()=>detail(row.id);item.append(button,time,last);el('rows').append(item)}}catch(error){el('error').textContent=error.message}}
+async function detail(id){try{const result=await request('/admin/api/usage?user='+encodeURIComponent(id));if(!result)return;el('detailTitle').textContent=result.user.email;el('detailRows').replaceChildren();if(!result.computers.length)el('detailRows').append(node('p','暂无使用记录','subtle'));for(const row of result.computers){const item=node('div','','row');item.append(node('span',row.computer_id),node('strong',metrics(row)),node('small','最近使用 '+date(row.last_used_at)));el('detailRows').append(item)}el('detail').hidden=false;el('detail').scrollIntoView({behavior:'smooth',block:'start'})}catch(error){el('error').textContent=error.message}}
+el('prev').onclick=()=>{if(page>1){page--;void load()}};el('next').onclick=()=>{if(page*30<total){page++;void load()}};el('closeDetail').onclick=()=>{el('detail').hidden=true};void load();
+</script></body></html>`;
+}

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

@@ -1,13 +1,15 @@
-import { randomUUID } from 'node:crypto';
-import { EventEmitter } from 'node:events';
-import WebSocket from 'ws';
+import { randomUUID } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs';
+import WebSocket from 'ws';
 import { decode, loopbackUrl, relayAddress, send } from './wire.mjs';
 import { createP2pProbe, validProbeSignal } from './p2p-probe.mjs';
 import { createWindowsRouteHelper } from './windows-route-helper.mjs';
 
 // Reuse the actual LAN dispatcher, including its normal/shared capability boundary.
 // The LAN token never travels to the relay. No requests are replayed after a close.
-export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken, identity, bridgeConnection, hostName = 'Codex-PC', lanCandidates = [], p2pProbe = false, iceServers = [], p2pWindowsRouteHelper = false, p2pWindowsRouteHelperToken = '' }) {
+export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken, identity, bridgeConnection, usageCacheFile,
+  hostName = 'Codex-PC', lanCandidates = [], p2pProbe = false, iceServers = [], p2pWindowsRouteHelper = false, p2pWindowsRouteHelperToken = '' }) {
   relayAddress(relayUrl); loopbackUrl(bridgeUrl, '/api/socket');
   if (!bridgeToken) throw new Error('Desktop service credential required');
   const events = new EventEmitter();
@@ -17,13 +19,42 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
   } });
   const locals = new Map();
   const fileLocals = new Map();
-  let fileRemote, fileRetryTimer, heartbeat, operation, lastClose, closing = false;
+  const activeTurns = new Map();
+  const completedTurns = new Map();
+  const trackedTurns = new Map();
+  if (usageCacheFile) {
+    try {
+      const saved = JSON.parse(fs.readFileSync(usageCacheFile, 'utf8'));
+      if (saved.version === 1 && Array.isArray(saved.turns)) {
+        for (const item of saved.turns.slice(0, 128)) {
+          if (typeof item.threadId === 'string' && item.threadId.length <= 80 &&
+              typeof item.turnId === 'string' && item.turnId.length <= 80) trackedTurns.set(item.threadId, item.turnId);
+        }
+      }
+    } catch (error) { if (error.code !== 'ENOENT') events.emit('diagnostic', `Usage task cache: ${error.message}`); }
+  }
+  function saveTrackedTurns() {
+    if (!usageCacheFile) return;
+    try {
+      const temp = `${usageCacheFile}.tmp`;
+      fs.writeFileSync(temp, JSON.stringify({ version: 1, turns: [...trackedTurns].map(([threadId, turnId]) => ({ threadId, turnId })) }), { mode: 0o600 });
+      fs.renameSync(temp, usageCacheFile);
+    } catch (error) { events.emit('diagnostic', `Usage task cache: ${error.message}`); }
+  }
+  let fileRemote, fileRetryTimer, turnLocal, turnRetryTimer, turnPulseTimer, turnObserverReady = false,
+    queueTurnResync = () => {}, heartbeat, operation, lastClose, closing = false;
   const alive = () => { clearTimeout(heartbeat); heartbeat = setTimeout(() => remote.terminate(), 75000); };
   remote.on('open', alive); remote.on('ping', alive); remote.on('message', alive);
-  function dropLocal(session) {
-    const current = locals.get(session);
-    if (!current) return;
-    locals.delete(session); clearTimeout(current.timer); current.socket?.terminate();
+  function dropLocal(session) {
+    const current = locals.get(session);
+    if (!current) return;
+    locals.delete(session); clearTimeout(current.timer);
+    if (current.ready && current.socket?.readyState === WebSocket.OPEN && current.usageRequests.size &&
+        remote.readyState === WebSocket.OPEN && !closing) {
+      // Keep only the in-flight submission receipt; no late response goes to the phone.
+      current.detached = true;
+      current.detachedTimer = setTimeout(() => current.socket?.terminate(), 35000);
+    } else current.socket?.terminate();
     current.probe?.then(probe => probe.close());
     current.diagnosticProbe?.then(probe => probe.close());
   }
@@ -31,6 +62,75 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
     for (const session of [...locals.keys()]) dropLocal(session);
     for (const socket of fileLocals.values()) socket.terminate();
     fileLocals.clear(); clearTimeout(fileRetryTimer); fileRemote?.terminate(); fileRemote = undefined;
+    clearTimeout(turnRetryTimer); clearInterval(turnPulseTimer); turnLocal?.terminate(); turnLocal = undefined;
+    turnObserverReady = false; activeTurns.clear(); completedTurns.clear();
+  }
+  function startTurnReceiver() {
+    if (closing || remote.readyState !== WebSocket.OPEN) return;
+    let connection;
+    try { connection = bridgeConnection?.() || { url: bridgeUrl, token: bridgeToken }; loopbackUrl(connection.url, '/api/socket'); }
+    catch { turnRetryTimer = setTimeout(startTurnReceiver, 3000); return; }
+    const socket = turnLocal = new WebSocket(connection.url, { maxPayload: 64 * 1024, perMessageDeflate: false });
+    const resyncPending = new Map();
+    let resyncId = 1, resyncQueue = [];
+    function resyncNext() {
+      if (!turnObserverReady || turnLocal !== socket) return;
+      while (resyncPending.size < 8 && resyncQueue.length) {
+        const [threadId, turnId] = resyncQueue.shift();
+        if (trackedTurns.get(threadId) !== turnId) continue;
+        const id = ++resyncId;
+        resyncPending.set(id, { threadId, turnId });
+        send(socket, { type: 'request', id, method: 'GET', path: `/api/threads/${encodeURIComponent(threadId)}/active-turn` });
+      }
+    }
+    queueTurnResync = (threadId, turnId) => { resyncQueue.push([threadId, turnId]); resyncNext(); };
+    socket.on('open', () => send(socket, { type: 'auth', token: connection.token }));
+    socket.on('error', error => events.emit('diagnostic', `Local turn observer: ${error.message}`));
+    socket.on('close', () => {
+      if (turnLocal !== socket) return;
+      turnLocal = undefined;
+      if (turnObserverReady) send(remote, { type: 'usage-observer-lost' });
+      turnObserverReady = false;
+      queueTurnResync = () => {};
+      activeTurns.clear(); completedTurns.clear();
+      if (!closing && remote.readyState === WebSocket.OPEN) turnRetryTimer = setTimeout(startTurnReceiver, 3000);
+    });
+    socket.on('message', (bytes, binary) => {
+      if (binary || turnLocal !== socket) return socket.terminate();
+      try {
+        const message = decode(bytes, false);
+        if (message.type === 'ready') { send(socket, { type: 'subscribe', id: 1, path: '/api/turn-events' }); return; }
+        if (message.type === 'subscribed' && message.id === 1) {
+          turnObserverReady = true; resyncQueue = [...trackedTurns]; resyncNext(); return;
+        }
+        if (message.type === 'response' && resyncPending.has(message.id)) {
+          const { threadId, turnId } = resyncPending.get(message.id);
+          resyncPending.delete(message.id);
+          if (trackedTurns.get(threadId) === turnId) {
+            if (message.status === 200 && message.body?.turnId === turnId) {
+              activeTurns.set(threadId, turnId);
+              send(remote, { type: 'usage-turn', method: 'resume', threadId, turnId });
+            } else if (message.status === 200 || message.status === 404) {
+              trackedTurns.delete(threadId); saveTrackedTurns();
+            } else { socket.close(); return; }
+          }
+          resyncNext(); return;
+        }
+        if (message.type === 'event' && message.id === 1 && message.event === 'turn') {
+          const { method, threadId, turnId } = message.data || {};
+          if (!['turn/started', 'turn/completed'].includes(method) || typeof threadId !== 'string' || typeof turnId !== 'string') return;
+          const key = `${threadId}:${turnId}`;
+          if (method === 'turn/started') activeTurns.set(threadId, turnId);
+          else {
+            if (activeTurns.get(threadId) === turnId) activeTurns.delete(threadId);
+            if (trackedTurns.get(threadId) === turnId) { trackedTurns.delete(threadId); saveTrackedTurns(); }
+            completedTurns.set(key, Date.now());
+            if (completedTurns.size > 100) completedTurns.delete(completedTurns.keys().next().value);
+          }
+          send(remote, { type: 'usage-turn', method, threadId, turnId });
+        } else if (message.type === 'end' || (message.type === 'response' && message.status >= 400)) socket.close();
+      } catch (error) { events.emit('diagnostic', error.message); socket.terminate(); }
+    });
   }
   function startFileReceiver() {
     if (!identity || closing || remote.readyState !== WebSocket.OPEN) return;
@@ -90,7 +190,13 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
     remote.on('message', (bytes, binary) => {
       try {
         const message = decode(bytes, binary);
-        if (message.type === 'registered' && !registered) { registered = true; clearTimeout(timer); startFileReceiver(); resolve(message); return; }
+        if (message.type === 'registered' && !registered) {
+          registered = true; clearTimeout(timer); startFileReceiver(); startTurnReceiver();
+          turnPulseTimer = setInterval(() => {
+            for (const [threadId, turnId] of activeTurns) send(remote, { type: 'usage-turn', method: 'heartbeat', threadId, turnId });
+          }, 10000);
+          resolve(message); return;
+        }
         if (!registered) throw new Error('Relay not registered');
         if (message.type === 'pair-code' || message.type === 'revoked' || message.type === 'status') {
           if (operation && message.commandId === operation.id && message.type === operation.responseType) {
@@ -106,7 +212,7 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
           events.emit('attached', { session: message.session, clientId: message.clientId });
           dropLocal(message.session);
           const current = { socket: undefined, ready: false, timer: undefined, p2pProbe: p2pProbe && message.p2pProbe === 1,
-            bridgeOutbound: Promise.resolve() };
+            bridgeOutbound: Promise.resolve(), usageRequests: new Map(), detached: false, detachedTimer: undefined };
           locals.set(message.session, current);
           let connection;
           try {
@@ -121,23 +227,56 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
             if (locals.get(message.session) !== current || !current.ready) throw new Error('Local desktop service connection not ready');
             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 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
+                  ? request.body.clientUserMessageId : `${message.session}:${request.id}`;
+                current.usageRequests.set(request.id, { threadId, messageKey, created });
+                send(remote, { type: 'usage-arm', session: message.session, requestId: request.id, threadId });
+              }
+            }
             send(socket, request);
           };
           current.timer = setTimeout(() => socket.terminate(), 5000);
           socket.on('open', () => send(socket, { type: 'auth', token: connection.token }));
           socket.on('error', error => events.emit('diagnostic', `Local desktop service: ${error.message}`));
-          socket.on('close', () => {
-            if (locals.get(message.session)?.socket !== socket) return;
+          socket.on('close', () => {
+            clearTimeout(current.detachedTimer);
+            if (locals.get(message.session)?.socket !== socket) return;
             send(remote, { type: 'detach', session: message.session }); dropLocal(message.session); events.emit('detached', { session: message.session });
           });
-          socket.on('message', (data, isBinary) => {
-            if (locals.get(message.session)?.socket !== socket) return;
+          socket.on('message', (data, isBinary) => {
+            if (locals.get(message.session)?.socket !== socket && !current.detached) return;
             try {
               const response = decode(data, isBinary);
               if (!current.ready) {
                 if (response.type !== 'ready') throw new Error('Local desktop service authentication failed');
                 clearTimeout(current.timer); current.ready = true; send(remote, { type: 'ready', session: message.session });
               } else {
+                const usage = response.type === 'response' ? current.usageRequests.get(response.id) : null;
+                if (usage) {
+                  current.usageRequests.delete(response.id);
+                  const threadId = usage.threadId || response.body?.threadId;
+                  if (response.status >= 200 && response.status < 300 && typeof threadId === 'string') {
+                    const turnId = usage.created ? response.body?.turnId : response.body?.usage?.turnId;
+                    const turnKind = usage.created ? 'start' : response.body?.usage?.kind;
+                    send(remote, { type: 'usage-message', session: message.session, requestId: response.id,
+                      threadId, messageKey: usage.messageKey, turnId, turnKind,
+                      completed: completedTurns.has(`${threadId}:${turnId}`), observerReady: turnObserverReady });
+                    if (turnKind === 'start' && typeof turnId === 'string' && !completedTurns.has(`${threadId}:${turnId}`)) {
+                      trackedTurns.set(threadId, turnId); saveTrackedTurns();
+                      if (turnObserverReady && !activeTurns.has(threadId)) queueTurnResync(threadId, turnId);
+                    }
+                  } else send(remote, { type: 'usage-cancel', session: message.session, requestId: response.id });
+                }
+                if (current.detached) {
+                  if (!current.usageRequests.size) socket.terminate();
+                  return;
+                }
                 const payload = data.toString();
                 current.bridgeOutbound = current.bridgeOutbound.then(async () => {
                   const probe = await current.probe;

package/dist/src/self-relay/email-accounts.mjs

@@ -115,11 +115,27 @@ export function openEmailAccounts(pool, configFile, providerOverride) {
     return { id: rows[0].id, email: rows[0].email, expiresAt: isoTime(rows[0].expires_at) };
   }
 
+  async function usage(userId) {
+    const [settings] = await pool.query('SELECT mode FROM relay_usage_settings WHERE id=1');
+    if (settings.length !== 1) throw new Error('Missing relay usage settings');
+    const [budgets] = await pool.execute(`SELECT period_start,period_end,limit_seconds,used_seconds FROM relay_usage_budgets
+      WHERE user_id=? AND period_start<=UTC_TIMESTAMP(3) AND period_end>UTC_TIMESTAMP(3)
+      ORDER BY period_start DESC LIMIT 2`, [userId]);
+    if (budgets.length > 1) throw new Error('Overlapping relay usage budgets');
+    const budget = budgets[0];
+    const [totals] = await pool.execute('SELECT task_seconds FROM relay_usage_totals WHERE user_id=?', [userId]);
+    return { mode: settings[0].mode, periodStart: budget ? isoTime(budget.period_start) : null,
+      periodEnd: budget ? isoTime(budget.period_end) : null,
+      limitSeconds: budget?.limit_seconds == null ? null : Number(budget.limit_seconds),
+      usedSeconds: budget ? Number(budget.used_seconds) : 0,
+      taskSeconds: Number(totals[0]?.task_seconds || 0) };
+  }
+
   async function logout(token) {
     await current(token);
     await pool.execute('UPDATE user_sessions SET revoked_at=UTC_TIMESTAMP(3) WHERE token_hash=? AND revoked_at IS NULL', [tokenHash(token)]);
     return { ok: true };
   }
 
-  return { captchaAppId: config.captchaAppId, requestCode, verifyCode, current, logout };
+  return { captchaAppId: config.captchaAppId, requestCode, verifyCode, current, usage, logout };
 }

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

@@ -142,6 +142,7 @@ async function createRelayRuntime(stateRoot) {
       const lanCandidates = await currentLanCandidates();
       connector?.events.removeAllListeners(); connector?.close();
       const current = connector = connectBridgeRelay({ relayUrl: config.url, hostKey: identity.registered ? undefined : hostKey, 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') }; },
         hostName: hostname(), lanCandidates, p2pProbe: config.p2pProbe === true, iceServers: config.p2pIceServers || [],

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'];
+    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';
@@ -10,11 +11,14 @@ import { relayAdminState } from './admin-state.mjs';
 import { openRelayMysql } from './mysql-state.mjs';
 import { adminPage } from './admin-page.mjs';
 import { openEmailAccounts } from './email-accounts.mjs';
+import { usageMeter, usageReport } from './usage-meter.mjs';
+import { usageDiagnostics } from './usage-diagnostics.mjs';
 
 // Always loopback; a TLS reverse proxy supplies the private-trial Internet endpoint.
 export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlMs = 120000,
   maxConnections = 32, maxClientsPerHost = 16, maxPayload = 8 * 1024 * 1024, stateFile,
-  maxRelaySessions = 8, adminStateFile, 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');
@@ -25,8 +29,13 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
   if (appDownloadUrl && !/^https:\/\/[^\s]+$/.test(appDownloadUrl)) throw new Error('Invalid app download URL');
   const hostHash = digest(hostKey), rooms = new Map();
   const database = mysqlConfigFile ? await openRelayMysql(mysqlConfigFile, maxRelaySessions) : null;
-  if (accountConfigFile && !database?.schemaVersions.includes('002_email_accounts')) throw new Error('Email account schema is required');
+  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);
@@ -117,7 +126,8 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
       }
       const bearer = /^Bearer ([A-Za-z0-9_-]{43})$/.exec(request.headers.authorization || '')?.[1];
       if (target.pathname === '/account/me' && request.method === 'GET') {
-        accountReply(response, 200, { user: await accounts.current(bearer) }); return;
+        const user = await accounts.current(bearer);
+        accountReply(response, 200, { user, usage: await accounts.usage(user.id) }); return;
       }
       if (target.pathname === '/account/logout' && request.method === 'POST') {
         accountReply(response, 200, await accounts.logout(bearer)); return;
@@ -142,6 +152,23 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
     if (request.method === 'GET' && target.pathname === '/admin') {
       adminReply(response, 200, adminPage(), 'text/html; charset=utf-8'); return;
     }
+    if (target.pathname.startsWith('/admin/api/')) {
+      const token = /^Bearer ([A-Za-z0-9_-]{43})$/.exec(request.headers.authorization || '')?.[1];
+      const diagnosticRoute = target.pathname === '/admin/api/usage-diagnostics' ||
+        target.pathname === '/admin/api/usage-diagnostics/drain';
+      const keyAccepted = diagnosticRoute && diagnosticKey && token &&
+        timingSafeEqual(Buffer.from(token), Buffer.from(diagnosticKey));
+      let email;
+      if (!keyAccepted) {
+        try { email = (await accounts.current(token)).email; }
+        catch { adminReply(response, 401, { error: '请先登录管理员账号' }); return; }
+        const [allowed] = await database.pool.execute('SELECT email FROM relay_admin_emails WHERE email=?', [email]);
+        if (!allowed.length) { adminReply(response, 403, { error: '此账号没有后台管理权限' }); return; }
+      }
+      if (target.pathname === '/admin/api/session' && request.method === 'GET') {
+        adminReply(response, 200, { email }); return;
+      }
+    }
     if (request.method === 'GET' && target.pathname === '/admin/api/status') {
       const state = adminState.read();
       adminReply(response, 200, { maxRelaySessions: state.maxRelaySessions, activeRelaySessions,
@@ -151,6 +178,25 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
         processRssBytes: process.memoryUsage().rss, processUptimeSeconds: process.uptime(),
         announcement: state.announcement, announcements: state.announcements }); return;
     }
+    if (request.method === 'GET' && target.pathname === '/admin/api/usage' && meter) {
+      const page = Number(target.searchParams.get('page') || '1');
+      const user = target.searchParams.get('user') || '';
+      if (!Number.isSafeInteger(page) || page < 1 || page > 100000 || (user && !/^[0-9a-f-]{36}$/.test(user))) {
+        adminReply(response, 400, { error: 'Invalid usage query' }); return;
+      }
+      adminReply(response, 200, await usageReport(database.pool, page, user)); return;
+    }
+    if (diagnostics && target.pathname === '/admin/api/usage-diagnostics') {
+      if (request.method === 'GET') adminReply(response, 200, await diagnostics.read());
+      else if (request.method === 'DELETE') adminReply(response, 200, await diagnostics.clear());
+      else adminReply(response, 405, { error: 'Unsupported diagnostic request' });
+      return;
+    }
+    if (diagnostics && target.pathname === '/admin/api/usage-diagnostics/drain') {
+      if (request.method === 'POST') adminReply(response, 200, await diagnostics.drain());
+      else adminReply(response, 405, { error: 'Unsupported diagnostic request' });
+      return;
+    }
     if (!['PUT', 'DELETE'].includes(request.method || '') || request.headers['content-type'] !== 'application/json' ||
         request.headers['x-code-relax-admin'] !== '1') { adminReply(response, 405, { error: 'Unsupported admin request' }); return; }
     try {
@@ -245,10 +291,14 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
       }).catch(() => connection.ws.close(1011, 'Relay delivery failed'));
     };
     ws.on('error', () => {}); // close owns routing cleanup.
-    ws.on('close', (code, reason) => {
+    ws.on('close', (code, reason) => {
       log({ event: 'closed', role: role || 'unauthenticated', device: room?.id, code, reason: reason.toString() });
       clearTimeout(authTimer); clearInterval(heartbeat);
       if (role === 'host' && room?.host === ws) {
+        for (const task of room.usageTasks?.values() || []) {
+          void meter?.lost(task).catch(error => log({ event: 'usage-error', message: error.message }));
+        }
+        room.usageTasks?.clear(); room.usageArms?.clear();
         room.host = undefined; room.hostName = undefined; room.lanCandidates = [];
         room.uploadHost?.close(4410, 'Computer offline');
         for (const client of room.uploadClients?.values() || []) client.ws.close(4410, 'Computer offline');
@@ -256,7 +306,8 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
         if (!room.durable) rooms.delete(room.id);
         for (const connection of room.connections.values()) connection.ws.close(4410, 'Computer offline; authorization retained');
       } else if (role === 'client' && room?.connections.get(clientId)?.ws === ws) {
-        releaseRelay(room.connections.get(clientId));
+        const connection = room.connections.get(clientId);
+        releaseRelay(connection);
         room.connections.delete(clientId);
         if (room.host) send(room.host, { type: 'detach', session });
       } else if (role === 'observer' && room?.observers.get(clientId)?.ws === ws) {
@@ -323,7 +374,14 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
             }
             const oldHost = room.host;
             room.observers ||= new Map();
+            if (oldHost && oldHost !== ws) {
+              for (const task of room.usageTasks?.values() || []) {
+                try { await meter?.lost(task); } catch (error) { log({ event: 'usage-error', message: error.message }); }
+              }
+              room.usageTasks?.clear(); room.usageArms?.clear();
+            }
             room.host = ws; room.hostName = hostName; room.lanCandidates = lanCandidates;
+            room.usageTasks ||= new Map(); room.usageArms ||= new Map();
             if (oldHost && oldHost !== ws) room.uploadHost?.close(4409, 'Computer connection replaced');
             room.p2pProbe = message.p2pProbe === 1; room.p2pProbeRepeat = message.p2pProbeRepeat === true;
             role = 'host'; clearTimeout(authTimer);
@@ -382,6 +440,11 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
             return;
           }
           if (!room.host) return fail(4410, 'Computer offline; authorization retained');
+          let userId;
+          if (accounts && message.accountToken !== undefined) {
+            try { userId = (await accounts.current(message.accountToken)).id; }
+            catch { return fail(4431, 'Account session invalid'); }
+          }
           const oldConnection = room.connections.get(clientId);
           role = 'client'; clearTimeout(authTimer); session = randomUUID();
           if (oldConnection?.ws && oldConnection.ws !== ws) {
@@ -390,9 +453,11 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
             oldConnection.ws.close(4409, 'Phone connection replaced by same identity');
           }
           room.connections.set(clientId, { ws, session, p2pProbe: room.p2pProbe && message.p2pProbe === 1,
+            userId,
             repeat: room.p2pProbeRepeat, signals: 0, probeStarted: 0, outbound: Promise.resolve(), queuedBytes: 0,
             relayAdmitted: false, relayExempt: false,
             capacityExempt: debugAllowed(debugAllowlist, room.id, room.clients.find(client => client.id === clientId)) });
+          diagnostics?.record('client', userId ? 'account-linked' : 'anonymous');
           send(ws, { type: 'paired', protocolVersion: 7, room: room.id, clientId, revision: room.revision, ...(credential ? { credential } : {}) });
           send(ws, { type: 'computer-info', hostName: room.hostName });
           if (room.lanCandidates?.length) send(ws, { type: 'lan-candidates', candidates: room.lanCandidates });
@@ -402,6 +467,83 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
         }
         if (role === 'host') {
           if (room.host !== ws) return;
+          if (meter && ['usage-arm', 'usage-message', 'usage-cancel', 'usage-turn', 'usage-observer-lost'].includes(message.type)) {
+            if (message.type === 'usage-observer-lost') {
+              for (const task of room.usageTasks.values()) {
+                try { await meter.lost(task); } catch (error) { log({ event: 'usage-error', message: error.message }); }
+              }
+              room.usageTasks.clear();
+              return;
+            }
+            const armKey = `${message.session}:${message.requestId}`;
+            const connection = [...room.connections.values()].find(item => item.session === message.session);
+            if (message.type === 'usage-arm') {
+              diagnostics?.record('arm', connection?.userId ? 'account-linked' : 'anonymous');
+              if (!connection?.userId || !Number.isSafeInteger(message.requestId) || message.requestId < 1 ||
+                  (message.threadId !== null && (!plainText(message.threadId, 128, false)))) {
+                diagnostics?.record('arm-rejected', !connection?.userId ? 'account-missing' : 'invalid-request');
+                return;
+              }
+              for (const [key, arm] of room.usageArms) if (Date.now() - arm.at > 120000) room.usageArms.delete(key);
+              if (room.usageArms.size >= 256) return;
+              room.usageArms.set(armKey, { userId: connection.userId,
+                clientId: [...room.connections.entries()].find(([, item]) => item === connection)?.[0],
+                session: message.session, at: Date.now() });
+              diagnostics?.record('arm-accepted', 'ready');
+              return;
+            }
+            if (message.type === 'usage-cancel') {
+              diagnostics?.record('message-cancelled', room.usageArms.has(armKey) ? 'armed' : 'arm-missing');
+              room.usageArms.delete(armKey); return;
+            }
+            if (message.type === 'usage-message') {
+              const arm = room.usageArms.get(armKey);
+              diagnostics?.record('message', arm ? 'armed' : 'arm-missing');
+              room.usageArms.delete(armKey);
+              if (!arm || Date.now() - arm.at > 120000 || !plainText(message.messageKey, 128, false)) {
+                diagnostics?.record('message-rejected', !arm ? 'arm-missing' : 'expired-or-invalid');
+                return;
+              }
+              try {
+                await meter.action(arm, room.id, arm.clientId, 'message', message.messageKey);
+                diagnostics?.record('message-counted', 'confirmed');
+                if (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);
+                      else room.usageTasks.set(key, task);
+                    }
+                  }
+                }
+              } catch (error) { diagnostics?.record('message-error', 'database'); log({ event: 'usage-error', message: error.message }); }
+              return;
+            }
+            if (!['turn/started', 'turn/completed', 'heartbeat', 'resume'].includes(message.method) ||
+                !plainText(message.threadId, 80, false) || !plainText(message.turnId, 80, false)) return;
+            const key = `${message.threadId}:${message.turnId}`;
+            if (key.length > 128) return;
+            let task = room.usageTasks.get(key);
+            try {
+              if (message.method === 'resume' && !task) {
+                task = await meter.turnOrigin(room.id, key);
+                if (!task) { diagnostics?.record('turn-resume', 'origin-missing'); return; }
+                await meter.pulse(task, true, room.id, task.clientId, `${key}:${randomUUID()}`);
+                diagnostics?.record('turn-resume', 'confirmed');
+                room.usageTasks.set(key, task);
+              } else if (task && message.method === 'heartbeat') await meter.pulse(task, true, room.id, task.clientId);
+              else if (task && message.method === 'turn/completed') {
+                await meter.pulse(task, false, room.id, task.clientId);
+                diagnostics?.record('turn-completed', 'confirmed');
+                room.usageTasks.delete(key);
+              }
+            } catch (error) { log({ event: 'usage-error', message: error.message }); }
+            return;
+          }
           if (message.type === 'lan-candidates') {
             room.lanCandidates = normalizeLanCandidates(message.candidates);
             for (const connection of room.connections.values()) send(connection.ws, { type: 'lan-candidates', candidates: room.lanCandidates });

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/dist/src/self-relay/usage-meter.mjs

@@ -0,0 +1,125 @@
+import { randomUUID } from 'node:crypto';
+
+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 [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 user_id,client_id FROM relay_usage_actions
+      WHERE computer_id=? AND kind='turn' AND action_key=?`, [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();
+      await pool.execute(`INSERT INTO relay_usage_sessions
+        (id,kind,external_key,user_id,computer_id,client_id,started_at,confirmed_until,charged_seconds)
+        VALUES (?,'task',?,?,?,?,UTC_TIMESTAMP(3),UTC_TIMESTAMP(3),0)`, [id, externalKey, connection.userId, computerId, clientId]);
+      connection.usageSessionId = id;
+      return;
+    }
+    const id = connection.usageSessionId;
+    const db = await pool.getConnection();
+    try {
+      await db.beginTransaction();
+      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 elapsedMs = Math.max(0, epoch(now) - epoch(row.confirmed_until));
+      const seconds = Math.min(elapsedMs, 20000) / 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 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, userId = '') {
+  if (userId) {
+    const [users] = await pool.execute(`SELECT u.id,i.normalized_value AS email,
+      COALESCE(t.task_seconds,0) AS task_seconds,
+      COALESCE(t.message_count,0) AS message_count,COALESCE(t.turn_count,0) AS turn_count
+      FROM users u JOIN user_login_identities i ON i.user_id=u.id AND i.kind='email'
+      LEFT JOIN relay_usage_totals t ON t.user_id=u.id WHERE u.id=?`, [userId]);
+    if (!users.length) return null;
+    const [computers] = await pool.execute(`SELECT c.id AS computer_id,
+      COALESCE(s.task_seconds,0) AS 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 computers c
+      LEFT JOIN (SELECT computer_id,
+        SUM(charged_seconds) AS task_seconds,
+        MAX(started_at) AS last_used_at FROM relay_usage_sessions WHERE user_id=? GROUP BY computer_id) s ON s.computer_id=c.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 user_id=? GROUP BY computer_id) a ON a.computer_id=c.id
+      WHERE s.computer_id IS NOT NULL OR a.computer_id IS NOT NULL
+      ORDER BY last_used_at DESC`, [userId, userId]);
+    return { user: users[0], computers };
+  }
+  const offset = (page - 1) * 30;
+  const [counts] = await pool.query(`SELECT COUNT(*) AS total FROM user_login_identities WHERE kind='email'`);
+  const [rows] = await pool.execute(`SELECT u.id,i.normalized_value AS email,
+    COALESCE(t.task_seconds,0) AS task_seconds,
+    COALESCE(t.message_count,0) AS message_count,COALESCE(t.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 users u JOIN user_login_identities i ON i.user_id=u.id AND i.kind='email'
+    LEFT JOIN relay_usage_totals t ON t.user_id=u.id
+    LEFT JOIN (SELECT user_id,MAX(started_at) AS last_used_at FROM relay_usage_sessions GROUP BY user_id) s ON s.user_id=u.id
+    LEFT JOIN (SELECT user_id,MAX(occurred_at) AS last_used_at FROM relay_usage_actions GROUP BY user_id) a ON a.user_id=u.id
+    ORDER BY task_seconds DESC,last_used_at DESC,u.id LIMIT ? OFFSET ?`, [30, offset]);
+  return { page, pageSize: 30, total: counts[0].total, rows };
+}

package/dist/src/server.mjs

@@ -283,7 +283,7 @@ async function handleRequest(request, response) {
       return;
     }
 
-    if (request.method === 'GET' && url.pathname === '/api/usage-events') {
+    if (request.method === 'GET' && url.pathname === '/api/usage-events') {
       const execution = sharedServer;
       response.startEvents();
       const emit = value => { if (!response.destroyed) response.event('usage', value); };
@@ -292,8 +292,45 @@ async function handleRequest(request, response) {
       execution.on('usage', emit); execution.on('usage-error', failed); execution.on('disconnected', disconnected);
       response.once('close', () => { execution.off('usage', emit); execution.off('usage-error', failed); execution.off('disconnected', disconnected); });
       try { emit(await execution.usage()); } catch (error) { failed(error); }
-      return;
-    }
+      return;
+    }
+
+    if (request.method === 'GET' && url.pathname === '/api/turn-events') {
+      response.startEvents();
+      const listener = ({ method, params }) => {
+        if (!['turn/started', 'turn/completed'].includes(method)) return;
+        const threadId = params?.threadId, turnId = params?.turn?.id;
+        if (typeof threadId === 'string' && typeof turnId === 'string' && !response.destroyed) {
+          response.event('turn', { method, threadId, turnId });
+        }
+      };
+      const disconnected = () => response.end();
+      sharedServer.on('notification', listener);
+      sharedServer.on('disconnected', disconnected);
+      response.once('close', () => {
+        sharedServer.off('notification', listener);
+        sharedServer.off('disconnected', disconnected);
+      });
+      return;
+    }
+
+    const activeTurnMatch = /^\/api\/threads\/([^/]+)\/active-turn$/.exec(url.pathname);
+    if (request.method === 'GET' && activeTurnMatch) {
+      const threadId = decodeURIComponent(activeTurnMatch[1]);
+      await sharedServer.connect();
+      const { thread } = await sharedServer.request('thread/read', { threadId, includeTurns: false });
+      const status = typeof thread.status === 'string' ? thread.status : thread.status?.type;
+      let turnId = null;
+      if (status === 'active') {
+        const page = await sharedServer.request('thread/turns/list', {
+          threadId, limit: 1, sortDirection: 'desc', itemsView: 'summary',
+        });
+        const latest = page.data?.[0];
+        if (latest?.status === 'inProgress') turnId = latest.id;
+      }
+      sendJson(response, 200, { turnId });
+      return;
+    }
 
     const createThreadMatch = /^\/api\/projects\/([^/]+)\/threads$/.exec(url.pathname);
     if (request.method === 'POST' && createThreadMatch) {
@@ -473,7 +510,8 @@ async function handleRequest(request, response) {
       await requireExecutionWritable(threadId);
       const body = await readJsonBody(request);
       if (body.hostId && body.hostId !== 'local') throw new RequestError(410, '此对话的连接方式已停用。', { code: 'unsupported_control' });
-      sendJson(response, 200, { success: true, data: await sharedServer.send(appServerTurnArguments(threadId, body)) });
+      const submitted = await sharedServer.send(appServerTurnArguments(threadId, body));
+      sendJson(response, 200, { success: true, data: submitted.result, usage: submitted.usage });
       return;
     }
 
@@ -711,12 +749,12 @@ function messagePayload(body) {
   return payload;
 }
 
-function appServerTurnArguments(threadId, body) {
+function appServerTurnArguments(threadId, body) {
   const payload = messagePayload(body);
   const input = [];
   if (payload.prompt) input.push({ type: 'text', text: payload.prompt });
   for (const image of payload.images) input.push(image.startsWith('data:') ? { type: 'image', url: image } : { type: 'localImage', path: image });
-  const value = { threadId, input };
+  const value = { threadId, input, ...appServerEvents.mobileTurnSource(body.clientUserMessageId) };
   if (typeof body.clientUserMessageId === 'string' && /^[a-f0-9]{32}$/.test(body.clientUserMessageId)) value.clientUserMessageId = body.clientUserMessageId;
   if (payload.model) value.model = payload.model;
   if (payload.thinking) value.effort = payload.thinking;

package/dist/src/shared-app-server.mjs

@@ -136,15 +136,18 @@ export class SharedAppServer extends EventEmitter {
     // Reading the live thread checks this service owns it without resume changing settings.
     const { thread } = await this.request('thread/read', { threadId: args.threadId, includeTurns: false });
     const status = typeof thread.status === 'string' ? thread.status : thread.status?.type;
-    if (status === 'active') {
+    if (status === 'active') {
       const page = await this.request('thread/turns/list', {
         threadId: args.threadId, limit: 1, sortDirection: 'desc', itemsView: 'summary',
       });
       const active = page.data?.[0];
       if (active?.status !== 'inProgress') throw new Error('活动轮次已变化，请刷新后再发送。');
-      return this.request('turn/steer', { threadId: args.threadId, expectedTurnId: active.id, input: args.input, ...(args.clientUserMessageId ? { clientUserMessageId: args.clientUserMessageId } : {}) });
-    }
-    return this.request('turn/start', args);
+      const { turnTrigger, ...source } = events.mobileTurnSource(args.clientUserMessageId);
+      const result = await this.request('turn/steer', { threadId: args.threadId, expectedTurnId: active.id, input: args.input, ...source, ...(args.clientUserMessageId ? { clientUserMessageId: args.clientUserMessageId } : {}) });
+      return { result, usage: { kind: 'steer', turnId: active.id } };
+    }
+    const result = await this.request('turn/start', args);
+    return { result, usage: { kind: 'start', turnId: result?.turn?.id || null } };
   }
 
   respondApproval(threadId, body) {

package/package.json

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