@walkhi/code-relax 0.1.0-beta.10 → 0.1.0-beta.101

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,145 @@
+// 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 controls = [...room.connections.values()].filter(entry => entry.control && entry.clientId === client.id && open(entry))
+      .map(entry => ({ purpose: 'control', ...socket(entry.ws) }));
+    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, ...controls].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/android-releases.mjs

@@ -0,0 +1,61 @@
+import fs from 'node:fs';
+
+const prefix = '/code-relax/android/';
+const webOrigin = 'https://www.coderelax.cn';
+
+export function readAndroidCatalog(file) {
+  const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (!Array.isArray(data.releases) || !data.releases.length) throw new Error('No Android releases');
+  const versions = new Set();
+  for (const item of data.releases) {
+    if (!Number.isSafeInteger(item.versionCode) || item.versionCode < 1 || item.versionCode > 2100000000
+      || versions.has(item.versionCode) || typeof item.versionName !== 'string' || !/^\d+\.\d+\.\d+\.\d+$/.test(item.versionName)
+      || !item.versionName.endsWith('.' + item.versionCode)
+      || !Number.isSafeInteger(item.size) || item.size <= 0 || !/^[a-f0-9]{64}$/.test(item.sha256)
+      || typeof item.objectKey !== 'string' || !/^code-relax\/android\/\d+\/[A-Za-z0-9._-]+\.apk$/.test(item.objectKey)
+      || typeof item.notes !== 'string' || item.notes.length > 10000) throw new Error('Invalid Android release catalog');
+    versions.add(item.versionCode);
+  }
+  if (!versions.has(data.latestVersionCode)) throw new Error('Latest Android release is missing');
+  return data;
+}
+
+export function createAndroidReleaseHandler({ catalogFile, signDownload, log = () => {} }) {
+  return async function handle(request, response, target) {
+    if (!target.pathname.startsWith(prefix)) return false;
+    const headers = { 'Cache-Control': 'no-store', 'Content-Type': 'application/json; charset=utf-8',
+      'X-Content-Type-Options': 'nosniff', 'Referrer-Policy': 'no-referrer',
+      'Access-Control-Allow-Origin': webOrigin, Vary: 'Origin' };
+    const reply = (code, data) => { response.writeHead(code, headers); response.end(JSON.stringify(data)); };
+    if (request.method !== 'GET') { reply(405, { error: 'Method not allowed' }); return true; }
+    if (![prefix + 'latest.json', prefix + 'download'].includes(target.pathname)) {
+      reply(404, { error: 'Not found' }); return true;
+    }
+    try {
+      if (!catalogFile || !signDownload) { reply(503, { error: 'Android release is not available' }); return true; }
+      const catalog = readAndroidCatalog(catalogFile);
+      const requested = target.searchParams.get('versionCode');
+      if (requested !== null && !/^[1-9]\d{0,9}$/.test(requested)) { reply(400, { error: 'Invalid version' }); return true; }
+      const code = target.pathname.endsWith('/latest.json') || requested === null ? catalog.latestVersionCode : Number(requested);
+      const release = catalog.releases.find(item => item.versionCode === code);
+      if (!release) { reply(404, { error: 'Release unavailable; check for updates again' }); return true; }
+      const { versionCode, versionName, size, sha256, notes } = release;
+      if (target.pathname.endsWith('/latest.json')) {
+        reply(200, { versionCode, versionName, size, sha256, notes }); return true;
+      }
+      // Sign only an explicitly published object, never a caller-supplied key or URL.
+      const ticket = await signDownload(release);
+      if (!ticket || new URL(ticket.url).protocol !== 'https:' || !Number.isSafeInteger(ticket.expiresAt) || ticket.expiresAt <= Date.now()) {
+        throw new Error('Invalid download ticket');
+      }
+      if (target.searchParams.get('redirect') === '1') {
+        response.writeHead(302, { ...headers, Location: ticket.url }); response.end();
+      } else reply(200, { versionCode, url: ticket.url, expiresAt: ticket.expiresAt });
+    } catch (error) {
+      // Provider errors may contain signed URLs or credentials. Never return or log them.
+      log({ event: 'android-release-error', type: error?.code === 'ENOENT' ? 'not-published' : 'configuration-or-storage' });
+      reply(503, { error: 'Android release is temporarily unavailable' });
+    }
+    return true;
+  };
+}

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

