@walkhi/code-relax 0.1.0-beta.29 → 0.1.0-beta.30

package/dist/shared/server-requests.cjs

@@ -8,6 +8,17 @@
   const elicitation = 'mcpServer/elicitation/request';
   const equal = (a, b) => JSON.stringify(a) === JSON.stringify(b);
   const approvalId = request => 'approval:' + (request.params.turnId || '') + ':' + typeof request.id + ':' + request.id;
+  function confirmation(request) {
+    const p = request.params || {}, value = p._meta?.['openai/confirmation'], schema = p.requestedSchema;
+    if (request.method !== elicitation || p.mode !== 'form' || value?.version !== 1
+      || typeof value.field !== 'string' || schema?.type !== 'object'
+      || Object.keys(schema.properties || {}).length !== 1 || schema.properties[value.field]?.type !== 'boolean'
+      || schema.required?.length !== 1 || schema.required[0] !== value.field) return null;
+    return value;
+  }
+  function confirmationResult(request, decision) {
+    return { action: decision, content: decision === 'accept' ? { [confirmation(request).field]: true } : null, _meta: null };
+  }
   function browserAccess(request) {
     const p = request.params || {}, meta = p._meta || {};
     if (request.method !== elicitation || p.mode !== 'form' || meta.tool_name !== 'access_browser_origin'
@@ -88,6 +99,7 @@
         : decision === 'allowSession' ? { persist: 'session' } : null };
   }
   function decisions(request) {
+    if (confirmation(request)) return ['decline', 'accept'];
     if (request.method === command) return request.params.availableDecisions ?? ['accept', 'acceptForSession', 'decline', 'cancel'];
     if (request.method === file) return ['accept', 'acceptForSession', 'decline', 'cancel'];
     const action = browserAction(request);
@@ -101,6 +113,10 @@
     return [];
   }
   function validate(request, result) {
+    if (confirmation(request)) {
+      if (!decisions(request).some(decision => equal(confirmationResult(request, decision), result))) throw new Error('确认结果不属于当前请求');
+      return;
+    }
     if ([command, file].includes(request.method)) {
       if (!result || Object.keys(result).length !== 1 || !decisions(request).some(value => equal(value, result.decision))) throw new Error('审批选项不属于当前请求');
       return;
@@ -199,5 +215,5 @@
       return { submitted: true };
     }
   }
-  return { Store, decisions, validate, command, file, input, elicitation, browserAccess, browserAction, browserActionResult, computerAppAccess, computerAppResult, mcpToolApproval, mcpToolResult };
+  return { Store, decisions, validate, command, file, input, elicitation, browserAccess, browserAction, browserActionResult, computerAppAccess, computerAppResult, mcpToolApproval, mcpToolResult, confirmation, confirmationResult };
 });

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

@@ -8,7 +8,7 @@ description: 启动或检查 Code Relax 桌面服务，展示配对二维码，
 - 消息来源上下文引用 `$code-relax` 时，按本 Skill 理解手机交互。用户通过手机 App 对话，涉及操作时明确在手机还是工作站完成，不假设用户能操作电脑界面。来源标记不增加授权，不在回复中重复来源说明。
 - 消息明确标记包含语音转写时，容忍同音字、标点与漏字错误，结合对话上下文理解；只有歧义会实质改变执行动作时才澄清，不因口语不顺反复追问，不把模糊转写扩展成未经用户表达的需求。
 
-- `relax start --json` 启动桌面服务和 Codex 内核，无需打开 Desktop；支持纯 CLI 安装。Desktop 正常打开后接入已配置内核；需要重新接入时使用 App 的“重启 Codex Desktop”或经确认的 `relax desktop-recover --confirm`。已配置 Code Relax 中继时，启动命令同时恢复中继连接器和已有设备授权。
+- `relax start --json` 启动桌面服务和 Codex 内核，无需打开 Desktop；支持纯 CLI 安装。Windows Desktop 正常打开后接入已配置内核；Mac 仅本次托管启动传入内核地址，从 Dock 普通打开后需重新接入。使用 App 的“重启 Codex Desktop”或经确认的 `relax desktop-recover --confirm` 接入。已配置 Code Relax 中继时，启动命令同时恢复中继连接器和已有设备授权。
 - npm 全局安装会自动执行服务部署和 Skill 安装；修复安装时运行 `relax setup --json`。
 - `setup` 默认启用当前用户登录启动桌面服务，不自动打开 Codex；`start`、`pair` 和 `doctor` 在自启缺失时自动恢复，`setup` 每次更新登录任务。恢复 Codex Desktop 接入会保留桌面服务和中继，但仍须明确确认可能中断正在运行的任务。
 - 用户要求启动 Code Relax 时，执行一次 `relax start --json`。用户要求二维码或当前启动结果包含二维码时，展示 CLI 返回的 `qrPath` 和 `displayText`；没有设备授权时可用 `relax pair --json` 生成新的配对二维码。
