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

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

@@ -6,9 +6,53 @@ export const adminUiTokens = `:root{
   --admin-accent:#286e43;--admin-accent-surface:#e0f0e5;
   --admin-error:#a5443b;--admin-card-radius:16px;--admin-control-radius:9px;
   --admin-card-padding:22px;
+  --admin-font:14px;--admin-heading:24px;--admin-title:18px;--admin-value:16px;--admin-label:12px;
+  --admin-space-sm:6px;--admin-space:12px;--admin-space-lg:18px;--admin-control-height:44px;
+  --admin-login-width:400px;--admin-status-height:42px;
   --admin-footer-caption:12px;--admin-footer-opacity:0.75;--admin-footer-space:24px;
 }`;
 
 export const adminFooterStyles = `body{display:flex;flex-direction:column}
 body>main{width:100%;flex:1;margin:0 auto}
 .admin-footer{flex-shrink:0;padding:0 var(--admin-footer-space) var(--admin-footer-space);text-align:center;color:var(--admin-muted);font-size:var(--admin-footer-caption);opacity:var(--admin-footer-opacity)}`;
+
+export const adminAuthStyles = `
+*{box-sizing:border-box}.admin-login{margin:0;min-height:100vh;background:var(--admin-page);color:var(--admin-text);font:var(--admin-font)/1.5 system-ui,"Microsoft YaHei",sans-serif}
+.admin-login main{display:grid;place-items:center;padding:var(--admin-card-padding)}
+.login-card{width:100%;max-width:var(--admin-login-width);padding:var(--admin-card-padding);background:var(--admin-surface);border:1px solid var(--admin-border);border-radius:var(--admin-card-radius);display:grid;gap:var(--admin-space)}
+.login-card h1{font-size:var(--admin-heading);margin:0}.login-card p{margin:0;color:var(--admin-muted)}
+.login-card input,.login-card button{font:inherit;min-height:var(--admin-control-height);padding:var(--admin-space);border:1px solid var(--admin-border);border-radius:var(--admin-control-radius)}
+.login-card input{width:100%;background:var(--admin-surface);color:var(--admin-text)}
+.login-card button{background:var(--admin-accent-surface);color:var(--admin-accent);cursor:pointer;font-weight:600}
+.login-card button:disabled{opacity:.6;cursor:wait}.login-card :focus-visible{outline:2px solid var(--admin-accent);outline-offset:2px}
+.login-card #result{min-height:var(--admin-status-height);color:var(--admin-error)}
+.page-head .admin-logout{margin-left:auto;flex:none;white-space:nowrap}
+@media(max-width:600px){.page-head{flex-wrap:wrap}.page-head .nav{order:3;flex-basis:100%}}`;
+
+export const adminWorkstationStyles = `
+.workstation-content{display:grid;gap:var(--admin-space-lg)}
+.workstation-row{display:grid;gap:var(--admin-space-lg);width:100%;text-align:left;text-decoration:none;min-height:var(--admin-control-height);padding:var(--admin-card-padding);border:1px solid var(--admin-row-border);border-radius:var(--admin-card-radius);background:var(--admin-row);color:var(--admin-text);font-weight:400}
+.workstation-row:hover{background:var(--admin-accent-surface);color:var(--admin-text)}
+.workstation-row:focus-visible{outline:2px solid var(--admin-accent);outline-offset:2px}
+.workstation-row-heading{display:flex;align-items:center;justify-content:space-between;gap:var(--admin-space)}
+.workstation-row-heading strong{min-width:0;overflow-wrap:anywhere;font-size:var(--admin-title)}
+.workstation-state{display:inline-flex;flex:none;align-items:center;padding:var(--admin-space-sm) var(--admin-space);border-radius:var(--admin-card-radius);background:var(--admin-accent-surface);color:var(--admin-accent);font-size:var(--admin-label);font-weight:700}
+.workstation-state.offline{background:var(--admin-row-border);color:var(--admin-muted)}
+.workstation-key-grid{display:grid;grid-template-columns:minmax(0,1fr) minmax(0,1fr) minmax(0,2fr) minmax(0,1fr);gap:var(--admin-space-lg);margin:0}
+.workstation-key{min-width:0}.workstation-key dt{color:var(--admin-muted);font-size:var(--admin-label);margin-bottom:var(--admin-space-sm)}
+.workstation-key dd{margin:0;font-size:var(--admin-value);font-weight:600;overflow-wrap:anywhere;color:var(--admin-text)}
+.workstation-key dd.working{color:var(--admin-accent)}
+.workstation-account-note{display:block;font-size:var(--admin-label);font-weight:400;color:var(--admin-muted);margin-top:var(--admin-space-sm)}
+.workstation-row-footer{display:flex;align-items:center;justify-content:space-between;gap:var(--admin-space)}
+.workstation-more{flex:none;color:var(--admin-accent);font-size:var(--admin-label)}
+.workstation-overview{display:grid;gap:var(--admin-space-lg);padding:var(--admin-card-padding);background:var(--admin-row);border:1px solid var(--admin-row-border);border-radius:var(--admin-card-radius)}
+.workstation-disclosure{min-width:0;border:1px solid var(--admin-border);border-radius:var(--admin-control-radius);background:var(--admin-surface)}
+.workstation-disclosure>summary{cursor:pointer;padding:var(--admin-space);font-weight:600;min-height:var(--admin-control-height);color:var(--admin-text)}
+.workstation-disclosure>summary:focus-visible{outline:2px solid var(--admin-accent);outline-offset:2px}
+.workstation-disclosure-content{display:grid;gap:var(--admin-space);padding:0 var(--admin-space) var(--admin-space)}
+.workstation-phone{display:grid;gap:var(--admin-space);padding:var(--admin-space);background:var(--admin-row);border-radius:var(--admin-control-radius)}
+.workstation-block{display:grid;gap:var(--admin-space);min-width:0;padding:var(--admin-space);border:1px solid var(--admin-border);border-radius:var(--admin-control-radius)}
+.workstation-fields{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:var(--admin-space);margin:0}
+.workstation-fields>div{min-width:0}.workstation-fields dd{margin:0;overflow-wrap:anywhere;font-variant-numeric:tabular-nums}
+#workstationBack[hidden]{display:none}
+@media(max-width:600px){.workstation-fields{grid-template-columns:minmax(0,1fr)}.workstation-row,.workstation-overview{padding:var(--admin-space)}.workstation-key-grid{grid-template-columns:repeat(2,minmax(0,1fr))}.workstation-key-account{grid-column:1/-1;order:3}.workstation-row-heading{align-items:start}}`;

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