@@ -1,26 +1,26 @@
-import { EventEmitter } from 'node:events';
-import WebSocket from 'ws';
-import { decode, relayAddress, send } from './wire.mjs';
-
-// Headless mobile-side adapter for the local validation. No OpenAI credentials.
-export function connectRelayClient({ relayUrl, room, code, credential, clientId, observe = false }) {
-  relayAddress(relayUrl);
-  const events = new EventEmitter(), pending = new Map();
+import { EventEmitter } from 'node:events';
+import WebSocket from 'ws';
+import { decode, relayAddress, send } from './wire.mjs';
+
+// Headless mobile-side adapter for the local validation. No OpenAI credentials.
+export function connectRelayClient({ relayUrl, room, code, credential, clientId, accountToken, observe = false }) {
+  relayAddress(relayUrl);
+  const events = new EventEmitter(), pending = new Map();
   const socket = new WebSocket(relayUrl, { maxPayload: 64 * 1024 * 1024, perMessageDeflate: true });
   let serial = 0, connected = false, pairedCredential = credential, pairedClientId = clientId;
-  const ready = new Promise((resolve, reject) => {
-    const timer = setTimeout(() => { reject(new Error('Relay connection timeout')); socket.terminate(); }, 7000);
-    socket.on('open', () => send(socket, observe ? { type: 'observe', room, credential, clientId }
-      : code ? { type: 'pair', room, code, credential, clientId } : { type: 'resume', room, credential, clientId }));
-    socket.on('error', error => { reject(error); events.emit('diagnostic', error.message); });
-    socket.on('close', () => {
-      clearTimeout(timer); connected = false; reject(new Error('Relay connection closed'));
-      for (const request of pending.values()) { clearTimeout(request.timer); request.reject(new Error('连接断开，操作结果未确认，不自动重发')); }
-      pending.clear(); events.emit('disconnected');
-    });
-    socket.on('message', (bytes, binary) => {
-      try {
-        const message = decode(bytes, binary);
+  const ready = new Promise((resolve, reject) => {
+    const timer = setTimeout(() => { reject(new Error('Relay connection timeout')); socket.terminate(); }, 7000);
+    socket.on('open', () => send(socket, observe ? { type: 'observe', room, credential, clientId, accountToken }
+      : code ? { type: 'pair', room, code, credential, clientId, accountToken } : { type: 'resume', room, credential, clientId, accountToken }));
+    socket.on('error', error => { reject(error); events.emit('diagnostic', error.message); });
+    socket.on('close', () => {
+      clearTimeout(timer); connected = false; reject(new Error('Relay connection closed'));
+      for (const request of pending.values()) { clearTimeout(request.timer); request.reject(new Error('连接断开，操作结果未确认，不自动重发')); }
+      pending.clear(); events.emit('disconnected');
+    });
+    socket.on('message', (bytes, binary) => {
+      try {
+        const message = decode(bytes, binary);
         if (message.type === 'paired') { if (message.credential) pairedCredential = message.credential; if (message.clientId) pairedClientId = message.clientId; }
         else if (message.type === 'observing') { clearTimeout(timer); connected = true; events.emit('observing', message); resolve({ room, credential: pairedCredential, clientId: pairedClientId }); }
         else if (message.type === 'computer-info') events.emit('computer-info', { hostName: message.hostName });
@@ -29,33 +29,33 @@ export function connectRelayClient({ relayUrl, room, code, credential, clientId,
         else if (message.type === 'official-computer-saved') events.emit('official-computer-saved', message.computer);
         else if (message.type === 'announcement') events.emit('announcement', message.announcement);
         else if (message.type === 'ready') { clearTimeout(timer); connected = true; resolve({ room, credential: pairedCredential, clientId: pairedClientId }); }
-        else if (message.type === 'data') {
-          const body = decode(message.payload, false), request = pending.get(body.id);
-          if (body.type === 'response' && request) { clearTimeout(request.timer); pending.delete(body.id); request.resolve(body); }
-          else events.emit('message', body);
-        } else throw new Error('Invalid relay message');
-      } catch (error) { reject(error); events.emit('diagnostic', error.message); socket.close(1008, 'Invalid response'); }
-    });
-  });
-  return {
-    ready, events,
-    request(path, { method = 'GET', body, timeoutMs = 5000 } = {}) {
-      if (!connected) return Promise.reject(new Error('Relay not ready'));
-      const id = ++serial;
-      return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => { pending.delete(id); reject(new Error('请求超时，结果未确认，不自动重发')); }, timeoutMs);
-        pending.set(id, { resolve, reject, timer });
-        if (!send(socket, { type: 'data', payload: JSON.stringify({ type: 'request', id, path, method, ...(body ? { body } : {}) }) })) {
-          clearTimeout(timer); pending.delete(id); reject(new Error('Relay not connected'));
-        }
-      });
-    },
+        else if (message.type === 'data') {
+          const body = decode(message.payload, false), request = pending.get(body.id);
+          if (body.type === 'response' && request) { clearTimeout(request.timer); pending.delete(body.id); request.resolve(body); }
+          else events.emit('message', body);
+        } else throw new Error('Invalid relay message');
+      } catch (error) { reject(error); events.emit('diagnostic', error.message); socket.close(1008, 'Invalid response'); }
+    });
+  });
+  return {
+    ready, events,
+    request(path, { method = 'GET', body, timeoutMs = 5000 } = {}) {
+      if (!connected) return Promise.reject(new Error('Relay not ready'));
+      const id = ++serial;
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => { pending.delete(id); reject(new Error('请求超时，结果未确认，不自动重发')); }, timeoutMs);
+        pending.set(id, { resolve, reject, timer });
+        if (!send(socket, { type: 'data', payload: JSON.stringify({ type: 'request', id, path, method, ...(body ? { body } : {}) }) })) {
+          clearTimeout(timer); pending.delete(id); reject(new Error('Relay not connected'));
+        }
+      });
+    },
     send(message) { if (!connected) throw new Error('Relay not ready'); return send(socket, { type: 'data', payload: JSON.stringify(message) }); },
     routeDirect() { if (!connected) throw new Error('Relay not ready'); return send(socket, { type: 'p2p-route', direct: 1 }); },
     recordOfficialComputer(computer) {
       if (!connected || !observe) throw new Error('Metadata channel not ready');
       return send(socket, { type: 'official-computer', ...computer });
     },
-    close() { socket.terminate(); },
-  };
-}
+    close() { socket.terminate(); },
+  };
+}

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