@walkhi/code-relax 0.1.0-beta.83 → 0.1.0-beta.91

package/dist/build-platform.json

@@ -1 +1 @@
-{"layout":"npm-platform-packages","version":"0.1.0-beta.83"}
+{"layout":"npm-platform-packages","version":"0.1.0-beta.91"}

package/dist/shared/question-attention.cjs

@@ -36,10 +36,11 @@
     }
     return null;
   }
-  // A successful submission is enough to dismiss a question; model consumption
-  // can happen later. Store identities only, never answers or replayable writes.
+  // A successful submission can precede model consumption. Keep its answer for
+  // display across page recreation, never as a replayable send request.
   function createAnswerStore({ storage, scope, onError }) {
     const records = new Map();
+    const previews = new Map();
     const key = thread => 'codexRemoteAnsweredQuestions:' + JSON.stringify([
       scope(), thread.hostId || 'local', thread.id,
     ]);
@@ -63,7 +64,37 @@
         catch (error) { onError?.(error); }
       }
     }
-    return { key, has: (thread, id) => read(key(thread)).has(id), remember };
+    function readPreviews(owner) {
+      if (!previews.has(owner)) {
+        try {
+          const values = JSON.parse(storage.getItem(owner + ':replies') || '[]');
+          previews.set(owner, new Map(Array.isArray(values) ? values.filter(value =>
+            Array.isArray(value) && typeof value[0] === 'string' && typeof value[1] === 'string') : []));
+        } catch (error) { previews.set(owner, new Map()); onError?.(error); }
+      }
+      return previews.get(owner);
+    }
+    function savePreviews(owner) {
+      try {
+        const values = [...readPreviews(owner)];
+        if (values.length) storage.setItem(owner + ':replies', JSON.stringify(values));
+        else storage.removeItem(owner + ':replies');
+      } catch (error) { onError?.(error); }
+    }
+    function submitted(owner, replies) {
+      const values = readPreviews(owner);
+      for (const reply of replies) values.set(reply.questionItemId, reply.answer);
+      savePreviews(owner);
+      remember(owner, replies.map(reply => reply.questionItemId));
+    }
+    function reconcile(thread, ids) {
+      const owner = key(thread), values = readPreviews(owner);
+      let changed = false;
+      for (const id of ids) if (values.delete(id)) changed = true;
+      if (changed) savePreviews(owner);
+    }
+    return { key, has: (thread, id) => read(key(thread)).has(id), remember, submitted, reconcile,
+      answer: (thread, id) => readPreviews(key(thread)).get(id) };
   }
   return { parseQuestionReply, questionIds, fromNotification, createAnswerStore };
 });

package/dist/src/browser-auth-operations.mjs