@@ -0,0 +1,95 @@
+export const adminWorkstationsMarkup = `
+<section id="workstations" class="page stack" hidden>
+  <section class="card">
+    <div class="usage-toolbar"><div><h2 id="workstationHeading">工作站</h2><p id="workstationCount" class="hint">正在读取</p></div>
+      <div class="actions"><button id="workstationBack" class="secondary" type="button" hidden>返回列表</button><button id="workstationRefresh" class="secondary" type="button">刷新</button></div></div>
+    <div id="workstationContent" class="workstation-content"></div><p id="workstationError" class="status error" role="alert"></p>
+  </section>
+</section>`;
+
+export const adminWorkstationsScript = String.raw`
+let workstationId=null,workstationController=null,workstationGeneration=0,workstationRendered='';
+const workstationDisclosures=new Map();
+const workstationRouteNames={management:'管理连接',pending:'连接方式待确认',direct:'中继直连',relay:'中继转发',lan:'局域网','self-relay':'Code Relax 中继'};
+function workstationTime(value){return value?new Date(value).toLocaleString('zh-CN',{timeZone:'Asia/Shanghai',year:'numeric',month:'2-digit',day:'2-digit',hour:'2-digit',minute:'2-digit',second:'2-digit',hour12:false}):'未记录'}
+function workstationFields(values){const list=node('dl','workstation-fields');for(const [label,value] of values){const row=node('div');row.append(node('dt','hint',label),node('dd','',value==null||value===''?'未提供':String(value)));list.append(row)}return list}
+function workstationBlock(title){const block=node('section','workstation-block');block.append(node('h3','',title));return block}
+function workstationAccount(accounts,missing='未上报'){return accounts.length?accounts.map(account=>account.email||account.id).join('、'):missing}
+function workstationAccountView(item){return item.accounts.length?{value:workstationAccount(item.accounts),note:'当前认证'}:item.associatedAccounts.length?{value:workstationAccount(item.associatedAccounts),note:'最近确认'}:{value:'未上报',note:''}}
+function workstationAssociated(accounts){return accounts.length?accounts.map(account=>account.email+(account.lastVerifiedAt?'（'+workstationTime(account.lastVerifiedAt)+' 确认）':'')).join('、'):'未上报'}
+function workstationStatus(online){return node('span','workstation-state'+(online?'':' offline'),online?'在线':'离线')}
+function workstationLastRoute(item){return workstationRouteNames[item.lastConnection?.mode]||'未记录'}
+function workstationConnectionState(item){return {connected:'已连接',disconnected:'已断开',unconfirmed:'未确认'}[item.connectionState]||'未确认'}
+function workstationWork(item,online=item.online){return online?(item.activeTasks?'工作中 · '+item.activeTasks+' 项':'未确认'):'—'}
+function workstationHighlights(item,online=item.online){
+  const list=node('dl','workstation-key-grid');const account=workstationAccountView(item);
+  for(const [key,label,value,note] of [['state','手机连接状态',workstationConnectionState(item),''],['connection','上次连接方式',workstationLastRoute(item),''],['account','手机账号',account.value,account.note],['work','工作状态',workstationWork(item,online),'']]){
+    const field=node('div','workstation-key workstation-key-'+key);field.append(node('dt','',label));const result=node('dd','',value);
+    if(note)result.append(node('small','workstation-account-note',note));if(key==='work'&&online&&item.activeTasks)result.classList.add('working');field.append(result);list.append(field)
+  }return list
+}
+function workstationDisclosure(item,key,title){const details=node('details','workstation-disclosure');const identity=item.id+':'+key;details.open=workstationDisclosures.get(identity)===true;details.append(node('summary','',title));details.addEventListener('toggle',()=>{if(details.isConnected)workstationDisclosures.set(identity,details.open)});return details}
+function openWorkstation(id){history.pushState({workstationDetail:true},'','#workstations/'+encodeURIComponent(id));showPage('workstations/'+encodeURIComponent(id))}
+function cancelWorkstations(){workstationGeneration++;workstationController?.abort();workstationController=null;workstationRendered=''}
+function workstationCaption(result){if(result.workstation){const item=result.workstation;return (item.online?'在线':'离线')+' · 更新 '+workstationTime(result.sampledAt)}const online=result.workstations.filter(item=>item.online).length;return online+' 台在线 · '+(result.workstations.length-online)+' 台离线 · 按上线时间从新到旧'}
+function renderWorkstationList(result){
+  const list=el('workstationContent');list.replaceChildren();el('workstationCount').textContent=workstationCaption(result);
+  if(!result.workstations.length){list.append(node('p','empty-note','暂无工作站'));return}
+  for(const item of result.workstations){
+    const row=node('a','workstation-row');row.href='#workstations/'+encodeURIComponent(item.id);row.addEventListener('click',event=>{if(event.button!==0||event.ctrlKey||event.metaKey||event.shiftKey||event.altKey)return;event.preventDefault();openWorkstation(item.id)});const heading=node('span','workstation-row-heading');heading.append(node('strong','',item.name),workstationStatus(item.online));
+    const footer=node('span','workstation-row-footer');footer.append(node('span','hint',(item.online?'上线时间 ':'最近上线 ')+workstationTime(item.onlineAt)),node('span','workstation-more','查看 ›'));
+    row.append(heading,workstationHighlights(item),footer);list.append(row)
+  }
+}
+function renderWorkstationDetail(result){
+  const item=result.workstation;const content=el('workstationContent');content.replaceChildren();el('workstationHeading').textContent=item.name;el('workstationCount').textContent=workstationCaption(result);
+  const overview=node('section','workstation-overview');const heading=node('div','workstation-row-heading');heading.append(workstationStatus(item.online),node('span','hint',(item.online?'上线时间 ':'最近上线 ')+workstationTime(item.onlineAt)));
+  overview.append(heading,workstationHighlights(item),node('p','hint','聊天连接 '+item.chatPhones+' 台手机 · 已配对 '+item.pairedPhones+' 台'));content.append(overview);
+  const phones=workstationDisclosure(item,'phones','手机与账号 · '+item.pairedPhones+' 台');const phoneList=node('div','workstation-disclosure-content');
+  if(!item.phones.length)phoneList.append(node('p','hint','尚无配对手机'));
+  for(const phone of item.phones){
+    const card=node('article','workstation-phone');const title=node('div','workstation-row-heading');const platform={android:'Android',harmony:'HarmonyOS',ios:'iOS'}[phone.platform]||'';
+    title.append(node('strong','',phone.deviceName||platform||'手机'),node('span','hint',workstationConnectionState(phone)));
+    const account=workstationAccountView(phone);card.append(title,workstationFields([['上次连接方式',workstationLastRoute(phone)],['手机账号',account.value+(account.note?' · '+account.note:'')]]));phoneList.append(card)
+  }phones.append(phoneList);content.append(phones);
+  const diagnostics=workstationDisclosure(item,'diagnostics','诊断详情');const body=node('div','workstation-disclosure-content');
+  const station=workstationBlock('工作站记录');station.append(workstationFields([
+    ['工作站 ID',item.id],['上线时间',workstationTime(item.onlineAt)],['来源 IP',item.connection?.address],['登记时间',workstationTime(item.registeredAt)],['授权更新时间',workstationTime(item.updatedAt)],
+    ['手机关联账号',workstationAssociated(item.associatedAccounts)],['当前认证账号',workstationAccount(item.accounts,'未确认')],['任务账号',workstationAccount(item.taskAccounts,'未记录')],
+    ['元数据连接',item.metadataPhones+' 台手机'],['调试白名单',item.debugEnabled?'已启用':'未启用'],['文件接收通道',item.fileReceiverOnline?'在线':'未连接']
+  ]));body.append(station);
+  const connectionEvents=workstationBlock('手机连接记录 · 工作站上报');
+  connectionEvents.append(node('p','hint',item.connectionReportingCurrent?'已收到当前工作站连接状态':'当前上报未确认；不据此推断手机断开'));
+  for(const event of item.connectionEvents||[]){const phone=item.phones.find(value=>value.id===event.clientId);connectionEvents.append(workstationFields([
+    ['时间',workstationTime(event.at)],['事件',event.state==='connected'?'手机已连接':'手机已断开'],['手机',phone?.deviceName||event.clientId],['连接方式',workstationRouteNames[event.mode]||'未确认']
+  ]))}
+  if(!item.connectionEvents?.length)connectionEvents.append(node('p','hint','暂无连接 / 断开记录'));body.append(connectionEvents);
+  const networks=workstationBlock('网络与 OpenAI 环境');
+  for(const network of item.lanCandidates)networks.append(workstationFields([['局域网地址',network.address],['网络',network.networkType==='wifi'?'Wi-Fi':'以太网'],['网络名称',network.networkName],['网卡',network.interfaceName]]));
+  if(item.officialComputer){const official=item.officialComputer;networks.append(workstationFields([['OpenAI 环境 ID',official.environmentId],['环境名称',official.name],['主机名',official.hostname],['登记时间',workstationTime(official.updatedAt)]]))}
+  if(!item.lanCandidates.length&&!item.officialComputer)networks.append(node('p','hint','尚未上报网络资料'));body.append(networks);
+  for(const phone of item.phones){
+    const card=workstationBlock(phone.deviceName||'手机连接记录');card.append(workstationFields([
+      ['手机 ID',phone.id],['平台',phone.platform],['关联账号',workstationAssociated(phone.associatedAccounts)],['当前认证账号',workstationAccount(phone.accounts,'未确认')],['任务账号',workstationAccount(phone.taskAccounts,'未记录')],
+      ['元数据连接',phone.metadata?'已连接':'未连接'],['设备管理连接',phone.managers.length+' 个'],['配对时间',workstationTime(phone.pairedAt)],['最近鉴权',workstationTime(phone.lastConnectedAt)],['最近局域网上报',workstationTime(phone.lastLanConnectedAt)],['上次连接时间',workstationTime(phone.lastConnection?.at)]
+    ]));
+    const channels=[...(phone.chat?[['聊天 / 管理',phone.chat]]:[]),...(phone.metadata?[['元数据',phone.metadata]]:[]),...phone.managers.map(channel=>['设备管理',channel]),...phone.transfers.map(channel=>[channel.purpose==='upload'?'文件上传':'文件下载',channel])];
+    for(const [name,channel] of channels)card.append(workstationFields([['通道',name],['认证账号',channel.account?.email||'未上报'],['连接时间',workstationTime(channel.connectedAt)],['来源 IP',channel.address]]));
+    if(phone.chat)card.append(workstationFields([['转发容量',phone.chat.relayAdmitted?(phone.chat.capacityExempt?'白名单豁免':'占用名额'):'未占用'],['待发送队列',phone.chat.queuedBytes+' 字节']]));body.append(card)
+  }
+  if(item.tasks.length){const tasks=workstationBlock('任务记录');for(const task of item.tasks)tasks.append(workstationFields([['线程 / 轮次',task.key],['手机 ID',task.clientId],['任务账号',task.account?.email||task.userId]]));body.append(tasks)}
+  const notes=workstationBlock('状态说明');notes.append(node('p','hint','在线表示工作站已连接云端中继，不代表内核已就绪。手机连接状态与上次连接方式独立：方式保留最近一次工作站确认的局域网 / Code Relax 中继，断开、工作站离线或云端重启不清空；未记录不推测。未确认表示云端没有足够的当前状态，不能据此判断手机未登录或工作站空闲。'),node('p','hint','局域网 / Code Relax 中继的连接、断开由新版工作站上报；健康探测、管理和文件通道不计入。工作站上报链路丢失不记作手机断开，OpenAI 中继暂未提供可靠的手机连接事件。'),node('p','hint','手机账号标为“最近确认”时来自既有验证记录，不代表当前登录；具体时间见关联账号记录。时间按北京时间显示，每 5 秒更新。'));
+  body.append(notes);diagnostics.append(body);content.append(diagnostics);
+}
+async function loadWorkstations(){
+  if(el('workstations').hidden||workstationController)return;const generation=workstationGeneration;const controller=workstationController=new AbortController();el('workstationRefresh').disabled=true;
+  try{
+    const result=await request('/admin/api/workstations'+(workstationId?'/'+encodeURIComponent(workstationId):''),{signal:controller.signal});if(generation!==workstationGeneration||el('workstations').hidden)return;
+    el('workstationError').textContent='';const signature=JSON.stringify(result.workstation||result.workstations);
+    if(signature!==workstationRendered){if(workstationId)renderWorkstationDetail(result);else renderWorkstationList(result);workstationRendered=signature}else el('workstationCount').textContent=workstationCaption(result)
+  }catch(error){if(generation!==workstationGeneration||controller.signal.aborted)return;workstationRendered='';el('workstationCount').textContent='读取失败，当前状态未确认';el('workstationContent').replaceChildren();el('workstationError').textContent=error.message}
+  finally{if(workstationController===controller){workstationController=null;el('workstationRefresh').disabled=false}}
+}
+el('workstationRefresh').addEventListener('click',()=>loadWorkstations());
+el('workstationBack').addEventListener('click',()=>{if(history.state?.workstationDetail)history.back();else navigatePage('workstations')});
+`;

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

