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

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

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

package/dist/src/server.mjs

@@ -9,6 +9,7 @@ import { fileURLToPath } from 'node:url';
 import vm from 'node:vm';
 import sharp from 'sharp';
 import { attachLanSocket } from './lan-socket-server.mjs';
+import { connectionReporting } from './self-relay/connection-reporting.mjs';
 import fileMentions from '../shared/file-mentions.cjs';
 import fileCitations from '../shared/file-citations.cjs';
 import { validateInlineImage } from './message-images.mjs';
@@ -393,7 +394,10 @@ async function handleRequest(request, response) {
         return;
       }
       const localPath = url.searchParams.get('path') || '';
-      if (localFileRequest && !/^[a-z]:[\\/]/i.test(localPath)) throw new RequestError(400, '无效的工作站文件路径。');
+      if (localFileRequest && (/[\x00-\x1f]/.test(localPath)
+        || !(process.platform === 'win32' ? /^[a-z]:[\\/]/i : /^\/(?!\/)/).test(localPath))) {
+        throw new RequestError(400, '无效的工作站文件路径。');
+      }
       const file = localFileRequest ? describeLocalFile(localPath) : fileCache.get(fileMatch[1]);
       if (!file) throw new RequestError(404, '电脑上的文件不存在或无法读取。');
       if (file.externalIdentity) await dotsImages.authorization(file.externalIdentity);