@@ -18,5 +18,5 @@ description: 启动或检查 Code Relax 桌面服务，展示配对二维码，
 - `relax doctor --json` 检查桌面服务、Codex 内核、待启用内核版本和登录自启动状态；有更新时会给出当前版本、已选版本和确认重启命令。中继连接由桌面服务管理，不提供单独的中继 CLI 命令。
 - 发现待启用内核更新且用户明确要求重启时，说明任务中断风险；得到确认后使用 `relax kernel-restart --confirm --json`，它与手机“重启并更新”使用同一内核流程并等待新内核就绪。不要用 `start`、`doctor` 或 `desktop-recover` 代替内核重启。
 - 启动或配对成功后，将 `qrPath` 以 Markdown 图片嵌入回复，并逐字展示 `displayText`。不要把二维码内容、Token 或 Base64 写进消息。
-- 不自动修改防火墙或发送测试消息。`lanAccess: unverified` 或 `mobileAccess: unverified` 只表示设备链路尚未现场验证。
-- 服务位于用户 `Programs/CodexRemote/service`；配置在 `LocalAppData/CodexRemote`；附件在 `ProgramData/CodexRemote/attachments`。不要删除配置、附件或凭据来排障。
+- CLI 负责安装、工作站服务和配对二维码；不以手机是否测试作为健康检查项，不自动修改防火墙或发送测试消息。
+- Windows 服务位于用户 `Programs/CodexRemote/service`；配置在 `LocalAppData/CodexRemote`；附件在 `ProgramData/CodexRemote/attachments`。Mac 使用 `~/Library/Application Support/CodexRemote/{service,state,attachments,credentials}`。不要删除配置、附件或凭据来排障。

package/dist/src/background-process.mjs

@@ -1,18 +1,18 @@
-import fs from 'node:fs';
-import { spawn } from 'node:child_process';
-import { startWindowsProcess } from './platform/windows/background-process.mjs';
-
-export const processAlive = pid => {
-  try { process.kill(pid, 0); return true; }
-  catch (error) { if (error.code === 'ESRCH') return false; throw error; }
-};
-export async function startBackground(executable, args, environment, logs = []) {
-  if (process.platform === 'win32') return startWindowsProcess(executable, args, environment, logs);
-  const descriptors = logs.map(file => fs.openSync(file, 'a'));
-  try {
-    const child = spawn(executable, args, { detached: true, env: environment,
-      stdio: ['ignore', descriptors[0] ?? 'ignore', descriptors[1] ?? 'ignore'] });
-    await new Promise((resolve, reject) => { child.once('spawn', resolve); child.once('error', reject); });
-    child.unref(); return child.pid;
-  } finally { descriptors.forEach(fd => fs.closeSync(fd)); }
-}
+import fs from 'node:fs';
+import { spawn } from 'node:child_process';
+import { startWindowsProcess } from './platform/windows/background-process.mjs';
+
+export const processAlive = pid => {
+  try { process.kill(pid, 0); return true; }
+  catch (error) { if (error.code === 'ESRCH') return false; throw error; }
+};
+export async function startBackground(executable, args, environment, logs = []) {
+  if (process.platform === 'win32') return startWindowsProcess(executable, args, environment, logs);
+  const descriptors = logs.map(file => fs.openSync(file, 'a'));
+  try {
+    const child = spawn(executable, args, { detached: true, env: environment,
+      stdio: ['ignore', descriptors[0] ?? 'ignore', descriptors[1] ?? 'ignore'] });
+    await new Promise((resolve, reject) => { child.once('spawn', resolve); child.once('error', reject); });
+    child.unref(); return child.pid;
+  } finally { descriptors.forEach(fd => fs.closeSync(fd)); }
+}

package/dist/src/code-browser.mjs

