@walkhi/code-relax 0.1.0-beta.16 → 0.1.0-beta.18

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

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

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

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

package/dist/src/server.mjs

@@ -283,7 +283,7 @@ async function handleRequest(request, response) {
       return;
     }
 
-    if (request.method === 'GET' && url.pathname === '/api/usage-events') {
+    if (request.method === 'GET' && url.pathname === '/api/usage-events') {
       const execution = sharedServer;
       response.startEvents();
       const emit = value => { if (!response.destroyed) response.event('usage', value); };
@@ -292,8 +292,45 @@ async function handleRequest(request, response) {
       execution.on('usage', emit); execution.on('usage-error', failed); execution.on('disconnected', disconnected);
       response.once('close', () => { execution.off('usage', emit); execution.off('usage-error', failed); execution.off('disconnected', disconnected); });
       try { emit(await execution.usage()); } catch (error) { failed(error); }
-      return;
-    }
+      return;
+    }
+
+    if (request.method === 'GET' && url.pathname === '/api/turn-events') {
+      response.startEvents();
+      const listener = ({ method, params }) => {
+        if (!['turn/started', 'turn/completed'].includes(method)) return;
+        const threadId = params?.threadId, turnId = params?.turn?.id;
+        if (typeof threadId === 'string' && typeof turnId === 'string' && !response.destroyed) {
+          response.event('turn', { method, threadId, turnId });
+        }
+      };
+      const disconnected = () => response.end();
+      sharedServer.on('notification', listener);
+      sharedServer.on('disconnected', disconnected);
+      response.once('close', () => {
+        sharedServer.off('notification', listener);
+        sharedServer.off('disconnected', disconnected);
+      });
+      return;
+    }
+
+    const activeTurnMatch = /^\/api\/threads\/([^/]+)\/active-turn$/.exec(url.pathname);
+    if (request.method === 'GET' && activeTurnMatch) {
+      const threadId = decodeURIComponent(activeTurnMatch[1]);
+      await sharedServer.connect();
+      const { thread } = await sharedServer.request('thread/read', { threadId, includeTurns: false });
+      const status = typeof thread.status === 'string' ? thread.status : thread.status?.type;
+      let turnId = null;
+      if (status === 'active') {
+        const page = await sharedServer.request('thread/turns/list', {
+          threadId, limit: 1, sortDirection: 'desc', itemsView: 'summary',
+        });
+        const latest = page.data?.[0];
+        if (latest?.status === 'inProgress') turnId = latest.id;
+      }
+      sendJson(response, 200, { turnId });
+      return;
+    }
 
     const createThreadMatch = /^\/api\/projects\/([^/]+)\/threads$/.exec(url.pathname);
     if (request.method === 'POST' && createThreadMatch) {
@@ -473,7 +510,8 @@ async function handleRequest(request, response) {
       await requireExecutionWritable(threadId);
       const body = await readJsonBody(request);
       if (body.hostId && body.hostId !== 'local') throw new RequestError(410, '此对话的连接方式已停用。', { code: 'unsupported_control' });
-      sendJson(response, 200, { success: true, data: await sharedServer.send(appServerTurnArguments(threadId, body)) });
+      const submitted = await sharedServer.send(appServerTurnArguments(threadId, body));
+      sendJson(response, 200, { success: true, data: submitted.result, usage: submitted.usage });
       return;
     }
 
@@ -505,7 +543,7 @@ void managedAppServer.start();
 executionHealth.start();
 runtimeDiscovery.start();
 server.on('error', error => {
-  console.error('Bridge 监听失败：', error.message);
+  console.error('桌面服务监听失败：', error.message);
   process.exit(1);
 });
 server.listen(options.port, options.lan ? '0.0.0.0' : '127.0.0.1', async () => {
@@ -528,10 +566,10 @@ server.listen(options.port, options.lan ? '0.0.0.0' : '127.0.0.1', async () => {
         pid: process.pid, controlPort: control.port });
     }
   } catch (error) {
-    console.error('Bridge 管理通道启动失败：', error.message);
+    console.error('桌面服务管理通道启动失败：', error.message);
     process.exit(1);
   }
-  console.log(`Code Relax Bridge 已启动：http://127.0.0.1:${options.port}/`);
+  console.log(`Code Relax 桌面服务已启动：http://127.0.0.1:${options.port}/`);
   if (options.lan) {
     console.log('LAN 模式使用鉴权 WebSocket，仅适合受信任局域网测试，不要暴露到公网。');
   }
@@ -711,12 +749,12 @@ function messagePayload(body) {
   return payload;
 }
 
-function appServerTurnArguments(threadId, body) {
+function appServerTurnArguments(threadId, body) {
   const payload = messagePayload(body);
   const input = [];
   if (payload.prompt) input.push({ type: 'text', text: payload.prompt });
   for (const image of payload.images) input.push(image.startsWith('data:') ? { type: 'image', url: image } : { type: 'localImage', path: image });
-  const value = { threadId, input };
+  const value = { threadId, input, ...appServerEvents.mobileTurnSource(body.clientUserMessageId) };
   if (typeof body.clientUserMessageId === 'string' && /^[a-f0-9]{32}$/.test(body.clientUserMessageId)) value.clientUserMessageId = body.clientUserMessageId;
   if (payload.model) value.model = payload.model;
   if (payload.thinking) value.effort = payload.thinking;

package/dist/src/service-control.mjs

@@ -29,7 +29,7 @@ export async function openControl({ instanceId, secret, shutdown, status = () =>
     }
     if (request.method === 'POST') response.once('finish', () => {
       Promise.resolve(shutdown()).catch(error => {
-        console.error('Bridge 关闭失败：', error.message);
+        console.error('桌面服务关闭失败：', error.message);
         process.exitCode = 1;
       });
     });
@@ -56,16 +56,16 @@ export function controlRequest(session, method = 'GET', action = '') {
       response.on('end', () => {
         try {
           if (response.statusCode === 409) throw new Error(JSON.parse(body).error);
-          if (response.statusCode !== 200) throw new Error('Bridge 管理通道身份验证失败。');
+          if (response.statusCode !== 200) throw new Error('桌面服务管理通道身份验证失败。');
           const identity = JSON.parse(body);
           if (identity.instanceId !== session.instanceId || identity.pid !== session.pid) {
-            throw new Error('Bridge 实例身份不匹配。');
+            throw new Error('桌面服务实例身份不匹配。');
           }
           resolve(identity);
         } catch (error) { reject(error); }
       });
     });
-    request.on('timeout', () => request.destroy(new Error('Bridge 管理通道响应超时。')));
+    request.on('timeout', () => request.destroy(new Error('桌面服务管理通道响应超时。')));
     request.on('error', reject);
     request.end();
   });

package/dist/src/service-doctor.mjs

@@ -20,7 +20,7 @@ export async function doctor({ paths, host, service, skillTarget, ensureAutostar
   });
   await check('bridge-runtime', async () => {
     await host.bridgeEnvironment();
-    add('bridge-runtime', 'ok', 'Bridge 启动环境已就绪；实际任务操作尚未验证。');
+    add('bridge-runtime', 'ok', '桌面服务启动环境已就绪；实际任务操作尚未验证。');
   });
   await check('network', async () => {
     const address = await host.lanAddress();
@@ -37,10 +37,10 @@ export async function doctor({ paths, host, service, skillTarget, ensureAutostar
       ? `本机服务正常：${state.mode}，端口 ${state.port}，运行版本：${state.version || '未知'}` : '服务未就绪；安装后执行 relax start。');
     if (state.running && installedVersion && state.version !== installedVersion) add('service-version', 'warning', state.version
       ? `已安装版本 ${installedVersion}，但当前运行版本为 ${state.version}；请重新执行安装或重启工作站服务。`
-      : `已安装版本 ${installedVersion}，但当前运行 Bridge 未报告版本，可能仍是旧进程；请重新执行安装或重启工作站服务。`);
+      : `已安装版本 ${installedVersion}，但当前运行的桌面服务未报告版本，可能仍是旧进程；请重新执行安装或重启桌面服务。`);
     if (state.running) add('managed-app-server', state.managedAppServer?.state === 'ready' ? 'ok' : 'error',
-      state.managedAppServer?.state === 'ready' ? '受管 app-server 已就绪。'
-        : state.managedAppServer?.error || '受管 app-server 尚未就绪。');
+      state.managedAppServer?.state === 'ready' ? 'Codex 内核已就绪。'
+        : state.managedAppServer?.error || 'Codex 内核尚未就绪。');
     if (state.managedAppServer?.updatePending) add('managed-app-server-update', 'warning',
       '已选择另一版本 CLI；当前 app-server 继续完成任务，下次内核启动时采用选定版本。');
     if (state.managedAppServer?.launcherRestartRequired) add('managed-app-server-launcher', 'warning',

package/dist/src/service-health.mjs

@@ -14,7 +14,7 @@ export function serviceHealth(session) {
       socket.terminate();
       if (error) reject(error); else resolve(value);
     };
-    const timer = setTimeout(() => finish(new Error('Bridge 健康检查超时。')), 6000);
+    const timer = setTimeout(() => finish(new Error('桌面服务健康检查超时。')), 6000);
     socket.on('open', () => socket.send(JSON.stringify({ type: 'auth', token })));
     socket.on('message', data => {
       try {
@@ -28,6 +28,6 @@ export function serviceHealth(session) {
     });
     socket.on('error', error => finish(error.code === 'ECONNREFUSED' ? null : error));
     socket.on('close', code => finish(new Error(code === 1008
-      ? 'Bridge 健康检查鉴权失败。' : 'Bridge 健康检查连接已断开。')));
+      ? '桌面服务健康检查鉴权失败。' : '桌面服务健康检查连接已断开。')));
   });
 }