@@ -515,11 +519,16 @@ async function handleRequest(request, response) {
 
     if (request.method === 'GET' && url.pathname === '/api/file-local-copy') {
       const value = url.searchParams.get('source') || '';
-      const id = /^([a-f0-9]{64})(?:\?recovery=[A-Za-z0-9_-]{1,4096})?$/.exec(value)?.[1];
-      if (id && (fileCache.has(id) || attachmentCache.has(id) && !attachmentCache.get(id).dotsFile)) {
+      const match = /^([a-f0-9]{64})(?:\?recovery=([A-Za-z0-9_-]{1,4096}))?$/.exec(value);
+      if (!match) throw new RequestError(400, '无效的文件标识。');
+      const asset = attachmentCache.get(match[1])
+        || dotsImages.restore(match[1], match[2] || url.searchParams.get('recovery') || '');
+      // A missing process cache does not make a local image an external file.
+      // The actual image endpoint owns recovery and download authorization.
+      if (!asset?.dotsFile) {
         sendJson(response, 200, { external: false, localCopy: null }); return;
       }
-      const asset = await externalDownloadAsset(value, url.searchParams.get('recovery'));
+      await dotsImages.authorization(asset.identity);
       const copy = await workstationDownloads.copy(asset.id);
       sendJson(response, 200, { external: true, localCopy: copy ? workstationCopyReference(copy, asset) : null,
         cachedContent: asset.buffer ? { remotePath: asset.id, name: asset.name, size: asset.buffer.length, mimeType: asset.mimeType } : null });
@@ -760,7 +769,9 @@ async function handleRequest(request, response) {
           }
           const { input } = appServerTurnArguments('', body);
           messageSubmissionStarted = true;
-          const created = await appServerEvents.createThread(rpc, target, input, body, undefined, bindCreation);
+          const createRpc = (method, params) => method === 'thread/start'
+            ? execution.startThread(params) : rpc(method, params);
+          const created = await appServerEvents.createThread(createRpc, target, input, body, undefined, bindCreation);
           const prompt = input.filter(part => part.type === 'text').map(part => part.text).join('\n');
           void generateAndSetThreadTitle({
             request: rpc,
@@ -1022,6 +1033,8 @@ const lanSocket = attachLanSocket(server, { token: options.token, dispatch: hand
   uploadsRoot,
   authorizeDevice: (clientId, credential) => authorizeLanDevice(stateRoot, clientId, credential),
   onDeviceAuthorizationsChanged: listener => onLanAuthorizationsChanged(stateRoot, listener),
+  onPhoneConnected: (...args) => connectionReporting(stateRoot).connected(...args),
+  onPhoneDisconnected: id => connectionReporting(stateRoot).disconnected(id),
   onDeviceConnected: (clientId, info) => {
     try { recordLanConnection(stateRoot, clientId, info); }
     catch (error) { console.error('记录局域网设备连接失败：', error.message); }

package/dist/src/service-update.mjs

@@ -5,6 +5,7 @@ import { startBackground } from './background-process.mjs';
 import { readRecord, writeRecord } from './service-lifecycle.mjs';
 import { runtimePaths } from './platform/runtime-paths.mjs';
 import { desktopHost } from './platform/desktop-host.mjs';
+import releaseVersion from '../shared/release-version.cjs';
 
 const versionPattern = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
 const statusPath = root => path.join(root, 'service-update.json');
@@ -27,8 +28,10 @@ export async function checkServiceUpdate(root) {
   const result = await fetch('https://registry.npmjs.org/@walkhi%2fcode-relax/latest', { signal: AbortSignal.timeout(12000) });
   if (!result.ok) throw new Error(`查询桌面服务版本失败：HTTP ${result.status}`);
   const latest = await result.json();
-  if (!versionPattern.test(latest.version || '')) throw new Error('npm 返回的版本号无效');
-  return { ...serviceUpdateStatus(root), latestVersion: latest.version };
+  if (!versionPattern.test(latest.version || '') || releaseVersion.compare(latest.version, latest.version) !== 0) throw new Error('npm 返回的版本号无效');
+  const status = serviceUpdateStatus(root);
+  return { ...status, latestVersion: latest.version,
+    updateAvailable: releaseVersion.compare(latest.version, status.currentVersion) > 0 };
 }
 let scheduling = false;
 export async function requestServiceUpdate(root, body) {
@@ -50,7 +53,7 @@ export async function requestServiceUpdate(root, body) {
     const latest = await checkServiceUpdate(root);
     if (!latest.supported) throw new Error('当前安装缺少 npm 路径，请先安装支持手机更新的过渡版。');
     if (latest.latestVersion !== body.targetVersion) throw new Error('最新版本已变化，请重新检查后确认。');
-    if (latest.currentVersion === body.targetVersion) throw new Error('桌面服务已是此版本。');
+    if (!latest.updateAvailable) throw new Error('没有高于当前安装版本的桌面服务更新。');
     const installed = installation();
     const directory = path.join(root, 'service-updates', body.operationId);
     fs.mkdirSync(directory, { recursive: true, mode: 0o700 });

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

@@ -173,6 +173,23 @@ export class SharedAppServer extends EventEmitter {
     return events.readProjects((method, params) => this.request(method, params));
   }
 
+  startThread(target) {
+    return this.request('thread/start', target, result => {
+      // thread/start already subscribes this connection. Retain its authoritative
+      // empty snapshot before turn/start can emit events; immediately resuming
+      // would unnecessarily read history that may not have been persisted yet.
+      const thread = result.thread;
+      const record = { thread: { ...thread, turns: (thread.turns || []).map(turn => events.compactTurn(turn)) },
+        nextCursor: null, sequence: 0, recoverAfter: 0, changes: new Map(), changeBytes: 0,
+        tokens: new Map([[randomUUID(), { sequence: 0, expires: Date.now() + syncTokenTtlMs }]]) };
+      this.threads.set(thread.id, record);
+      this.contexts.set(thread.id, { model: result.model, thinking: result.reasoningEffort,
+        serviceTier: result.serviceTier ?? null, cwd: result.cwd, ...events.permissionState(result) });
+      this.scheduleCleanup(thread.id, this.slot(thread.id));
+      return result;
+    });
+  }
+
   async send(args, { assertCurrent = () => {} } = {}) {
     let submitted = false;
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walkhi/code-relax",
-  "version": "0.1.0-beta.51",
+  "version": "0.1.0-beta.59",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",
@@ -41,8 +41,8 @@
     "tag": "beta"
   },
   "optionalDependencies": {
-    "@walkhi/code-relax-native-win32-x64": "0.1.0-beta.51",
-    "@walkhi/code-relax-native-darwin-arm64": "0.1.0-beta.51",
-    "@walkhi/code-relax-native-darwin-x64": "0.1.0-beta.51"
+    "@walkhi/code-relax-native-win32-x64": "0.1.0-beta.59",
+    "@walkhi/code-relax-native-darwin-arm64": "0.1.0-beta.59",
+    "@walkhi/code-relax-native-darwin-x64": "0.1.0-beta.59"
   }
 }