@@ -4,7 +4,27 @@ import { createHash, randomUUID } from 'node:crypto';
 
 // Only submission markers are durable. Credentials never enter this store.
 export class BrowserAuthOperations {
-  constructor(stateRoot) { this.directory = path.join(stateRoot, 'browser-auth-operations'); }
+  constructor(stateRoot, codexDataRoot) {
+    this.directory = path.join(stateRoot, 'browser-auth-operations');
+    this.desktopStateFile = codexDataRoot && path.join(codexDataRoot, '.codex-global-state.json');
+  }
+  async desktopStatus(key, conversationId) {
+    if (!this.desktopStateFile) return null;
+    let state;
+    try { state = JSON.parse(await fs.readFile(this.desktopStateFile, 'utf8')); }
+    catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+    const [accountId, userId, , , , , challengeId] = key;
+    if (!accountId || !userId || !conversationId || !challengeId) return null;
+    // Desktop 26.1027.3384.0 operation journal; read only the scoped outcome.
+    const entry = state['electron-browser-auth-operations']?.entries?.find(entry => {
+      const c = entry.context;
+      return c?.accountId === accountId && c.userId === userId && c.hostId === 'durable'
+        && c.conversationId === conversationId && c.challengeId === challengeId;
+    });
+    const status = entry?.operation?.fillStatus;
+    return ['unknown', 'submitted', 'declined', 'cancelled', 'unavailable', 'expired',
+      'origin_changed', 'page_changed', 'locator_invalid', 'submission_failed'].includes(status) ? status : null;
+  }
   file(key) { return path.join(this.directory, createHash('sha256').update(JSON.stringify(key)).digest('hex') + '.json'); }
   async read(key) {
     try { return JSON.parse(await fs.readFile(this.file(key), 'utf8')).status; }

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

@@ -232,7 +232,7 @@ export class DotsChatServer extends HostedHistoryAppServer {
           || record.thread.turns.some(turn => turn.items.length) || saved?.turns?.some(turn => turn.items.length))) {
           throw new Error('点点最新消息尚未确认，请稍后重新同步。');
         }
-        const incoming = dotsRoomTurns(room, page.items), observed = record.thread.turns.length ? record.thread.turns : saved?.turns || [];
+        const incoming = (await this.roomTurns(threadId, room, page.items)), observed = record.thread.turns.length ? record.thread.turns : saved?.turns || [];
         const overlap = connectedPrefix(observed, incoming);
         const turns = overlap ? mergeTurns(observed, incoming) : incoming;
         const previousCursor = record.thread.turns.length ? record.nextCursor : saved?.nextCursor;
@@ -332,7 +332,7 @@ export class DotsChatServer extends HostedHistoryAppServer {
           let after = record.thread.turns.filter(turn => turn.roomMessage).at(-1)?.id;
           do {
             const page = await this.rooms.messages(room.id, { after }); check();
-            this.publish(threadId, record, mergeTurns(record.thread.turns, dotsRoomTurns(room, page.items)));
+            this.publish(threadId, record, mergeTurns(record.thread.turns, (await this.roomTurns(threadId, room, page.items))));
             for (const message of page.items) updates.delete(message.id);
             if (after && page.after === after) throw new Error('点点增量游标未推进。');
             after = page.after;
@@ -342,7 +342,7 @@ export class DotsChatServer extends HostedHistoryAppServer {
           const page = await this.rooms.messages(room.id, { around: id, limit: 1 }); check();
           const message = page.items.find(message => message.id === id);
           if (!message) throw new Error('点点消息更新尚未确认。');
-          const turns = dotsRoomTurns(room, [message]);
+          const turns = (await this.roomTurns(threadId, room, [message]));
           if (record.thread.turns.some(turn => turn.id === id)) this.publish(threadId, record, mergeTurns(record.thread.turns, turns));
           else {
             const first = record.thread.turns.find(turn => turn.roomMessage);
@@ -385,7 +385,7 @@ export class DotsChatServer extends HostedHistoryAppServer {
     if (record !== load.record || record?.needsReload || record?.recoverAfter > load.sequence) {
       throw new Error('点点历史读取期间消息已变化，请重试加载。');
     }
-    const turns = dotsRoomTurns(room, page.items).map(turn => {
+    const turns = (await this.roomTurns(threadId, room, page.items)).map(turn => {
       const changed = record?.changes.get(turn.id);
       return changed?.sequence > load.sequence ? { ...changed.turn, historyOnly: false } : turn;
     });
@@ -466,6 +466,18 @@ 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]));
   }
+  async roomTurns(threadId, room, messages) {
+    const epoch = this.epoch, record = this.threads.get(threadId), turns = dotsRoomTurns(room, messages);
+    for (const item of turns.flatMap(turn => turn.items)) {
+      if (item.type !== 'approval' || !serverRequests.browserAuth(item)) continue;
+      const key = this.browserAuthKey(threadId, { roomMessageId: item.roomMessageId, id: item.requestId }, item.params);
+      const status = await this.browserAuthOperations?.desktopStatus(key, item.params.threadId)
+        || await this.browserAuthOperations?.read(key);
+      if (status) item.authenticationStatus = status;
+    }
+    if (epoch !== this.epoch || record !== this.threads.get(threadId)) throw new Error('点点连接已变化，请重新核对。');
+    return turns;
+  }
   browserAuthKey(threadId, body, params) {
     const identity = this.historyIdentity;
     return [identity?.accountId, identity?.userId, threadId, this.bindings.get(threadId)?.id,
@@ -481,7 +493,21 @@ export class DotsChatServer extends HostedHistoryAppServer {
     if (!request.params || typeof request.params.mode !== 'string') throw new Error('此房间请求格式无效');
     const key = JSON.stringify([room.id, body.roomMessageId, body.id]);
     const auth = serverRequests.browserAuth({ method: serverRequests.elicitation, params: request.params });
-    const authStatus = auth && await this.browserAuthOperations?.read(this.browserAuthKey(threadId, body, request.params));
+    const authKey = auth && this.browserAuthKey(threadId, body, request.params);
+    const authStatus = auth && (await this.browserAuthOperations?.desktopStatus(authKey, request.params.threadId)
+      || await this.browserAuthOperations?.read(authKey));
+    // Inspect is authoritative for this request, even when room history is older.
+    const record = this.threads.get(threadId);
+    const previous = record?.thread.turns.flatMap(turn => turn.items).find(item => item.type === 'approval'
+      && item.roomMessageId === body.roomMessageId && item.requestId === body.id);
+    if (previous && ['resolved', 'expired'].includes(current.runtime_status) && (previous.status !== current.runtime_status || previous.authenticationStatus !== (authStatus || null))) {
+      const turns = structuredClone(record.thread.turns);
+      const updated = turns.flatMap(turn => turn.items).find(item => item.id === previous.id);
+      Object.assign(updated, { status: current.runtime_status, params: request.params, authenticationStatus: authStatus || null });
+      await this.approvalTimeline.observe(threadId, [updated], turns);
+      if (epoch !== this.epoch || this.threads.get(threadId) !== record) throw new Error('点点连接已变化，请重新核对。');
+      this.publish(threadId, record, turns);
+    }
     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, authenticationStatus: authStatus || null,
@@ -498,7 +524,8 @@ export class DotsChatServer extends HostedHistoryAppServer {
   }
   async authenticateApproval(threadId, body) {
     if (!this.browserAuthOperations) throw new Error('安全登录提交服务尚未就绪');
-    return this.submitRoomApproval(threadId, body, async (current, markSent) => {
+    let fillStatus;
+    const response = await this.submitRoomApproval(threadId, body, async (current, markSent) => {
       const auth = serverRequests.browserAuth({ method: serverRequests.elicitation, params: current.params });
       serverRequests.validateBrowserAuthFields(auth, body.fields);
       const key = this.browserAuthKey(threadId, body, current.params);
@@ -516,11 +543,16 @@ export class DotsChatServer extends HostedHistoryAppServer {
         throw Object.assign(new Error(`安全登录提交${status ? `失败（HTTP ${status}）` : '结果未确认'}，请在官网核对；不会重复发送登录信息`),
           { deliveryUnknown: error.deliveryUnknown });
       }
-      console.info(JSON.stringify({ time: new Date().toISOString(), event: 'browser-auth', phase: 'fill-result', requestId: body.id, submitted: filled?.status === 'submitted' }));
-      if (filled?.status !== 'submitted') throw new Error('安全登录未确认完成，请在官网核对；不会重新发送登录信息');
-      await this.browserAuthOperations.complete(key, 'submitted');
-      return { action: 'accept' };
+      const known = ['submitted', 'declined', 'cancelled', 'unavailable', 'expired', 'origin_changed', 'page_changed', 'locator_invalid', 'submission_failed'];
+      fillStatus = known.includes(filled?.status) ? filled.status : 'unknown';
+      console.info(JSON.stringify({ time: new Date().toISOString(), event: 'browser-auth', phase: 'fill-result', requestId: body.id, fillStatus }));
+      if (fillStatus === 'unknown') throw new Error('安全登录结果未确认，请在桌面端核对；不会重新发送登录信息');
+      await this.browserAuthOperations.complete(key, fillStatus);
+      // Desktop replies to every definitive fill outcome, not just success.
+      return { action: fillStatus === 'submitted' ? 'accept' : 'decline' };
     });
+    return { ...response, authenticationStatus: fillStatus,
+      result: { action: fillStatus === 'submitted' ? 'accept' : 'decline' } };
   }
   async submitRoomApproval(threadId, body, prepareResult) {
     this.requireWritable(threadId);
@@ -552,7 +584,14 @@ export class DotsChatServer extends HostedHistoryAppServer {
         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 = resultBody; this.publish(threadId, record, turns); }
+        if (applied) {
+          applied.status = 'resolved'; applied.result = resultBody;
+          if (serverRequests.browserAuth({ method: serverRequests.elicitation, params: current.params })) {
+            applied.authenticationStatus = await this.browserAuthOperations?.read(this.browserAuthKey(threadId, body, current.params));
+          }
+          await this.approvalTimeline.observe(threadId, [applied], turns);
+          if (epoch === this.epoch && this.threads.get(threadId) === record) this.publish(threadId, record, turns);
+        }
       }
       return result;
     } catch (error) {

package/dist/src/file-upload-session.mjs

@@ -87,7 +87,7 @@ export function createFileUploadSession(root) {
         const previous = files.get(message.fileKey);
         if (previous) {
           if (previous.originalName !== message.name || previous.size !== message.size ||
-              previous.expected !== message.sha256?.toLowerCase() || previous.previewOf !== message.previewOf) throw new Error('续传文件身份不一致');
+              previous.previewOf !== message.previewOf) throw new Error('续传文件身份不一致');
           return previous.result || { type: 'started', id: previous.id, offset: previous.offset, chunkBytes: FILE_CHUNK_BYTES };
         }
         if (committed) throw new Error('文件批次已提交');
@@ -101,14 +101,13 @@ export function createFileUploadSession(root) {
         if (message.previewOf && (!parent || parent.preview || message.size > FILE_CHUNK_BYTES)) throw new Error('预览图关联无效或超过 256 KiB');
         if (!parent && completed.size >= MAX_FILE_COUNT) throw new Error('每条消息最多 4 个文件');
         if (!parent && relayed && completedBytes + message.size > MAX_TOTAL_BYTES) throw new Error('服务器转发仅支持每批合计不超过 40 MiB，请使用局域网或 RTC 直连');
-        if (!/^[a-f0-9]{64}$/i.test(message.sha256 || '')) throw new Error('文件校验值无效');
         const id = crypto.randomUUID();
         await fs.mkdir(directory, { recursive: true });
         const partial = path.join(directory, `.upload-${id}`);
         const handle = await fs.open(partial, 'wx');
         upload = { id, partial, handle, name: parent ? `${id}.preview.jpg` : message.name, size: message.size, parent,
           originalName: message.name, previewOf: message.previewOf,
-          expected: message.sha256.toLowerCase(), hash: crypto.createHash('sha256'), offset: 0 };
+          offset: 0 };
         files.set(message.fileKey, upload);
         return { type: 'started', id, offset: 0, chunkBytes: FILE_CHUNK_BYTES };
       }
@@ -126,13 +125,12 @@ export function createFileUploadSession(root) {
           throw new Error('文件分片大小无效');
         }
         await current.handle.writeFile(bytes);
-        current.hash.update(bytes);
         current.offset += bytes.length;
         return { type: 'offset', id: current.id, offset: current.offset };
       }
       if (message.type === 'finish') {
-        if (current.offset !== current.size || current.hash.digest('hex') !== current.expected) {
-          await clear(); throw new Error('文件大小或 SHA-256 校验失败');
+        if (current.offset !== current.size) {
+          await clear(); throw new Error('文件大小不一致');
         }
         await current.handle.sync();
         await current.handle.close();
@@ -140,7 +138,7 @@ export function createFileUploadSession(root) {
         let saved;
         try { saved = await uniqueDestination(directory, current.name, current.partial); }
         catch (error) { await fs.unlink(current.partial).catch(() => {}); throw error; }
-        const result = { type: 'completed', id: current.id, ...saved, size: current.size, sha256: current.expected };
+        const result = { type: 'completed', id: current.id, ...saved, size: current.size };
         current.result = result;
         if (current.parent) current.parent.preview = result;
         else { completed.set(current.id, result); completedBytes += current.size; }

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

@@ -116,9 +116,7 @@ export function attachLanSocket(server, { token, dispatch, authorizeDevice = ()
           if (stopped || closing || ws.readyState !== WebSocket.OPEN) return;
           if (message.type === 'device-auth' && !authorizeDevice(message.clientId, message.credential)) throw new Error('设备授权已失效');
           const same = [...activeUploads.values()].filter(item => item.identity === identity && item.purpose === purpose);
-          const uploads = [...activeUploads.values()].filter(item => item.purpose === 'upload').length;
-          if (!identity || same.length >= (purpose === 'upload' ? 1 : 3) || activeUploads.size >= 8 ||
-              (purpose === 'upload' && uploads >= 2)) throw new Error('文件身份无效或文件任务过多');
+          if (!identity || (purpose === 'download' && same.length >= 3) || activeUploads.size >= 8) throw new Error('文件身份无效或文件任务过多');
           if (message.type === 'device-auth') deviceConnections.set(ws, {
             clientId: message.clientId, credential: message.credential,
             revoke() { discardUpload = true; stop(); ws.close(4401, 'Device authorization revoked'); },
@@ -128,7 +126,6 @@ export function attachLanSocket(server, { token, dispatch, authorizeDevice = ()
           if (purpose === 'upload') {
             uploadEntry = uploadSessions.get(uploadId);
             if (!uploadEntry) {
-              if ([...uploadSessions.values()].filter(entry => !entry.committed).length >= 2) throw new Error('待完成上传批次过多，请稍后再试');
               if (uploadSessions.size >= 32) {
                 const oldest = [...uploadSessions].find(([, entry]) => entry.committed && !entry.ws);
                 if (!oldest) throw new Error('上传批次过多，请稍后再试');
@@ -142,7 +139,7 @@ export function attachLanSocket(server, { token, dispatch, authorizeDevice = ()
             Object.assign(uploadEntry, { ws, released });
             upload = uploadEntry.session;
           }
-          reply({ type: 'ready', version: 4, purpose, maxDownloadBytes: fileRelay ? FILE_READ_LIMIT : null, maxFileBytes: fileRelay ? MAX_FILE_BYTES : null, maxFileCount: MAX_FILE_COUNT,
+          reply({ type: 'ready', version: 5, purpose, maxDownloadBytes: fileRelay ? FILE_READ_LIMIT : null, maxFileBytes: fileRelay ? MAX_FILE_BYTES : null, maxFileCount: MAX_FILE_COUNT,
             maxTotalBytes: fileRelay ? MAX_TOTAL_BYTES : null, chunkBytes: FILE_CHUNK_BYTES, uploadSessionId: uploadId });
           return;
         }

package/dist/src/message-upload-files.mjs

@@ -1,115 +1,111 @@
-import fs from 'node:fs/promises';
-import { openAsBlob } from 'node:fs';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import sharp from 'sharp';
-import media from '../shared/code-browser.cjs';
-import { validateInlineImage } from './message-images.mjs';
-import { createFileUploadSession, FILE_CHUNK_BYTES, MAX_FILE_COUNT } from './file-upload-session.mjs';
-import { fileRevision } from './file-transfer-range.mjs';
-
-const mimeTypes = { pdf: 'application/pdf', txt: 'text/plain', md: 'text/markdown', csv: 'text/csv',
-  json: 'application/json', zip: 'application/zip', doc: 'application/msword',
-  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-  xls: 'application/vnd.ms-excel', xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-  ppt: 'application/vnd.ms-powerpoint', pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation' };
-
-// Reuse the incoming-file contract without sending workstation bytes to the phone.
-export async function stageWorkstationMessageFile(file, uploadsRoot) {
-  const handle = await fs.open(file.path, 'r');
-  const session = createFileUploadSession(uploadsRoot);
-  try {
-    const stat = await handle.stat();
-    if (!stat.isFile() || stat.size < 1) throw new Error('附件为空。');
-    const validate = async () => {
-      if (fileRevision(await handle.stat()) !== file.revision || fileRevision(await fs.stat(file.path)) !== file.revision) {
-        throw new Error('电脑文件已变化，请重新添加。');
-      }
-    };
-    await validate();
-    const bytes = Buffer.alloc(FILE_CHUNK_BYTES);
-    const hash = crypto.createHash('sha256');
-    const readPart = async offset => {
-      const length = Math.min(bytes.length, stat.size - offset);
-      let count = 0;
-      while (count < length) {
-        const { bytesRead } = await handle.read(bytes, count, length - count, offset + count);
-        if (!bytesRead) throw new Error('电脑文件读取不完整，请重新添加。');
-        count += bytesRead;
-      }
-      return bytes.subarray(0, length);
-    };
-    for (let offset = 0; offset < stat.size; offset += FILE_CHUNK_BYTES) hash.update(await readPart(offset));
-    await validate();
-    const sha256 = hash.digest('hex');
-    const started = await session.receive({ type: 'start', fileKey: '0', name: file.name, size: stat.size, sha256 });
-    for (let offset = 0; offset < stat.size; offset += FILE_CHUNK_BYTES) {
-      await session.receive({ type: 'chunk', id: started.id, offset, data: await readPart(offset) });
-    }
-    await validate();
-    const result = await session.receive({ type: 'finish', id: started.id });
-    await session.receive({ type: 'commit' });
-    return { ...result, mediaKind: media.mediaKind(file),
-      mimeType: media.mediaMime(file) || mimeTypes[path.extname(file.name).slice(1).toLowerCase()] || 'application/octet-stream' };
-  } finally { await handle.close(); await session.close(); }
-}
-
-async function localFile(file, directory) {
-  if (typeof file?.path !== 'string' || typeof file.name !== 'string' || !file.name || /[\r\n\0]/.test(file.name)) {
-    throw new Error('附件信息无效，请重新选择。');
-  }
-  const root = await fs.realpath(directory), resolved = await fs.realpath(file.path);
-  if (path.relative(root, path.dirname(resolved)) !== '') throw new Error('附件必须来自本次工作站上传目录。');
-  const handle = await fs.open(resolved, 'r');
-  try {
-    const stat = await handle.stat();
-    if (!stat.isFile() || stat.size < 1) throw new Error('附件为空。');
-    const bytes = await openAsBlob(resolved);
-    if (bytes.size !== stat.size) throw new Error('附件在读取时发生变化，请重新上传。');
-    const mimeType = media.mediaMime(file) || mimeTypes[path.extname(file.name).slice(1).toLowerCase()] || 'application/octet-stream';
-    if (!/^[a-z0-9.+-]+\/[a-z0-9.+-]+$/i.test(mimeType)) throw new Error('附件类型无效。');
-    return { name: file.name, mimeType, bytes, path: resolved };
-  } finally { await handle.close(); }
-}
-
-export async function readMessageUploads(body, uploadsRoot) {
-  const images = body.images ?? [], originals = body.originalImages ?? [], files = body.files ?? [];
-  if (![images, originals, files].every(Array.isArray) || images.length + originals.length > 4 || files.length + originals.length > MAX_FILE_COUNT) {
-    throw new Error('每条消息最多 4 张图片、4 个文件。');
-  }
-  const uploads = [];
-  let imageBytes = 0;
-  for (const image of images) {
-    let file;
-    if (typeof image === 'string' && image.startsWith('data:')) {
-      validateInlineImage(image);
-      const mimeType = image.slice(5, image.indexOf(';'));
-      file = { name: `image.${mimeType.split('/')[1]}`, mimeType, bytes: Buffer.from(image.slice(image.indexOf(',') + 1), 'base64') };
-    } else {
-      if (typeof image !== 'string' || !/^[a-f0-9]{64}$/.test(image)) throw new Error('图片标识无效。');
-      let extension = 'webp';
-      try { await fs.access(path.join(uploadsRoot, `${image}.webp`)); }
-      catch (error) { if (error.code !== 'ENOENT') throw error; extension = 'png'; }
-      file = await localFile({ path: path.join(uploadsRoot, `${image}.${extension}`), name: `image.${extension}` }, uploadsRoot);
-    }
-    imageBytes += file.bytes.size ?? file.bytes.length;
-    if (imageBytes > 8 * 1024 * 1024) throw new Error('压缩图片合计不能超过 8 MiB。');
-    uploads.push(file);
-  }
-  for (const original of originals) {
-    if (typeof original !== 'string' || !/\.(png|jpe?g|webp|gif)$/i.test(original)) throw new Error('原图路径无效。');
-  }
-  for (const file of [...originals.map(value => ({ path: value, name: path.basename(value) })), ...files]) {
-    const uploaded = await localFile(file, path.join(uploadsRoot, 'incoming'));
-    uploads.push(uploaded);
-  }
-  for (const file of uploads) {
-    if (/^image\/(?:png|jpeg|webp|gif)$/.test(file.mimeType)) {
-      const metadata = await sharp(file.path || file.bytes).metadata();
-      file.width = metadata.width; file.height = metadata.height;
-      if (!file.width || !file.height) throw new Error('无法读取 图片尺寸。');
-    }
-  }
-  if (uploads.filter(file => file.width).length > 4) throw new Error('每条消息最多 4 张图片。');
-  return uploads;
-}
+import fs from 'node:fs/promises';
+import { openAsBlob } from 'node:fs';
+import path from 'node:path';
+import sharp from 'sharp';
+import media from '../shared/code-browser.cjs';
+import { validateInlineImage } from './message-images.mjs';
+import { createFileUploadSession, FILE_CHUNK_BYTES, MAX_FILE_COUNT } from './file-upload-session.mjs';
+import { fileRevision } from './file-transfer-range.mjs';
+
+const mimeTypes = { pdf: 'application/pdf', txt: 'text/plain', md: 'text/markdown', csv: 'text/csv',
+  json: 'application/json', zip: 'application/zip', doc: 'application/msword',
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  xls: 'application/vnd.ms-excel', xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  ppt: 'application/vnd.ms-powerpoint', pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation' };
+
+// Reuse the incoming-file contract without sending workstation bytes to the phone.
+export async function stageWorkstationMessageFile(file, uploadsRoot) {
+  const handle = await fs.open(file.path, 'r');
+  const session = createFileUploadSession(uploadsRoot);
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile() || stat.size < 1) throw new Error('附件为空。');
+    const validate = async () => {
+      if (fileRevision(await handle.stat()) !== file.revision || fileRevision(await fs.stat(file.path)) !== file.revision) {
+        throw new Error('电脑文件已变化，请重新添加。');
+      }
+    };
+    await validate();
+    const bytes = Buffer.alloc(FILE_CHUNK_BYTES);
+    const readPart = async offset => {
+      const length = Math.min(bytes.length, stat.size - offset);
+      let count = 0;
+      while (count < length) {
+        const { bytesRead } = await handle.read(bytes, count, length - count, offset + count);
+        if (!bytesRead) throw new Error('电脑文件读取不完整，请重新添加。');
+        count += bytesRead;
+      }
+      return bytes.subarray(0, length);
+    };
+    await validate();
+    const started = await session.receive({ type: 'start', fileKey: '0', name: file.name, size: stat.size });
+    for (let offset = 0; offset < stat.size; offset += FILE_CHUNK_BYTES) {
+      await session.receive({ type: 'chunk', id: started.id, offset, data: await readPart(offset) });
+    }
+    await validate();
+    const result = await session.receive({ type: 'finish', id: started.id });
+    await session.receive({ type: 'commit' });
+    return { ...result, mediaKind: media.mediaKind(file),
+      mimeType: media.mediaMime(file) || mimeTypes[path.extname(file.name).slice(1).toLowerCase()] || 'application/octet-stream' };
+  } finally { await handle.close(); await session.close(); }
+}
+
+async function localFile(file, directory) {
+  if (typeof file?.path !== 'string' || typeof file.name !== 'string' || !file.name || /[\r\n\0]/.test(file.name)) {
+    throw new Error('附件信息无效，请重新选择。');
+  }
+  const root = await fs.realpath(directory), resolved = await fs.realpath(file.path);
+  if (path.relative(root, path.dirname(resolved)) !== '') throw new Error('附件必须来自本次工作站上传目录。');
+  const handle = await fs.open(resolved, 'r');
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile() || stat.size < 1) throw new Error('附件为空。');
+    const bytes = await openAsBlob(resolved);
+    if (bytes.size !== stat.size) throw new Error('附件在读取时发生变化，请重新上传。');
+    const mimeType = media.mediaMime(file) || mimeTypes[path.extname(file.name).slice(1).toLowerCase()] || 'application/octet-stream';
+    if (!/^[a-z0-9.+-]+\/[a-z0-9.+-]+$/i.test(mimeType)) throw new Error('附件类型无效。');
+    return { name: file.name, mimeType, bytes, path: resolved };
+  } finally { await handle.close(); }
+}
+
+export async function readMessageUploads(body, uploadsRoot) {
+  const images = body.images ?? [], originals = body.originalImages ?? [], files = body.files ?? [];
+  if (![images, originals, files].every(Array.isArray) || images.length + originals.length > 4 || files.length + originals.length > MAX_FILE_COUNT) {
+    throw new Error('每条消息最多 4 张图片、4 个文件。');
+  }
+  const uploads = [];
+  let imageBytes = 0;
+  for (const image of images) {
+    let file;
+    if (typeof image === 'string' && image.startsWith('data:')) {
+      validateInlineImage(image);
+      const mimeType = image.slice(5, image.indexOf(';'));
+      file = { name: `image.${mimeType.split('/')[1]}`, mimeType, bytes: Buffer.from(image.slice(image.indexOf(',') + 1), 'base64') };
+    } else {
+      if (typeof image !== 'string' || !/^[a-f0-9]{64}$/.test(image)) throw new Error('图片标识无效。');
+      let extension = 'webp';
+      try { await fs.access(path.join(uploadsRoot, `${image}.webp`)); }
+      catch (error) { if (error.code !== 'ENOENT') throw error; extension = 'png'; }
+      file = await localFile({ path: path.join(uploadsRoot, `${image}.${extension}`), name: `image.${extension}` }, uploadsRoot);
+    }
+    imageBytes += file.bytes.size ?? file.bytes.length;
+    if (imageBytes > 8 * 1024 * 1024) throw new Error('压缩图片合计不能超过 8 MiB。');
+    uploads.push(file);
+  }
+  for (const original of originals) {
+    if (typeof original !== 'string' || !/\.(png|jpe?g|webp|gif)$/i.test(original)) throw new Error('原图路径无效。');
+  }
+  for (const file of [...originals.map(value => ({ path: value, name: path.basename(value) })), ...files]) {
+    const uploaded = await localFile(file, path.join(uploadsRoot, 'incoming'));
+    uploads.push(uploaded);
+  }
+  for (const file of uploads) {
+    if (/^image\/(?:png|jpeg|webp|gif)$/.test(file.mimeType)) {
+      const metadata = await sharp(file.path || file.bytes).metadata();
+      file.width = metadata.width; file.height = metadata.height;
+      if (!file.width || !file.height) throw new Error('无法读取 图片尺寸。');
+    }
+  }
+  if (uploads.filter(file => file.width).length > 4) throw new Error('每条消息最多 4 张图片。');
+  return uploads;
+}

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

@@ -5,7 +5,7 @@ import { digest } from './wire.mjs';
 export function accountConnections() {
   const sessions = new Map();
   return {
-    track(token, onInvalid) {
+    track(token, onInvalid, refresh) {
       const key = digest(token);
       const entries = sessions.get(key) || new Set();
       sessions.set(key, entries);
@@ -25,10 +25,21 @@ export function accountConnections() {
         if (active && Date.now() >= expires) invalidate();
         return active;
       }
-      function schedule() {
+      function schedule(delay = 86400000) {
+        clearTimeout(timer);
         if (!valid()) return;
-        // Login lasts 30 days, longer than Node's maximum timer delay.
-        timer = setTimeout(schedule, Math.min(expires - Date.now(), 0x7fffffff));
+        timer = setTimeout(async () => {
+          if (!valid()) return;
+          if (!refresh) { schedule(); return; }
+          try {
+            const user = await refresh();
+            // A logout/disconnect during the database request must win.
+            if (active) entry.activate(user.expiresAt);
+          } catch (error) {
+            if (error.status === 401 || error.status === 403) invalidate();
+            else if (active) schedule(60000);
+          }
+        }, Math.min(expires - Date.now(), delay));
         timer.unref();
       }
       const entry = {

package/dist/src/self-relay/email-accounts.mjs

@@ -134,12 +134,24 @@ export function openEmailAccounts(pool, configFile, providerOverride) {
     finally { db.release(); }
   }
 
-  async function current(token) {
+  async function current(token, { renew = false } = {}) {
     if (typeof token !== 'string' || !/^[A-Za-z0-9_-]{43}$/.test(token)) throw error(401, 'Unauthorized');
-    const [rows] = await pool.execute(`SELECT u.id,i.normalized_value AS email,s.expires_at FROM user_sessions s
+    const query = `SELECT u.id,i.normalized_value AS email,s.expires_at FROM user_sessions s
       JOIN users u ON u.id=s.user_id JOIN user_login_identities i ON i.user_id=u.id AND i.kind='email'
-      WHERE s.token_hash=? AND s.revoked_at IS NULL AND s.expires_at>UTC_TIMESTAMP(3) AND u.status='active'`, [tokenHash(token)]);
+      WHERE s.token_hash=? AND s.revoked_at IS NULL AND s.expires_at>UTC_TIMESTAMP(3) AND u.status='active'`;
+    let [rows] = await pool.execute(query, [tokenHash(token)]);
     if (!rows.length) throw error(401, 'Unauthorized');
+    // Review identities keep their fixed authorization window, even when review login is disabled.
+    if (renew && rows[0].email !== config.reviewLogin?.email
+      && Date.parse(isoTime(rows[0].expires_at)) < Date.now() + 29 * 86400000) {
+      await pool.execute(`UPDATE user_sessions s JOIN users u ON u.id=s.user_id
+        SET s.expires_at=GREATEST(s.expires_at,UTC_TIMESTAMP(3) + INTERVAL 30 DAY)
+        WHERE s.token_hash=? AND s.revoked_at IS NULL AND s.expires_at>UTC_TIMESTAMP(3)
+          AND s.expires_at<UTC_TIMESTAMP(3) + INTERVAL 29 DAY AND u.status='active'`, [tokenHash(token)]);
+      // Recheck revocation/expiry after the conditional write; never resurrect an invalid session.
+      [rows] = await pool.execute(query, [tokenHash(token)]);
+      if (!rows.length) throw error(401, 'Unauthorized');
+    }
     return { id: rows[0].id, email: rows[0].email, expiresAt: isoTime(rows[0].expires_at) };
   }
 

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

@@ -266,7 +266,7 @@ 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') {
-        const user = await accounts.current(bearer);
+        const user = await accounts.current(bearer, { renew: true });
         accountReply(response, 200, { user, usage: await accounts.usage(user.id) }); return;
       }
       if (target.pathname === '/account/logout' && request.method === 'POST') {
@@ -557,9 +557,10 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
               !(['pair', 'resume'].includes(message.type) && message.management === true)) {
             if (!['pair', 'resume', 'observe', 'file-client'].includes(message.type)) return fail();
             if (!accounts || !validSecret(message.accountToken)) return fail(4431, 'Account login required');
-            accountConnection = accountSockets.track(message.accountToken, invalidateAccountConnection);
+            accountConnection = accountSockets.track(message.accountToken, invalidateAccountConnection,
+              () => accounts.current(message.accountToken, { renew: true }));
             try {
-              const user = await accounts.current(message.accountToken);
+              const user = await accounts.current(message.accountToken, { renew: true });
               if (!accountConnection.activate(user.expiresAt)) return;
               userId = user.id;
               ws.adminInfo.account = { id: user.id, email: user.email };

package/dist/src/server.mjs

@@ -14,6 +14,7 @@ import fileMentions from '../shared/file-mentions.cjs';
 import fileCitations from '../shared/file-citations.cjs';
 import { validateInlineImage } from './message-images.mjs';
 import { ThreadWriterConflictError } from './shared-app-server.mjs';
+import { readThreadGoal, changeThreadGoal } from './thread-goals.mjs';
 import { ManagedAppServer } from './managed-app-server.mjs';
 import { RuntimeDiscovery } from './runtime-discovery.mjs';
 import { streamSharedThread, threadListNotificationMethods } from './shared-thread-stream.mjs';
@@ -125,7 +126,7 @@ const hostedHistoryCache = new HostedHistoryCache(stateRoot);
 const dotsServer = new DotsAppServer(managedAppServer.client, desktopDotsProfiles(codexDataRoot, stateRoot), hostedHistoryCache, { uploadsRoot });
 const dotsImages = new DotsMessageImages({ localServer: managedAppServer.client, identity: () => dotsServer.profileIdentity,
   cache: attachmentCache, capabilityKey: imageCapabilityKey, maxEntries: MAX_CACHED_ATTACHMENTS, maxBytes: MAX_IMAGE_PREVIEW_BYTES });
-const dotsChat = new DotsChatServer(dotsServer, undefined, { uploadsRoot, browserAuthOperations: new BrowserAuthOperations(stateRoot) });
+const dotsChat = new DotsChatServer(dotsServer, undefined, { uploadsRoot, browserAuthOperations: new BrowserAuthOperations(stateRoot, codexDataRoot) });
 managedAppServer.on('state', state => { if (state.ready) dotsChat.startBackgroundActivity(); });
 const runtimeDiscovery = new RuntimeDiscovery({ stateRoot, host: desktopHost,
   url: () => managedAppServer.snapshot().url, diagnose: runtimeDiagnostic });
@@ -954,6 +955,22 @@ async function handleRequest(request, response) {
       }
     }
 
+    const goalMatch = /^\/api\/threads\/([^/]+)\/goal$/.exec(url.pathname);
+    if (goalMatch && ['GET', 'POST'].includes(request.method)) {
+      if (rootChat) throw new RequestError(405, '点点主聊天不提供线程目标操作。');
+      const threadId = decodeURIComponent(goalMatch[1]);
+      if (request.method === 'GET') sendJson(response, 200, await readThreadGoal(execution, threadId));
+      else {
+        await requireExecutionWritable(threadId, execution);
+        const body = await readJsonBody(request);
+        await execution.connect();
+        sendJson(response, 200, await changeThreadGoal(execution, threadId, body, {
+          beforeActivate: () => execution.prepareGoalActivation(threadId, { useGlobalPermissions: hostId !== 'durable' }),
+        }));
+      }
+      return;
+    }
+
     const renameMatch = /^\/api\/threads\/([^/]+)\/name$/.exec(url.pathname);
     if (request.method === 'POST' && renameMatch) {
       if (rootChat) throw new RequestError(405, '点点主聊天名称由点点资料管理。');

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

@@ -194,14 +194,18 @@ export class SharedAppServer extends EventEmitter {
 
   async send(args, { assertCurrent = () => {}, useGlobalPermissions = true } = {}) {
     let submitted = false;
+    let sendPhase = 'connect';
     try {
       await this.connect();
+      sendPhase = 'writable';
       this.requireWritable(args.threadId);
       // Reading the live thread checks this service owns it without resume changing settings.
+      sendPhase = 'thread-read';
       const { thread } = await this.request('thread/read', { threadId: args.threadId, includeTurns: false });
       assertCurrent();
       const status = typeof thread.status === 'string' ? thread.status : thread.status?.type;
       if (status === 'active') {
+        sendPhase = 'active-turn';
         const page = await this.request('thread/turns/list', {
           threadId: args.threadId, limit: 1, sortDirection: 'desc', itemsView: 'notLoaded',
         });
@@ -210,21 +214,37 @@ export class SharedAppServer extends EventEmitter {
         if (active?.status !== 'inProgress') throw new Error('活动轮次已变化，请刷新后再发送。');
         const { turnTrigger, ...source } = events.mobileTurnSource(args.clientUserMessageId, args.responsesapiClientMetadata?.code_relax_input === 'speech_to_text');
         submitted = true;
+        sendPhase = 'turn-steer';
         return await this.request('turn/steer', { threadId: args.threadId, expectedTurnId: active.id, input: args.input, ...source, ...(args.clientUserMessageId ? { clientUserMessageId: args.clientUserMessageId } : {}) },
           result => ({ result, usage: { kind: 'steer', turnId: active.id } }));
       }
+      sendPhase = 'permissions';
       const permissions = useGlobalPermissions ? await events.globalPermissionOverrides((method, params) => this.request(method, params),
         { ...this.contexts.get(args.threadId), desktopPermissionMode: await desktopPermissionMode(), model: args.model || this.contexts.get(args.threadId)?.model }, args.threadId) : {};
       assertCurrent();
       submitted = true;
+      sendPhase = 'turn-start';
       return await this.request('turn/start', { ...args, ...permissions },
         result => ({ result, usage: { kind: 'start', turnId: result?.turn?.id || null } }));
     } catch (error) {
       if (!submitted || messageDelivery.rejectedBeforeSubmission(error)) error.deliveryUnknown = false;
+      error.details = { ...(error.details && typeof error.details === 'object' ? error.details : {}), sendPhase,
+        ...(Number.isInteger(error.rpcCode) ? { rpcCode: error.rpcCode } : {}) };
       throw error;
     }
   }
 
+  async prepareGoalActivation(threadId, { useGlobalPermissions = true } = {}) {
+    this.requireWritable(threadId);
+    const record = this.threads.get(threadId);
+    if (!record || record.needsReload || record.hydrating) throw new Error('请等待对话同步完成后再开始目标');
+    if (!useGlobalPermissions) return;
+    const request = (method, params) => this.request(method, params);
+    const permissions = await events.globalPermissionOverrides(request,
+      { ...this.contexts.get(threadId), desktopPermissionMode: await desktopPermissionMode() }, threadId);
+    if (Object.keys(permissions).length) await request('thread/settings/update', { threadId, ...permissions });
+  }
+
   async findSentMessage(threadId, clientId, anchorItemId) {
     await this.connect();
     return messageDelivery.findMessage((method, params) => this.request(method, params), threadId, clientId, anchorItemId);
@@ -241,6 +261,7 @@ export class SharedAppServer extends EventEmitter {
   notification(method, params) {
     this.serverRequests.notification(method, params);
     this.emit('notification', { method, params });
+    if (['thread/goal/updated', 'thread/goal/cleared'].includes(method)) return;
     if (method === 'thread/queue/changed') { this.emit('queue-changed', params.threadId); return; }
     if (method === 'account/rateLimits/updated') { this.usageCache.update(params); return; }
     const id = params.threadId;

package/dist/src/shared-thread-stream.mjs

@@ -94,6 +94,11 @@ export async function streamSharedThread(response, threadId, client, normalize,
     flush();
   };
   const onSettings = id => { if (id === threadId) emit('settings', client.context(id)); };
+  const onGoal = ({ method, params }) => {
+    if (params.threadId === threadId && ['thread/goal/updated', 'thread/goal/cleared'].includes(method)) {
+      emit('goal', { threadId, goal: method === 'thread/goal/cleared' ? null : params.goal });
+    }
+  };
   const onRequests = id => { if (id === threadId) emit('approvals', { requests: client.serverRequests.list(threadId) }); };
   const onQueue = id => { if (id === threadId) emit('queue-changed', {}); };
   const onDisconnected = () => { emit('bridge-error', { error: 'Codex 内核连接已断开，请重新连接。' }); response.end(); finish(); };
@@ -102,6 +107,7 @@ export async function streamSharedThread(response, threadId, client, normalize,
   const onChatError = value => { if (value.threadId === threadId) emit('chat-error', value); };
   response.once('close', () => { closed = true; finish(); });
   client.on('turn', onTurn); client.on('settings', onSettings); client.on('disconnected', onDisconnected);
+  client.on('notification', onGoal);
   client.on('timeline-reset', onReset);
   client.on('queue-changed', onQueue);
   client.on('requests-changed', onRequests);
@@ -154,6 +160,7 @@ export async function streamSharedThread(response, threadId, client, normalize,
     clearTimeout(timer);
     releaseActivity?.();
     client.off('turn', onTurn); client.off('settings', onSettings); client.off('disconnected', onDisconnected);
+    client.off('notification', onGoal);
     client.off('timeline-reset', onReset);
     client.off('queue-changed', onQueue);
     client.off('requests-changed', onRequests);

package/dist/src/thread-goals.mjs

@@ -0,0 +1,40 @@
+// Goal state is metadata, independent of transcript snapshots and their cursors.
+export async function readThreadGoal(client, threadId) {
+  await client.connect();
+  try {
+    return { supported: true, ...await client.request('thread/goal/get', { threadId }) };
+  } catch (error) {
+    if (error.rpcCode === -32601 || /goals feature is disabled/i.test(error.message)) {
+      return { supported: false, goal: null };
+    }
+    throw error;
+  }
+}
+
+export async function changeThreadGoal(client, threadId, body, { beforeActivate } = {}) {
+  if (body.action === 'clear') return client.request('thread/goal/clear', { threadId, origin: 'user' });
+  if (body.action !== 'set') throw new Error('无效的目标操作');
+  const params = { threadId, origin: 'user' };
+  if (body.objective !== undefined) {
+    if (typeof body.objective !== 'string' || !body.objective.trim() || [...body.objective.trim()].length > 4000) {
+      throw new Error('请输入 1 至 4000 字的目标');
+    }
+    params.objective = body.objective.trim();
+  }
+  if (body.status !== undefined) {
+    if (!['active', 'paused'].includes(body.status)) throw new Error('无效的目标状态');
+    params.status = body.status;
+  }
+  if (body.tokenBudget !== undefined) {
+    if (body.tokenBudget !== null && (!Number.isSafeInteger(body.tokenBudget) || body.tokenBudget <= 0)) throw new Error('Token 预算必须为正整数');
+    params.tokenBudget = body.tokenBudget;
+  }
+  if (Object.keys(params).length === 2) throw new Error('请选择目标操作');
+  // GoalService starts idle turns itself. Prepare the same settings as a normal
+  // send before activating; never send a second turn/start for the goal.
+  if (beforeActivate && (params.status === 'active' || params.status === undefined
+    && ((await client.request('thread/goal/get', { threadId })).goal?.status ?? 'active') === 'active')) {
+    await beforeActivate();
+  }
+  return client.request('thread/goal/set', params);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walkhi/code-relax",
-  "version": "0.1.0-beta.83",
+  "version": "0.1.0-beta.91",
   "private": false,
   "license": "UNLICENSED",
   "type": "module",