@@ -0,0 +1,143 @@
+// Explicit projections: authorization hashes, credentials, socket objects and payloads
+// must never become part of the management API.
+const open = entry => entry?.ws?.readyState === 1;
+const socket = ws => ({ connectedAt: ws.adminInfo?.connectedAt || null,
+  address: ws.adminInfo?.address || null, account: ws.adminInfo?.account
+    ? { id: ws.adminInfo.account.id, email: ws.adminInfo.account.email } : null });
+
+export function workstationDetail(room, debugEnabled = false) {
+  const online = room.host?.readyState === 1;
+  const connectionReportingCurrent = online && room.adminPhoneConnections !== undefined;
+  const tasks = online ? [...(room.usageTasks?.entries() || [])] : [];
+  const phones = room.clients.map(client => {
+    const connection = room.connections.get(client.id);
+    const chat = online && open(connection) ? connection : null;
+    const observer = room.observers?.get(client.id);
+    const metadata = open(observer) ? socket(observer.ws) : null;
+    const managers = [...(room.deviceManagers?.entries() || [])]
+      .filter(([ws, id]) => id === client.id && ws.readyState === 1).map(([ws]) => socket(ws));
+    const transfers = online ? [...(room.uploadClients?.values() || [])]
+      .filter(entry => entry.clientId === client.id && open(entry))
+      .map(entry => ({ purpose: entry.purpose, ...socket(entry.ws) })) : [];
+    const activeTasks = tasks.filter(([, task]) => task.clientId === client.id).length;
+    const reportedConnections = online ? [...(room.adminPhoneConnections?.values() || [])]
+      .filter(item => item.clientId === client.id).map(item => ({ connectionId: item.connectionId, mode: item.mode })) : [];
+    const connected = reportedConnections.length > 0 || Boolean(chat?.userId);
+    const channels = [chat && socket(chat.ws), metadata, ...managers, ...transfers].filter(Boolean);
+    const accounts = [...new Map(channels.filter(item => item.account)
+      .map(item => [item.account.id, item.account])).values()];
+    const taskAccounts = [...new Set(tasks.filter(([, task]) => task.clientId === client.id)
+      .map(([, task]) => task.userId).filter(Boolean))].map(id => accounts.find(account => account.id === id) || { id, email: null });
+    return {
+      id: client.id, deviceName: client.deviceName || null, platform: client.platform || null,
+      pairedAt: client.createdAt || null, lastConnectedAt: client.lastConnectedAt || null,
+      connected, connectionState: connected ? 'connected' : connectionReportingCurrent ? 'disconnected' : 'unconfirmed',
+      lastConnection: null, reportedConnections,
+      accounts, taskAccounts, associatedAccounts: [], metadata, managers, transfers, activeTasks,
+      chat: chat ? { ...socket(chat.ws), route: chat.userId ? chat.adminRoute || 'pending' : 'management',
+        capacityExempt: Boolean(chat.capacityExempt), relayAdmitted: Boolean(chat.relayAdmitted || chat.relayExempt),
+        queuedBytes: chat.queuedBytes || 0 } : null,
+      lastLanConnectedAt: room.adminLanConnections?.get(client.id) || null,
+    };
+  }).sort((a, b) => Number(b.connected) - Number(a.connected) ||
+    (b.lastConnectedAt || '').localeCompare(a.lastConnectedAt || '') || a.id.localeCompare(b.id));
+  const accounts = [...new Map(phones.flatMap(phone => phone.accounts).map(account => [account.id, account])).values()];
+  const taskAccounts = [...new Set(tasks.map(([, task]) => task.userId).filter(Boolean))]
+    .map(id => accounts.find(account => account.id === id) || { id, email: null });
+  return {
+    id: room.id, name: room.hostName || room.adminLastHostName || room.officialComputer?.hostname || '工作站 …' + room.id.slice(-8),
+    online, registeredAt: room.createdAt || null, updatedAt: room.updatedAt || null,
+    onlineAt: (online ? room.host.adminInfo?.connectedAt : room.adminLastOnlineAt) || null,
+    connection: online ? socket(room.host) : null,
+    pairedPhones: phones.length, connectedPhones: phones.filter(phone => phone.connected).length,
+    chatPhones: phones.filter(phone => phone.reportedConnections.length || phone.chat && phone.chat.route !== 'management').length,
+    connectionReportingCurrent,
+    connectionState: phones.some(phone => phone.connected) ? 'connected' : connectionReportingCurrent ? 'disconnected' : 'unconfirmed',
+    lastConnection: null,
+    metadataPhones: phones.filter(phone => phone.metadata).length,
+    activeTasks: tasks.length, accounts, taskAccounts, associatedAccounts: [], debugEnabled,
+    fileReceiverOnline: online && room.uploadHost?.readyState === 1,
+    lanCandidates: online ? (room.lanCandidates || []).map(item => ({ address: item.address,
+      networkType: item.networkType, networkName: item.networkName, interfaceName: item.interfaceName })) : [],
+    officialComputer: room.officialComputer ? { environmentId: room.officialComputer.environmentId,
+      name: room.officialComputer.name, hostname: room.officialComputer.hostname,
+      updatedAt: room.officialComputer.updatedAt } : null,
+    tasks: tasks.map(([key, task]) => ({ key, clientId: task.clientId, userId: task.userId,
+      account: taskAccounts.find(account => account.id === task.userId) || null })), phones,
+  };
+}
+
+// Previous connection mode is durable history; it never establishes current presence.
+export async function resolveWorkstationConnections(workstations, events) {
+  const paired = new Map(workstations.map(item => [item.id, new Map(item.phones.map(phone => [phone.id, phone]))]));
+  for (const record of await events.latest(workstations.map(item => item.id))) {
+    const phone = paired.get(record.computerId)?.get(record.clientId);
+    if (phone) phone.lastConnection = { mode: record.mode, at: record.at };
+  }
+  for (const item of workstations) {
+    const last = item.phones.filter(phone => phone.lastConnection)
+      .sort((a, b) => b.lastConnection.at.localeCompare(a.lastConnection.at) || a.id.localeCompare(b.id))[0];
+    item.lastConnection = last ? { ...last.lastConnection, clientId: last.id } : null;
+  }
+  return workstations;
+}
+
+// Account association belongs to a workstation/mobile identity pair. A missing
+// signaling socket says nothing about whether that phone has a login session.
+// Read existing verified usage attribution without rewriting any history.
+export async function resolveWorkstationAccounts(workstations, pool) {
+  const paired = new Map(workstations.map(item => [item.id, new Map(item.phones.map(phone => [phone.id, phone]))]));
+  if (pool && workstations.length) {
+    const [rows] = await pool.execute(`SELECT computer_id,client_id,user_id,MAX(occurred_at) AS last_verified_at
+      FROM relay_usage_actions WHERE computer_id IN (${workstations.map(() => '?').join(',')})
+      GROUP BY computer_id,client_id,user_id`, workstations.map(item => item.id));
+    for (const row of rows) {
+      const phone = paired.get(row.computer_id)?.get(row.client_id);
+      if (phone) phone.associatedAccounts.push({ id: row.user_id, email: null,
+        lastVerifiedAt: row.last_verified_at.replace(' ', 'T') + 'Z' });
+    }
+  }
+  const references = workstations.flatMap(item => [...item.taskAccounts,
+    ...item.phones.flatMap(phone => [...phone.taskAccounts, ...phone.associatedAccounts])]);
+  const missing = [...new Set(references.filter(account => !account.email).map(account => account.id))];
+  if (pool && missing.length) {
+    const [rows] = await pool.execute(`SELECT i.user_id,i.normalized_value AS email FROM user_login_identities i
+      JOIN users u ON u.id=i.user_id AND u.status='active'
+      WHERE i.kind='email' AND i.user_id IN (${missing.map(() => '?').join(',')})`, missing);
+    const emails = new Map(rows.map(row => [row.user_id, row.email]));
+    for (const account of references) if (!account.email) account.email = emails.get(account.id) || null;
+  }
+  for (const item of workstations) {
+    for (const phone of item.phones) {
+      const known = new Map(phone.associatedAccounts.filter(account => account.email)
+        .sort((a, b) => b.lastVerifiedAt.localeCompare(a.lastVerifiedAt)).map(account => [account.id, account]));
+      for (const account of [...phone.taskAccounts, ...phone.accounts]) if (account.email) {
+        known.set(account.id, { ...account, lastVerifiedAt: known.get(account.id)?.lastVerifiedAt || null });
+      }
+      phone.associatedAccounts = [...known.values()];
+    }
+    const known = new Map();
+    for (const phone of item.phones) for (const account of phone.associatedAccounts) {
+      if (!known.has(account.id) || (account.lastVerifiedAt || '') > (known.get(account.id).lastVerifiedAt || '')) known.set(account.id, account);
+    }
+    item.associatedAccounts = [...known.values()];
+  }
+  return workstations;
+}
+
+export function workstationSummary(item) {
+  const { phones, tasks, lanCandidates, officialComputer, fileReceiverOnline, debugEnabled, ...summary } = item;
+  return { ...summary, routes: workstationRoutes(phones) };
+}
+
+function workstationRoutes(phones) {
+  return [...new Set(phones.flatMap(phone => [...(phone.chat ? [phone.chat.route] : []),
+    ...phone.reportedConnections.filter(item => item.mode === 'lan' || !phone.chat).map(item => item.mode)]))];
+}
+
+export function listWorkstations(rooms, { details = false } = {}) {
+  const items = [...rooms.values()].filter(room => room.status === 'active').map(room => workstationDetail(room))
+    .sort((a, b) => Number(b.online) - Number(a.online) || (b.onlineAt || '').localeCompare(a.onlineAt || '') ||
+      a.name.localeCompare(b.name, 'zh-CN') || a.id.localeCompare(b.id));
+  return details ? items : items.map(workstationSummary);
+}