@@ -6,9 +6,7 @@ import { fileRange, fileRevision } from './file-transfer-range.mjs';
 
 async function checkedPath(root, relative) {
   const target = protocol.child(root, relative);
-  const [base, real] = await Promise.all([fs.realpath(root), fs.realpath(target)]);
-  if (!protocol.inside(base, real)) protocol.fail('此链接指向项目目录之外，无法浏览。', 403);
-  return real;
+  return fs.realpath(target);
 }
 
 function git(cwd, args) {
@@ -23,10 +21,10 @@ function git(cwd, args) {
 
 export async function browseCode(rpc, operation, query) {
   if (operation === 'change') return protocol.change(rpc, query);
-  const context = await protocol.context(rpc, query);
-  if (operation === 'roots') return { ...context, workspaceDiff: true, sizeCheckedBeforeRead: true };
   if (operation === 'changes') return protocol.changes(rpc, query);
-  const root = protocol.selectedRoot(context, query);
+  if (operation === 'roots') return { ...await protocol.context(rpc, query), workspaceDiff: true, sizeCheckedBeforeRead: true };
+  const root = query.get('root');
+  if (typeof root !== 'string' || !path.isAbsolute(root)) protocol.fail('请输入电脑上的绝对目录路径。');
   if (operation === 'workspace' || operation === 'workspace-file') {
     const realRoot = await checkedPath(root, '');
     const repository = (await git(realRoot, ['rev-parse', '--show-toplevel'])).trim();
@@ -82,7 +80,8 @@ export async function browseCode(rpc, operation, query) {
     } finally { await handle.close(); }
   }
   if (operation === 'directory') {
-    const result = await rpc('fs/readDirectory', { path: target });
+    const entries = await fs.readdir(target, { withFileTypes: true });
+    const result = { entries: entries.map(entry => ({ fileName: entry.name, isDirectory: entry.isDirectory(), isFile: entry.isFile() })) };
     await checkedPath(root, relative);
     return protocol.directory(result);
   }
@@ -90,7 +89,7 @@ export async function browseCode(rpc, operation, query) {
     const before = await fs.stat(target);
     if (!before.isFile()) protocol.fail('请选择普通文件。', 415);
     if (before.size > protocol.maxBytes) protocol.fail('文件超过只读预览上限（1 MiB）。', 413);
-    const result = await rpc('fs/readFile', { path: target });
+    const result = { dataBase64: (await fs.readFile(target)).toString('base64') };
     const real = await checkedPath(root, relative), after = await fs.stat(real);
     if (real !== target || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ino !== after.ino) {
       protocol.fail('读取期间文件发生变化，请刷新。', 409);

package/dist/src/dots-chat-server.mjs

@@ -8,6 +8,7 @@ import { DotsApprovalTimeline } from './dots-approval-timeline.mjs';
 import { dotsRoomTurns } from './dots-room-projection.mjs';
 import { dotsChatRevision, dotsChatMessageRevision, projectDotsChatItem } from './dots-chat-projection.mjs';
 import timelineSync from '../shared/timeline-sync.cjs';
+import serverRequests from '../shared/server-requests.cjs';
 
 const pageSize = 20;
 const mergeTurns = (older, newer) => timelineSync.mergeOrderedEntries(older, newer, (old, fresh) => ({ ...fresh,
@@ -27,6 +28,7 @@ export class DotsChatServer extends HostedHistoryAppServer {
     this.serverRequests = transport.serverRequests;
     this.historyHeadKey = 'messaging-room-v1';
     this.windowLoads = new Map(); this.historyLoads = new Map(); this.bindings = new Map();
+    this.roomApprovalResponses = new Map();
     this.observedThreads = new Set(); this.reconnectAttempts = 0;
     this.approvalTimeline = new DotsApprovalTimeline(this);
     this.chatActivity = new DotsRoomActivity(this);
@@ -77,6 +79,7 @@ export class DotsChatServer extends HostedHistoryAppServer {
     this.traceSync('invalidated', null, reason);
     clearTimeout(this.reconnectTimer);
     this.epoch = randomUUID(); this.chatActivity.close(); this.approvalTimeline.clear();
+    this.roomApprovalResponses.clear();
     for (const record of this.threads.values()) { record.needsReload = true; record.tokens.clear(); record.refresh = null; }
     for (const timer of this.windowSaves.values()) clearTimeout(timer); this.windowSaves.clear();
     for (const slot of this.subscriptions.values()) clearTimeout(slot.expiry);
@@ -394,7 +397,53 @@ export class DotsChatServer extends HostedHistoryAppServer {
     const turn = { id: `activity:${params.turnId}:${item.id}`, status: 'completed', items: [item] };
     this.publish(params.threadId, record, mergeTurns(record.thread.turns, [turn]));
   }
-  respondApproval(threadId, body) { this.requireWritable(threadId); return this.transport.respondApproval(threadId, body); }
+  async inspectApproval(threadId, body) {
+    if (typeof body.roomMessageId !== 'string' || !body.roomMessageId || typeof body.id !== 'string' || !body.id) throw new Error('确认请求标识无效');
+    const epoch = this.epoch, room = this.bindings.get(threadId) || await this.room(threadId);
+    const route = `/messaging/rooms/${encodeURIComponent(room.id)}/messages/${encodeURIComponent(body.roomMessageId)}/elicitation`;
+    const current = await this.rooms.request(`${route}?inspect=true`), request = current.elicitation;
+    if (epoch !== this.epoch || this.bindings.get(threadId) !== room || request?.request_id !== body.id
+      || request.params?.threadId !== request.thread_id || typeof current.request_fingerprint !== 'string') throw new Error('确认请求已变化，请重新核对。');
+    if (!serverRequests.confirmation({ method: serverRequests.elicitation, params: request.params })) throw new Error('此房间请求尚未支持');
+    const key = JSON.stringify([room.id, body.roomMessageId, body.id]);
+    return { requestId: request.request_id, params: request.params, fingerprint: current.request_fingerprint,
+      status: current.runtime_status, canRespond: current.can_respond === true && current.runtime_status === 'pending',
+      submissionStatus: this.roomApprovalResponses.get(key) || null };
+  }
+  async respondApproval(threadId, body) {
+    this.requireWritable(threadId);
+    if (!body.roomMessageId) return this.transport.respondApproval(threadId, body);
+    const epoch = this.epoch, room = this.bindings.get(threadId);
+    if (!room || typeof body.fingerprint !== 'string' || !body.fingerprint) throw new Error('请先核对确认请求。');
+    const key = JSON.stringify([room.id, body.roomMessageId, body.id]);
+    if (this.roomApprovalResponses.has(key)) throw new Error('此确认请求已提交，请核对结果。');
+    this.roomApprovalResponses.set(key, 'submitting');
+    let sent = false;
+    try {
+      const current = await this.inspectApproval(threadId, body);
+      if (epoch !== this.epoch || !current.canRespond || current.fingerprint !== body.fingerprint) throw new Error('确认请求已变化或结束，请重新核对。');
+      const request = { method: serverRequests.elicitation, params: current.params };
+      serverRequests.validate(request, body.result);
+      sent = true;
+      const route = `/messaging/rooms/${encodeURIComponent(room.id)}/messages/${encodeURIComponent(body.roomMessageId)}/elicitation/response`;
+      const result = await this.rooms.request(route, { method: 'POST', body: { request_fingerprint: current.fingerprint, result: body.result } });
+      if (epoch === this.epoch) this.roomApprovalResponses.set(key, result?.status === 'applied' ? 'applied' : 'unknown');
+      if (epoch === this.epoch && result?.status === 'applied') {
+        const record = this.threads.get(threadId);
+        const turns = record && structuredClone(record.thread.turns);
+        const applied = turns?.flatMap(turn => turn.items).find(item => item.roomMessageId === body.roomMessageId);
+        if (applied) { applied.status = 'resolved'; applied.result = body.result; this.publish(threadId, record, turns); }
+      }
+      return result;
+    } catch (error) {
+      if (!sent) error.deliveryUnknown = false;
+      if (epoch === this.epoch) {
+        if (error.deliveryUnknown === false) this.roomApprovalResponses.delete(key);
+        else this.roomApprovalResponses.set(key, 'unknown');
+      }
+      throw error;
+    }
+  }
   acquireActivity(threadId, listener) { return this.chatActivity.acquire(threadId, listener); }
   acquirePanelActivity(threadId, listener) { return this.chatActivity.acquire(threadId, listener); }
   isHistorySyncing() { return false; }

package/dist/src/dots-room-client.mjs

@@ -24,7 +24,7 @@ export class DotsRoomClient extends CelsiusClient {
       'chatgpt-account-id': identity.accountId, 'user-agent': 'Code-Relax/0.1.0' } };
   }
 
-  async request(route, { method = 'GET', body, contentType, signal, onEvent } = {}) {
+  async request(route, { method = 'GET', body, contentType, signal, onEvent, rawResponse = false } = {}) {
     const auth = await this.authorization();
     const controller = new AbortController(); this.controllers.add(controller);
     const cancelled = () => controller.abort(signal.reason);
@@ -86,7 +86,7 @@ export class DotsRoomClient extends CelsiusClient {
         request.on('error', error => finish(error));
         request.on('end', () => {
           if (!current()) { finish(new Error('点点账号已变化，请重新连接。')); return; }
-          try { finish(null, onEvent ? null : text ? JSON.parse(text) : null); } catch (error) { finish(error); }
+          try { finish(null, onEvent ? null : rawResponse ? text : text ? JSON.parse(text) : null); } catch (error) { finish(error); }
         });
         request.on('close', () => { if (!settled) finish(new Error('点点请求连接已断开。')); });
         // end() can queue data before TLS connects. Only a ready HTTP/2 stream

package/dist/src/dots-task-catalog.mjs

@@ -2,6 +2,8 @@ import WebSocket from 'ws';
 import { HostedHistoryAppServer } from './hosted-history-app-server.mjs';
 import { createDotsAvatarReader } from './dots-avatar.mjs';
 import { readDotsCatalog } from './dots-profile.mjs';
+import { DotsRoomClient } from './dots-room-client.mjs';
+import { uploadTaskFiles, taskFilePrompt } from './dots-task-files.mjs';
 
 const hostedAppServerUrl = 'wss://codex-cloud-backend.chatgpt.com/';
 export const dotsTaskRevision = turn => turn ? JSON.stringify([turn.id, turn.status]) : '';
@@ -9,10 +11,12 @@ export const dotsTaskRevision = turn => turn ? JSON.stringify([turn.id, turn.sta
 // Dots delegated tasks live in Desktop's durable host. Reuse the app-server
 // protocol client; only the authenticated transport differs from the local host.
 export class DotsAppServer extends HostedHistoryAppServer {
-  constructor(localServer, readProfiles = async () => new Map(), historyCache = null) {
+  constructor(localServer, readProfiles = async () => new Map(), historyCache = null, { uploadsRoot } = {}) {
     super(localServer.url, historyCache);
     this.historySource = 'aeon_child';
     this.localServer = localServer;
+    this.uploadsRoot = uploadsRoot;
+    this.filesClient = new DotsRoomClient(this);
     this.url = hostedAppServerUrl;
     this.threadSources = new Map();
     this.catalogWatches = new Map();
@@ -30,6 +34,7 @@ export class DotsAppServer extends HostedHistoryAppServer {
       this.saveHistoryWindow(thread.id);
     });
     this.on('disconnected', () => {
+      this.filesClient.close();
       this.profileIdentity = null;
       this.catalogPages.clear(); this.profileRefresh = null; this.profileAttemptAt = 0;
       this.catalogWatches.clear();
@@ -94,7 +99,7 @@ export class DotsAppServer extends HostedHistoryAppServer {
   nativeRequest(method, params, transform) {
     const socket = this.socket;
     return super.request(method, params, transform).catch(error => {
-      if (error.code === 'app_server_request_timeout' && this.ready && this.socket === socket && !this.resetting) {
+      if (error.code === 'app_server_request_timeout' && !error.deliveryResult && this.ready && this.socket === socket && !this.resetting) {
         // An OPEN hosted socket can stop answering RPCs while still delivering
         // notifications. Invalidate it once; reconnect through the existing
         // observer lifecycle, never replay the request whose outcome is unknown.
@@ -244,12 +249,26 @@ export class DotsAppServer extends HostedHistoryAppServer {
   }
 
   async send(args) {
+    const { uploadFiles = [], ...turnArgs } = args;
+    let assertCurrent;
     try {
       await this.connect();
       const record = this.threads.get(args.threadId);
       if (!record || record.needsReload) await this.timeline(args.threadId);
+      if (uploadFiles.length) {
+        this.requireWritable(args.threadId);
+        const epoch = this.epoch, identity = this.profileIdentity;
+        const current = () => {
+          if (epoch !== this.epoch || identity !== this.profileIdentity || !this.ready) throw new Error('云端连接已变化，请核对后发送。');
+        };
+        assertCurrent = current;
+        const references = await uploadTaskFiles(uploadFiles, { uploadsRoot: this.uploadsRoot, client: this.filesClient, current });
+        current();
+        const text = turnArgs.input.filter(item => item.type === 'text').map(item => item.text).join('\n');
+        turnArgs.input = [{ type: 'text', text: taskFilePrompt(text, references) }, ...turnArgs.input.filter(item => item.type !== 'text')];
+      }
     } catch (error) { error.deliveryUnknown = false; throw error; }
-    return super.send(args);
+    return super.send(turnArgs, { assertCurrent });
   }
 
   async interrupt(threadId) {

package/dist/src/dots-task-files.mjs

@@ -0,0 +1,52 @@
+import { randomUUID } from 'node:crypto';
+import { readMessageUploads } from './message-upload-files.mjs';
+
+// Desktop 26.1007.9446.0 Dll/Uhn/pA: reserve, upload bytes, confirm,
+// then include an Uploaded file sediment pointer in the user message.
+export async function uploadTaskFiles(files, { uploadsRoot, client, current, fetchImpl = fetch }) {
+  const uploads = await readMessageUploads({ files }, uploadsRoot);
+  const references = [];
+  for (const file of uploads) {
+    current();
+    const reserved = await client.request('/files', { method: 'POST', body: {
+      file_name: file.name, file_size: file.bytes.length, mime_type: file.mimeType,
+      use_case: 'codex', store_in_library: false, timezone_offset_min: new Date().getTimezoneOffset(), reset_rate_limits: false,
+    } });
+    current();
+    if (reserved?.status === 'error' || !/^[A-Za-z0-9_-]{1,256}$/.test(reserved?.file_id || '')
+      || typeof reserved.upload_url !== 'string') throw new Error('云端文件上传地址未确认。');
+    const url = new URL(reserved.upload_url, 'https://chatgpt.com');
+    if (url.protocol !== 'https:' || url.username || url.password || url.port || url.hash) throw new Error('云端文件上传地址无效。');
+    if (url.origin === 'https://chatgpt.com' && url.pathname === '/backend-api/estuary/upload_content_bytes') {
+      const uploadUrl = url.searchParams.get('upload_url');
+      if (!uploadUrl) throw new Error('云端文件上传地址缺少参数。');
+      const boundary = `relax-${randomUUID()}`;
+      const name = file.name.replaceAll('"', '%22').replaceAll('\\', '%5C');
+      const body = Buffer.concat([Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${name}"\r\nContent-Type: ${file.mimeType}\r\n\r\n`),
+        file.bytes, Buffer.from(`\r\n--${boundary}\r\nContent-Disposition: form-data; name="upload_url"\r\n\r\n${uploadUrl}\r\n--${boundary}--\r\n`)]);
+      await client.request(url.pathname.slice('/backend-api'.length) + url.search, {
+        method: 'POST', body, contentType: `multipart/form-data; boundary=${boundary}`, rawResponse: true,
+      });
+    } else {
+      if (!['.oaiusercontent.com', '.blob.core.windows.net', '.amazonaws.com'].some(suffix => url.hostname.endsWith(suffix))) {
+        throw new Error('云端文件上传地址不属于文件服务。');
+      }
+      const aws = [...url.searchParams.keys()].some(key => key.toLowerCase() === 'x-amz-algorithm');
+      const response = await fetchImpl(url, { method: 'PUT', body: file.bytes, redirect: 'error', signal: AbortSignal.timeout(60000),
+        headers: { 'Content-Type': file.mimeType, ...aws ? {} : { 'x-ms-blob-type': 'BlockBlob',
+          'x-ms-version': '2020-04-08', 'x-ms-blob-content-type': file.mimeType } } });
+      await response.body?.cancel();
+      if (!response.ok) throw new Error(`云端文件上传失败（${response.status}）。`);
+    }
+    current();
+    await client.request(`/files/${encodeURIComponent(reserved.file_id)}/uploaded`, { method: 'POST', body: {} });
+    current();
+    references.push({ pointer: `sediment://${reserved.file_id}`, fileName: file.name });
+  }
+  return references;
+}
+
+export function taskFilePrompt(text, references) {
+  if (!references.length) return text;
+  return `# Files mentioned by the user:\n${references.map(file => `\nUploaded file: ${JSON.stringify(file).replaceAll('#', '\\u0023')}\n`).join('')}\n## My request:\n${text || '请查看上述文件。'}`;
+}

package/dist/src/execution-health.mjs

@@ -1,26 +1,26 @@
-// Execution availability is sampled in the background. Health requests may
-// join the current sample so a reconnect cannot cache an initial false state.
-// Only connections are retried, not work.
-export class ExecutionHealth {
-  constructor(read, interval = 3000) { this.read = read; this.interval = interval; this.state = { state: 'checking', ready: false }; }
-  start() { this.stopped = false; void this.tick(); }
-  stop() { this.stopped = true; clearTimeout(this.timer); }
-  refresh() {
-    if (this.work) return this.work;
-    this.work = this.sample().finally(() => { this.work = null; });
-    return this.work;
-  }
-  async sample() {
-    try {
-      const result = await this.read();
-      this.state = result && typeof result === 'object'
-        ? { ...result, ready: Boolean(result.ready), checkedAt: new Date().toISOString() }
-        : { state: result ? 'ready' : 'unavailable', ready: Boolean(result), checkedAt: new Date().toISOString() };
-    } catch (error) { this.state = { state: 'unavailable', ready: false, error: error.message, checkedAt: new Date().toISOString() }; }
-    return this.state;
-  }
-  async tick() {
-    await this.refresh();
-    if (!this.stopped) { this.timer = setTimeout(() => this.tick(), this.interval); this.timer.unref?.(); }
-  }
-}
+// Execution availability is sampled in the background. Health requests may
+// join the current sample so a reconnect cannot cache an initial false state.
+// Only connections are retried, not work.
+export class ExecutionHealth {
+  constructor(read, interval = 3000) { this.read = read; this.interval = interval; this.state = { state: 'checking', ready: false }; }
+  start() { this.stopped = false; void this.tick(); }
+  stop() { this.stopped = true; clearTimeout(this.timer); }
+  refresh() {
+    if (this.work) return this.work;
+    this.work = this.sample().finally(() => { this.work = null; });
+    return this.work;
+  }
+  async sample() {
+    try {
+      const result = await this.read();
+      this.state = result && typeof result === 'object'
+        ? { ...result, ready: Boolean(result.ready), checkedAt: new Date().toISOString() }
+        : { state: result ? 'ready' : 'unavailable', ready: Boolean(result), checkedAt: new Date().toISOString() };
+    } catch (error) { this.state = { state: 'unavailable', ready: false, error: error.message, checkedAt: new Date().toISOString() }; }
+    return this.state;
+  }
+  async tick() {
+    await this.refresh();
+    if (!this.stopped) { this.timer = setTimeout(() => this.tick(), this.interval); this.timer.unref?.(); }
+  }
+}

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

@@ -93,7 +93,7 @@ export function attachLanSocket(server, { token, dispatch, authorizeDevice = ()
         }
         if (purpose === 'download') {
           if (message.type !== 'read' || typeof message.path !== 'string' || message.path.length > 12000 ||
-              !/^\/api\/(?:images\/[a-f0-9]{64}|files\/[a-f0-9]{64}|code\/(?:image|binary))(?:\?|$)/.test(message.path) || message.path.includes('#')) throw new Error('无效的文件读取请求');
+              !/^\/api\/(?:images\/[a-f0-9]{64}|files\/(?:local|[a-f0-9]{64})|code\/(?:image|binary)|desktop\/frames\/[a-f0-9]{32})(?:\?|$)/.test(message.path) || message.path.includes('#')) throw new Error('无效的文件读取请求');
           await dispatch({ method: 'GET', url: message.path, headers: {}, socketRequest: true, fileTransfer: true }, {
             json(status, body) { reply({ type: 'error', status, error: body?.error || '文件读取失败' }); },
             filePart(metadata, data) {
@@ -178,7 +178,7 @@ export function attachLanSocket(server, { token, dispatch, authorizeDevice = ()
       }
       if (typeof path !== 'string' || !path.startsWith('/api/') || path.includes('#') ||
           path.startsWith('/api/attachments/') || path === '/api/socket' || path === '/api/uploads' ||
-          subscription !== isStream || !['GET', 'POST', 'DELETE'].includes(message.method || 'GET') ||
+          subscription !== isStream || !['GET', 'POST', 'PUT', 'DELETE'].includes(message.method || 'GET') ||
           (subscription && message.method && message.method !== 'GET') ||
           (message.body !== undefined && (!message.body || typeof message.body !== 'object' || Array.isArray(message.body)))) {
         send({ type: 'response', id, status: 400, body: { error: '无效的连接请求' } }); return;

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

@@ -1,11 +1,12 @@
 import fs from 'node:fs';
+import { executableKey } from './platform/path-identity.mjs';
 import net from 'node:net';
 import path from 'node:path';
 import { EventEmitter } from 'node:events';
 import { setTimeout as delay } from 'node:timers/promises';
 import { readRecord, writeRecord } from './service-lifecycle.mjs';
 import { SharedAppServer } from './shared-app-server.mjs';
-import { pruneRetainedDesktopRuntimes, resolveCodexRuntime, runtimeFilesAvailable } from './platform/windows/codex-runtime.mjs';
+import { pruneRetainedDesktopRuntimes, resolveCodexRuntime, runtimeFilesAvailable } from './platform/codex-runtime.mjs';
 
 export const managedAppServerUrl = 'ws://127.0.0.1:45839';
 export const managedAppServerReadyUrl = 'http://127.0.0.1:45839/readyz';
@@ -80,7 +81,7 @@ export class ManagedAppServer extends EventEmitter {
         ? savedRuntime
         : await resolveCodexRuntime(this.stateRoot, { refresh: !actual, environment: this.environment });
       if (actual && !runtimeFilesAvailable(actual.executable)) {
-        throw new Error(`运行中的 Codex 内核目录已被移除或缺少 codex-code-mode-host.exe：${actual.executable}；已找到可用内核 ${runtime.executable}，请确认重启内核。`);
+        throw new Error(`运行中的 Codex 内核目录已被移除或缺少配套 code-mode-host：${actual.executable}；已找到可用内核 ${runtime.executable}，请确认重启内核。`);
       }
       if (!actual) {
         if (!await this.available()) throw new Error('45839 被未识别进程占用，未启动或结束任何进程。');
@@ -108,11 +109,11 @@ export class ManagedAppServer extends EventEmitter {
       await this.client.connect();
       if (!this.client.ready) throw new Error('Codex 内核协议初始化未完成。');
       if (startedHere) {
-        try { pruneRetainedDesktopRuntimes(this.stateRoot, actual.executable); }
+        try { await pruneRetainedDesktopRuntimes(this.stateRoot, actual.executable); }
         catch (error) { console.error('旧版 Codex 内核文件清理失败：', error); }
       }
       const preferredExecutable = path.resolve(runtime.executable);
-      const updatePending = path.resolve(actual.executable).toLowerCase() !== preferredExecutable.toLowerCase();
+      const updatePending = executableKey(actual.executable) !== executableKey(preferredExecutable);
       const launcherRevision = Number.isSafeInteger(record?.launcherRevision) ? record.launcherRevision : 0;
       this.retryAttempt = 0;
       this.retryAfter = 0;
@@ -171,7 +172,7 @@ export class ManagedAppServer extends EventEmitter {
       const desktop = await this.host.prepareKernelRestart?.();
       this.client.close();
       if (actual) {
-        await this.host.stop(actual.pid);
+        await this.host.stop(actual.pid, actual);
         await this.waitUntilStopped(actual);
       } else if (!await this.available()) {
         throw new Error('45839 被未识别进程占用，未结束任何进程。');
@@ -235,7 +236,9 @@ export class ManagedAppServer extends EventEmitter {
 
 export function sameManagedProcess(record, actual) {
   if (!record || !actual || record.pid !== actual.pid || record.created !== actual.created) return false;
-  if (String(record.executable || '').toLowerCase() !== String(actual.executable || '').toLowerCase()) return false;
+  if (!record.executable || !actual.executable || executableKey(record.executable) !== executableKey(actual.executable)) return false;
+  if (Array.isArray(actual.args)) return JSON.stringify(record.args) === JSON.stringify(actual.args)
+    && JSON.stringify(actual.args.slice(1)) === JSON.stringify(['app-server', '--listen', managedAppServerUrl]);
   const command = String(actual.command || '').toLowerCase();
   return command.includes('app-server') && command.includes(managedAppServerUrl);
 }

package/dist/src/message-images.mjs

@@ -1,9 +1,9 @@
-export function validateInlineImage(value) {
-  const data = typeof value === 'string' ? value.slice(value.indexOf(',') + 1) : '';
-  if (typeof value !== 'string' || value.length > Math.ceil(8 * 1024 * 1024 / 3) * 4 + 64 ||
-      !/^data:image\/(?:jpeg|png|webp);base64,/.test(value) || !data || data.length % 4 !== 0 ||
-      !/^[A-Za-z0-9+/]*={0,2}$/.test(data) || Buffer.byteLength(data, 'base64') > 8 * 1024 * 1024) {
-    throw new Error('图片必须是 JPEG、PNG 或 WebP 数据，且不超过 8 MiB。');
-  }
-  return value;
-}
+export function validateInlineImage(value) {
+  const data = typeof value === 'string' ? value.slice(value.indexOf(',') + 1) : '';
+  if (typeof value !== 'string' || value.length > Math.ceil(8 * 1024 * 1024 / 3) * 4 + 64 ||
+      !/^data:image\/(?:jpeg|png|webp);base64,/.test(value) || !data || data.length % 4 !== 0 ||
+      !/^[A-Za-z0-9+/]*={0,2}$/.test(data) || Buffer.byteLength(data, 'base64') > 8 * 1024 * 1024) {
+    throw new Error('图片必须是 JPEG、PNG 或 WebP 数据，且不超过 8 MiB。');
+  }
+  return value;
+}

package/dist/src/onboarding.mjs

@@ -1,29 +1,12 @@
-export const connectionModesText = [
-  '可选连接模式：',
-  '• 局域网：启动时会把当前 Wi-Fi/有线网络候选临时发给已配对设备；App 验证后保存，也可手动输入 IP。',
-  '• Code Relax 中继：同一设备授权可跨网络长期重连；Codex 内核就绪后才能进入聊天。',
-  '• OpenAI 中继：在已配对电脑内使用官方账号和设备授权；认证仍直连 OpenAI。',
-].join('\n');
-
-export function phonePairingSteps(transportMode, paired = false) {
-  const mode = transportMode === 'lan-shared' ? '局域网 · Codex 内核已就绪' : '局域网（Codex 内核未就绪）';
-  return paired ? [
-    `已有移动设备授权。移动端可继续使用 Code Relax 中继；${mode} 会显示验证成功的当前网络和历史记录。`,
-    '添加另一台设备时执行 relax pair；每台设备只需扫码配对一次。',
-  ] : [
-    '请先在移动端安装 Code Relax。当前为鸿蒙 HarmonyOS 7 私测版，调试 HAP 需通过 DevEco/调试设备安装，尚无商店下载入口。',
-    '使用 App 扫描配对二维码；每台移动设备只需配对一次。',
-    `配对后可直接使用 Code Relax 中继；${mode} 会接收并验证当前网络候选，也可手动输入 IP。`,
-  ];
-}
-export const desktopSetupSteps = [
-  'Code Relax Skill 已随 npm 包自动安装。',
-  '安装完成后桌面服务和 Codex 内核已启动，并默认在当前用户登录时启动。',
-  'CLI 用户无需安装 Desktop；已安装 Desktop 时，安装器负责将运行中的 Desktop 接入同一内核。',
-  '尚无设备授权时执行 relax pair，打开并扫描配对二维码。',
-  '统一配对先建立电脑记录；进入该电脑后可另行完成 OpenAI 官方 Remote 配对。',
+export function phonePairingSteps(_transportMode, paired = false) {
+  return paired ? ['已配对设备可直接连接。添加设备：relax pair']
+    : ['生成配对二维码：relax pair', '用 Code Relax App 扫码添加工作站。'];
+}
+export const desktopSetupSteps = [
+  '工作站服务和 Codex 内核已就绪，已启用登录自启。',
+  '生成配对二维码：relax pair',
 ];
 
-export function pairingDisplayText(nextSteps, notice) {
-  return ['桌面服务已就绪，请在移动端完成连接。', connectionModesText, ...nextSteps.map((step, index) => `${index + 1}. ${step}`), notice].join('\n\n');
+export function pairingDisplayText(nextSteps) {
+  return ['Code Relax 工作站已启动。', ...nextSteps].join('\n');
 }

package/dist/src/plan-pricing.mjs

@@ -0,0 +1,47 @@
+import http2 from 'node:http2';
+import pricing from '../shared/plan-pricing.cjs';
+
+export async function readPlanPricing(client) {
+  await client.connect();
+  const token = async () => (await client.request('getAuthStatus', { includeToken: true, refreshToken: false })).authToken;
+  const authToken = await token();
+  if (!authToken) return null;
+  const identity = value => {
+    const auth = JSON.parse(Buffer.from(value.split('.')[1], 'base64url'))['https://api.openai.com/auth'];
+    return JSON.stringify([auth?.chatgpt_account_id, auth?.chatgpt_user_id]);
+  };
+  const initialIdentity = identity(authToken), accountId = JSON.parse(initialIdentity)[0];
+  if (!accountId) return null;
+  const session = http2.connect('https://chatgpt.com');
+  session.on('error', () => {}); // Each stream reports its own request error.
+  try {
+    const get = route => new Promise((resolve, reject) => {
+      const request = session.request({ ':method': 'GET', ':path': '/backend-api' + route,
+        authorization: `Bearer ${authToken}`, 'chatgpt-account-id': accountId,
+        'user-agent': 'Code-Relax/0.1.0', accept: 'application/json' });
+      let body = '', status, size = 0, ended = false;
+      const timer = setTimeout(() => request.destroy(new Error('套餐费用查询超时。')), 15000);
+      request.setEncoding('utf8');
+      request.on('response', headers => { status = headers[':status']; });
+      request.on('data', chunk => {
+        size += Buffer.byteLength(chunk);
+        if (size > 1024 * 1024) request.destroy(new Error('套餐费用响应过大。'));
+        else body += chunk;
+      });
+      request.on('error', reject);
+      request.on('close', () => { clearTimeout(timer); if (!ended) reject(new Error('套餐费用连接已断开。')); });
+      request.on('end', () => {
+        ended = true;
+        try {
+          if (status !== 200) throw new Error(`套餐费用查询失败（HTTP ${status}）。`);
+          resolve(JSON.parse(body));
+        } catch (error) { reject(error); }
+      });
+      request.end();
+    });
+    const value = await pricing.read(accountId, get);
+    const current = await token();
+    if (!current || identity(current) !== initialIdentity) throw new Error('套餐查询期间账号已变化。');
+    return value;
+  } finally { session.destroy(); }
+}