package/dist/src/service-lifecycle.mjs

@@ -27,7 +27,7 @@ export function lifecycle({ stateRoot, host }) {
 
   async function alive(session) {
     if (!session?.controlPort || !session.instanceId || !session.controlSecret) {
-      if (await health(session)) throw new Error('当前为旧版 Bridge，请先使用旧版停止入口结束服务，再启动新版。');
+      if (await health(session)) throw new Error('当前为旧版桌面服务，请先使用旧版停止入口结束服务，再启动新版。');
       return false;
     }
     try { await controlRequest(session); return true; }
@@ -35,7 +35,7 @@ export function lifecycle({ stateRoot, host }) {
   }
   async function stop() {
     const session = readRecord(sessionPath);
-    if (!await alive(session)) return { stopped: true, message: 'Bridge 已停止。' };
+    if (!await alive(session)) return { stopped: true, message: '桌面服务已停止。' };
     await controlRequest(session, 'POST');
     const deadline = Date.now() + 10000;
     while (true) {
@@ -45,10 +45,10 @@ export function lifecycle({ stateRoot, host }) {
         // Verify refusal on the next connection; never resend the shutdown request.
         if (error.code !== 'ECONNRESET') throw error;
       }
-      if (Date.now() > deadline) throw new Error('Bridge 未在 10 秒内退出；未强杀进程。');
+      if (Date.now() > deadline) throw new Error('桌面服务未在 10 秒内退出；未强杀进程。');
       await delay(100);
     }
-    return { stopped: true, message: 'Bridge 已正常关闭。' };
+    return { stopped: true, message: '桌面服务已正常关闭。' };
   }
   async function status() {
     const session = readRecord(sessionPath);
@@ -78,7 +78,7 @@ export function lifecycle({ stateRoot, host }) {
   }
   async function restartManagedAppServer() {
     const session = readRecord(sessionPath);
-    if (!await alive(session)) throw new Error('Bridge 尚未运行，无法迁移受管 app-server。');
+    if (!await alive(session)) throw new Error('桌面服务尚未运行，无法迁移 Codex 内核。');
     return controlRequest(session, 'POST', 'restart-managed-app-server');
   }
   async function start() {
@@ -110,11 +110,11 @@ export function lifecycle({ stateRoot, host }) {
       const deadline = Date.now() + 10000;
       let ready;
       while (!(ready = readRecord(readyPath))) {
-        if (!processAlive(pid)) throw new Error('Bridge 启动失败，请查看 bridge.stderr.log。');
-        if (Date.now() > deadline) throw new Error('Bridge 未在 10 秒内就绪。');
+        if (!processAlive(pid)) throw new Error('桌面服务启动失败，请查看 bridge.stderr.log。');
+        if (Date.now() > deadline) throw new Error('桌面服务未在 10 秒内就绪。');
         await delay(100);
       }
-      if (ready.instanceId !== instanceId || ready.pid !== pid) throw new Error('Bridge 启动实例不匹配。');
+      if (ready.instanceId !== instanceId || ready.pid !== pid) throw new Error('桌面服务启动实例不匹配。');
       session = { ...ready, controlSecret, executablePath: executable, scriptPath, port: config.port,
         lan: true, appServer: false, accessUrl: `http://${address}:${config.port}/?token=${config.token}`,
         startedAt: new Date().toISOString() };

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

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

package/dist/src/shared-recovery.mjs

@@ -111,7 +111,7 @@ export async function runRecovery(stateRoot, operationId, dependencies = {}) {
     await waitFor(async () => {
       const health = await service.status();
       return health.running && health.mode === 'lan-shared' && health.execution?.ready === true;
-    }, 'Codex 内核未就绪；Bridge 和中继管理连接仍保留。');
+    }, 'Codex 内核未就绪；桌面服务和中继连接仍保留。');
     record = { ...record, status: 'completed', stage: 'ready', steps: record.steps.map(step => ({ ...step, status: 'completed' })),
       message: 'Codex Desktop 已接入 Codex 内核；移动端控制保持就绪，原任务未自动重发。' };
   } catch (error) { record = { ...record, status: 'failed', error: error.message,

package/package.json

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

package/tools/postinstall.mjs

@@ -59,9 +59,9 @@ export function formatSetupOutput(output, previous = {}) {
         ? `未重启（PID ${pid}，启动代次 ${migration.launcherRevision ?? '未知'} 已是最新）`
         : `已启动（PID ${pid}，启动代次 ${migration.launcherRevision ?? '未知'}）`;
     return `Code Relax ${result.version || '未知版本'} 安装成功。\n`
-      + `受管 app-server：${appServer}\n`
-      + `Bridge：${result.restarted ? '已恢复并健康' : '已启动并健康'}\n`
-      + `${result.desktopRestarted ? `Codex Desktop：已干净重启并重新接入（${result.desktopRestartReason === 'attach-managed-server' ? '接入受管内核' : 'app-server 迁移'}）\n` : ''}`
+      + `Codex 内核：${appServer}\n`
+      + `桌面服务：${result.restarted ? '已恢复并健康' : '已启动并健康'}\n`
+      + `${result.desktopRestarted ? `Codex Desktop：已干净重启并重新接入（${result.desktopRestartReason === 'attach-managed-server' ? '接入 Codex 内核' : '内核迁移'}）\n` : ''}`
       + `${result.desktopRestartRecommended ? 'Codex Desktop：建议完全退出后重新打开。\n' : ''}`;
   } catch { return output; }
 }