package/dist/src/self-relay/connection-reporting.mjs

@@ -0,0 +1,38 @@
+import path from 'node:path';
+import { EventEmitter } from 'node:events';
+import { randomUUID } from 'node:crypto';
+
+const reporters = new Map();
+
+// Workstation observations only. The bounded in-memory outbox covers cloud
+// reconnects, not process exit; no polling or message payloads are involved.
+export function connectionReporting(stateRoot) {
+  let key = path.resolve(stateRoot);
+  if (process.platform === 'win32') key = key.toLowerCase();
+  if (reporters.has(key)) return reporters.get(key);
+  const active = new Map(), pending = new Map(), events = new EventEmitter();
+  function record(connection, state) {
+    const event = { ...connection, id: randomUUID(), state, at: new Date().toISOString() };
+    pending.set(event.id, event);
+    if (pending.size > 128) pending.delete(pending.keys().next().value);
+    events.emit('change', event);
+  }
+  const reporter = {
+    connected(connectionId, clientId, mode) {
+      if (active.has(connectionId)) return;
+      const connection = { connectionId, clientId, mode };
+      active.set(connectionId, connection); record(connection, 'connected');
+    },
+    disconnected(connectionId) {
+      const connection = active.get(connectionId);
+      if (!connection) return;
+      active.delete(connectionId); record(connection, 'disconnected');
+    },
+    snapshot: () => [...active.values()],
+    pending: () => [...pending.values()],
+    acknowledge: id => pending.delete(id),
+    watch(listener) { events.on('change', listener); return () => events.off('change', listener); },
+  };
+  reporters.set(key, reporter);
+  return reporter;
+}

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

@@ -244,6 +244,7 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
           resolve(message); return;
         }
         if (!registered) throw new Error('Relay not registered');
+        if (message.type === 'phone-connection-ack') { events.emit('phone-connection-ack', message.id); return; }
         if (['pair-code', 'revoked', 'status', 'invite-create', 'invite-list', 'invite-revoke', 'devices-list', 'device-revoke'].includes(message.type)) {
           if (operation && message.commandId === operation.id && message.type === operation.responseType) {
             clearTimeout(operation.timer); const pending = operation; operation = undefined;
@@ -257,7 +258,7 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
         if (message.type === 'attach') {
           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,
+          const current = { clientId: message.clientId, socket: undefined, ready: false, timer: undefined, p2pProbe: p2pProbe && message.p2pProbe === 1,
             bridgeOutbound: Promise.resolve(), healthRequests: new Set(), usageRequests: new Map(), detached: false, detachedTimer: undefined };
           locals.set(message.session, current);
           let connection;
@@ -292,7 +293,8 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
             send(socket, request);
           };
           current.timer = setTimeout(() => socket.terminate(), 5000);
-          socket.on('open', () => send(socket, { type: 'auth', token: connection.token }));
+          socket.on('open', () => send(socket, { type: 'auth', token: connection.token,
+            ...(message.chat === true ? { relayClientId: message.clientId } : {}) }));
           socket.on('error', error => events.emit('diagnostic', `Local desktop service: ${error.message}`));
           socket.on('close', () => {
             clearTimeout(current.detachedTimer);
@@ -391,7 +393,8 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
               },
               onData: file ? undefined : payload => current.forwardToBridge(payload),
               onFileChannel: file ? channel => attachRtcFile(channel, bridgeConnection?.() || { url: bridgeUrl, token: bridgeToken },
-                () => locals.get(message.session) === current && current.ready && current[idField] === probeId && remote.readyState === WebSocket.OPEN) : undefined,
+                () => locals.get(message.session) === current && current.ready && current[idField] === probeId && remote.readyState === WebSocket.OPEN,
+                current.clientId) : undefined,
               report: (state, diagnostic) => events.emit('p2p-probe', { state, diagnostic, purpose: file ? 'file' : 'chat' })
             })).catch(() => {
               events.emit('diagnostic', p2pWindowsRouteHelper ? 'Windows RTC 路由辅助不可用' : 'WebRTC probe initialization failed');
@@ -422,6 +425,8 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
   return { ready, events,
     assertConnected() { if (remote.readyState !== WebSocket.OPEN) throw lastClose || new Error('Relay disconnected during registration'); },
     reportDeviceConnection(info) { return send(remote, { ...info, type: 'device-connected' }); },
+    reportPhoneConnection(event) { return send(remote, { type: 'phone-connection', event }); },
+    reportPhoneConnections(active) { return send(remote, { type: 'phone-connections', active }); },
     command(type, details = {}) {
       if (operation) return Promise.reject(new Error('已有设备管理操作正在执行'));
       return new Promise((resolve, reject) => {

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

@@ -12,6 +12,7 @@ import { validProbeIceServers } from './p2p-probe.mjs';
 import { relayAddress, validSecret } from './wire.mjs';
 import { saveLanAuthorizations, onLanDeviceConnected, pendingLanConnections } from './lan-authorizations.mjs';
 import { lanNetworks } from '../platform/network-info.mjs';
+import { connectionReporting } from './connection-reporting.mjs';
 
 const officialConfig = { url: serviceEndpoints.relayUrl };
 
@@ -83,6 +84,12 @@ async function createRelayRuntime(stateRoot) {
   const stopWatchingDevices = onLanDeviceConnected(stateRoot, info => {
     if (online && !closing) connector.reportDeviceConnection(info);
   });
+  const phoneReporting = connectionReporting(stateRoot);
+  const stopWatchingPhones = phoneReporting.watch(event => {
+    if (!online || closing) return;
+    try { connector.reportPhoneConnection(event); }
+    catch (error) { audit('phone-report-unavailable', { message: error.message }); }
+  });
   async function currentLanCandidates() {
     try {
       const bridge = session(), port = bridge?.port || 45831;
@@ -108,6 +115,7 @@ async function createRelayRuntime(stateRoot) {
     if (closing) return;
     closing = true; online = false; attachedCount = 0; clearTimeout(retryTimer);
     stopWatchingDevices();
+    stopWatchingPhones();
     connector?.events.removeAllListeners(); connector?.close();
   }
   async function saveInvitation(message) {
@@ -143,6 +151,7 @@ async function createRelayRuntime(stateRoot) {
         p2pWindowsRouteHelper: config.p2pWindowsRouteHelper === true, p2pWindowsRouteHelperToken: config.p2pWindowsRouteHelperToken || '' });
       current.events.on('p2p-probe', result => audit('p2p-probe', result));
       current.events.on('diagnostic', message => audit('transport-error', { message }));
+      current.events.on('phone-connection-ack', id => phoneReporting.acknowledge(id));
       current.events.on('attached', () => { paired = true; attachedCount++; audit('phone-attached', { attachedCount }); });
       current.events.on('detached', () => { attachedCount = Math.max(0, attachedCount - 1); audit('phone-detached', { attachedCount }); });
       current.events.on('authorization-changed', update => {
@@ -170,6 +179,8 @@ async function createRelayRuntime(stateRoot) {
       online = true; attempts = 0; paired = registration.paired; clientCount = registration.clientCount || 0; lastError = '';
       saveLanAuthorizations(stateRoot, identity.id, registration.clients || [], registration.revision);
       for (const info of pendingLanConnections(stateRoot)) current.reportDeviceConnection(info);
+      for (const event of phoneReporting.pending()) current.reportPhoneConnection(event);
+      current.reportPhoneConnections(phoneReporting.snapshot());
       await saveInvitation(registration);
       if (!closing) audit('relay-connected', { paired });
     } catch (error) {

package/dist/src/self-relay/phone-connections.mjs

@@ -0,0 +1,55 @@
+import { validId } from './device-store.mjs';
+
+export function validPhoneConnection(value) {
+  return value && validId(value.connectionId) && validId(value.clientId) && ['lan', 'self-relay'].includes(value.mode);
+}
+
+export function phoneConnectionEvents(pool) {
+  const recent = new Map();
+  const lastConnections = new Map();
+  return {
+    async record(computerId, event) {
+      if (!validPhoneConnection(event) || !validId(event.id) ||
+          !['connected', 'disconnected'].includes(event.state) ||
+          typeof event.at !== 'string' || !/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/.test(event.at) ||
+          !Number.isFinite(Date.parse(event.at)) || new Date(event.at).toISOString() !== event.at) throw new Error('Invalid phone connection event');
+      const item = { id: event.id, connectionId: event.connectionId, clientId: event.clientId,
+        mode: event.mode, state: event.state, at: event.at, receivedAt: new Date().toISOString() };
+      if (pool) await pool.execute(`INSERT INTO workstation_phone_events
+        (event_id,computer_id,client_id,connection_id,mode,state,occurred_at,received_at) VALUES (?,?,?,?,?,?,?,?)
+        ON DUPLICATE KEY UPDATE event_id=event_id`,
+      [item.id, computerId, item.clientId, item.connectionId, item.mode, item.state,
+        item.at.slice(0, 23).replace('T', ' '), item.receivedAt.slice(0, 23).replace('T', ' ')]);
+      else {
+        const items = recent.get(computerId) || [];
+        if (!items.some(value => value.id === item.id)) items.push(item);
+        recent.set(computerId, items.slice(-20));
+        if (item.state === 'connected') {
+          const phones = lastConnections.get(computerId) || new Map();
+          if (!phones.has(item.clientId) || phones.get(item.clientId).at <= item.at) phones.set(item.clientId, item);
+          lastConnections.set(computerId, phones);
+        }
+      }
+    },
+    async latest(computerIds) {
+      if (!computerIds.length) return [];
+      if (!pool) return computerIds.flatMap(computerId => [...(lastConnections.get(computerId)?.values() || [])]
+        .map(item => ({ computerId, clientId: item.clientId, mode: item.mode, at: item.at })));
+      const [rows] = await pool.execute(`SELECT computer_id,client_id,mode,occurred_at FROM (
+        SELECT computer_id,client_id,mode,occurred_at,
+          ROW_NUMBER() OVER (PARTITION BY computer_id,client_id ORDER BY occurred_at DESC,sequence_id DESC) AS connection_rank
+        FROM workstation_phone_events WHERE state='connected' AND computer_id IN (${computerIds.map(() => '?').join(',')})
+      ) latest WHERE connection_rank=1`, computerIds);
+      return rows.map(row => ({ computerId: row.computer_id, clientId: row.client_id,
+        mode: row.mode, at: row.occurred_at.replace(' ', 'T') + 'Z' }));
+    },
+    async list(computerId) {
+      if (!pool) return [...(recent.get(computerId) || [])].reverse();
+      const [rows] = await pool.execute(`SELECT event_id,client_id,connection_id,mode,state,occurred_at,received_at
+        FROM workstation_phone_events WHERE computer_id=? ORDER BY sequence_id DESC LIMIT 20`, [computerId]);
+      return rows.map(row => ({ id: row.event_id, clientId: row.client_id, connectionId: row.connection_id,
+        mode: row.mode, state: row.state, at: row.occurred_at.replace(' ', 'T') + 'Z',
+        receivedAt: row.received_at.replace(' ', 'T') + 'Z' }));
+    },
+  };
+}

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

@@ -3,7 +3,7 @@ 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) {
+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(); });
@@ -19,13 +19,18 @@ export function attachRtcFile(channel, connection, authorized) {
         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.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) {
-              if (binary || JSON.parse(bytes.toString()).type !== 'ready') throw new Error('File authentication failed');
+              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());