@walkhi/code-relax 0.1.0-beta.27 → 0.1.0-beta.28

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

@@ -0,0 +1,94 @@
+// Desktop 26.1002.7124.0 hides appshot context before the visible request.
+// Presentation recognizes the format, never an application's routing contract.
+function appshotMessageBody(text) {
+  if (typeof text !== 'string' || !text.trimStart().startsWith('# Applications mentioned by the user:')) return text;
+  const request = /\r?\n## My request(?: for Codex)?:\r?\n/.exec(text);
+  if (!request) return text;
+  const context = text.slice(0, request.index);
+  for (const [, attributes, content] of context.matchAll(/<appshot\b([^>]*)>([\s\S]*?)<\/appshot>/g)) {
+    const attrs = new Map([...attributes.matchAll(/([A-Za-z][A-Za-z0-9-]*)="([^"]*)"/g)].map(([, key, value]) => [key, value]));
+    if (attrs.get('app')?.trim() && attrs.get('bundle-identifier')?.trim()
+      && (content.trim() || attrs.get('image')?.trim())) return text.slice(request.index + request[0].length);
+  }
+  return text;
+}
+
+// Desktop 26.1007.2314.0 X8o/Z8o: suggestions are a native widget, not text.
+// Use its supplied web setup entry on mobile; never invent an OAuth URL.
+function pluginSetupLinks(attachments) {
+  const links = new Map();
+  for (const attachment of attachments) {
+    if (attachment.type !== 'widget' || attachment.product_sku !== 'aeon'
+      || attachment.messages?.length !== 2) continue;
+    const [call, reply] = attachment.messages;
+    if (call.author?.role !== 'assistant' || reply.author?.role !== 'tool'
+      || call.id !== attachment.original_message_id || reply.metadata?.is_visually_hidden_from_conversation === true
+      || reply.metadata?.is_error === true) continue;
+    const first = call.metadata?.chatgpt_sdk, second = reply.metadata?.chatgpt_sdk;
+    const connector = first?.resource_name === 'plugin_management.suggest_plugins' ? 'connector_openai_plugin_management'
+      : first?.resource_name === 'openai_settings.suggest_plugins' ? 'connector_openai_openai_settings' : null;
+    if (!connector || [first, second].some(sdk => !sdk || sdk.resource_name !== first.resource_name
+      || sdk.html_asset_pointer !== 'internal://plugin-management-suggestions' || sdk.distribution_channel !== 'openai'
+      || sdk.attribution_id !== connector || sdk.resolved_pineapple_uri !== `connectors://${connector}`
+      || sdk.is_error === true || sdk.is_widget_closed === true)) continue;
+    const result = second.tool_response_metadata?.call_tool_result, data = result?.structuredContent;
+    if (result?.isError === true || data?.kind !== 'plugin_suggestions' || data.version !== 1
+      || typeof data.setup_url !== 'string' || !Array.isArray(data.suggestions) || !data.suggestions.length
+      || data.suggestions.some(plugin => typeof plugin?.plugin_id !== 'string' || !plugin.plugin_id
+        || typeof plugin.display_name !== 'string' || !plugin.display_name.trim())) continue;
+    let url;
+    try { url = new URL(data.setup_url); } catch { continue; }
+    if (url.origin !== 'https://chatgpt.com' || url.pathname !== '/plugin-suggestions'
+      || url.username || url.password || url.hash || url.searchParams.getAll('bundle').length !== 1
+      || !url.searchParams.get('bundle')) continue;
+    const names = [...new Map(data.suggestions.map(plugin => [plugin.plugin_id, plugin.display_name])).values()];
+    const label = names.join('、').replace(/[\r\n]+/g, ' ').replace(/[\\`*_[\]<>]/g, '\\$&');
+    links.set(data.setup_url, `[设置 ${label} 连接](<${url.href.replace(/</g, '%3C').replace(/>/g, '%3E')}>)`);
+  }
+  return [...links.values()];
+}
+
+// Message role alone is insufficient: Dot is also a user-shaped room member.
+export function dotsRoomTurns(room, messages) {
+  return messages.map(message => {
+    const member = room.members.find(value => value.account_user_id === message.account_user_id);
+    const assistant = Array.isArray(message.raw_messages) || Boolean(member?.aeon_id);
+    const time = Date.parse(message.created_at);
+    const common = { id: message.id, startedAtMs: Number.isFinite(time) ? time : undefined,
+      completedAtMs: Number.isFinite(time) ? time : undefined };
+    const rawText = Array.isArray(message.raw_messages) ? message.raw_messages
+      .filter(raw => raw.author?.role === 'assistant' && raw.channel !== 'analysis'
+        && !raw.metadata?.is_hidden && !raw.metadata?.hidden && ['text', 'multimodal_text'].includes(raw.content?.content_type))
+      .flatMap(raw => (raw.content.parts || []).filter(part => typeof part === 'string')).join('\n\n')
+      : message.content?.text || '';
+    const sourceAttachments = message.content?.attachments || message.attachments || [];
+    const text = assistant ? [rawText, ...pluginSetupLinks(sourceAttachments)].filter(Boolean).join('\n\n')
+      : member ? appshotMessageBody(rawText) : rawText;
+    const attachments = sourceAttachments.flatMap(attachment => {
+      if (attachment.type !== 'file' || typeof attachment.file_id !== 'string') return [];
+      const file = attachment.file || {};
+      return [{ type: /^image\//.test(file.mime_type || '') ? 'image' : 'file',
+        roomId: room.id, fileId: attachment.file_id, name: file.name || file.file_name || '附件',
+        mimeType: file.mime_type || '', size: file.size_bytes }];
+    });
+    let item;
+    if (!message.deleted_at && message.content?.type !== 'message_error') {
+      if (assistant) item = { ...common, type: 'agentMessage', text, attachments, phase: 'final', delivery: 'async',
+        ...(message.generation?.status === 'in_progress' ? { dotsStreaming: true, completedAtMs: null } : {}) };
+      else if (member) item = { ...common, type: 'userMessage', clientId: message.request_id?.replace(/-/g, ''),
+        content: [...(text ? [{ type: 'text', text }] : []), ...attachments] };
+    }
+    const request = message.content?.elicitation;
+    const approval = !message.deleted_at && request && typeof request.request_id === 'string' && request.request_id
+      && typeof request.thread_id === 'string' && request.thread_id && request.params?.threadId === request.thread_id
+      && ['pending', 'resolved', 'expired'].includes(request.status)
+      ? { type: 'approval', id: `approval:string:${request.request_id}`, requestId: request.request_id,
+        method: 'mcpServer/elicitation/request', params: request.params, status: request.status, result: null,
+        sourceThreadId: request.thread_id, turnId: request.turn_id ?? null, receivedAtMs: time,
+        completedAtMs: null, roomMessageId: message.id } : null;
+    return { id: message.id, status: item?.dotsStreaming ? 'inProgress' : 'completed',
+      roomMessage: true, deleted: Boolean(message.deleted_at), createdAt: message.created_at,
+      updatedAt: message.deleted_at || message.updated_at || message.created_at,
+      items: [...(item && (text || attachments.length) ? [item] : []), ...(approval ? [approval] : [])] };
+  });
+}

package/dist/src/dots-schedules.mjs

@@ -0,0 +1,66 @@
+import http2 from 'node:http2';
+
+// Desktop 26.930.3748.0: state-42dba351d73f lists this Dot's automations,
+// and F8 excludes finished schedules while retaining condition watches.
+export async function readDotsSchedules(dotsServer, threadId) {
+  await dotsServer.connect();
+  await dotsServer.source(threadId, 'aeon');
+  const identity = dotsServer.profileIdentity;
+  const auth = await dotsServer.localServer.request('getAuthStatus', { includeToken: true, refreshToken: false });
+  const principal = JSON.parse(Buffer.from(auth.authToken.split('.')[1], 'base64url').toString('utf8'))['https://api.openai.com/auth'];
+  if (!identity || identity.accountId !== principal?.chatgpt_account_id || identity.userId !== principal?.chatgpt_user_id) {
+    throw new Error('点点账号已变化，请重新连接。');
+  }
+  const session = http2.connect('https://chatgpt.com');
+  // Stream errors carry failures to the caller; consume the corresponding
+  // session event so a failed connection does not crash the workstation.
+  session.on('error', () => {});
+  const get = path => new Promise((resolve, reject) => {
+    const request = session.request({ ':method': 'GET', ':path': '/backend-api' + path,
+      authorization: `Bearer ${auth.authToken}`, 'chatgpt-account-id': identity.accountId,
+      'user-agent': 'Code-Relax/0.1.0', accept: 'application/json' });
+    let status, contentType, body = '', size = 0;
+    const timeout = setTimeout(() => request.destroy(new Error('读取点点定时任务超时。')), 60000);
+    request.setEncoding('utf8');
+    request.on('response', headers => { status = headers[':status']; contentType = headers['content-type']; });
+    request.on('data', chunk => {
+      size += Buffer.byteLength(chunk);
+      if (size > 8 * 1024 * 1024) request.destroy(new Error('点点定时任务响应过大。'));
+      else body += chunk;
+    });
+    request.on('error', reject);
+    request.on('close', () => clearTimeout(timeout));
+    request.on('end', () => {
+      try {
+        if (status !== 200) throw new Error(`读取点点定时任务失败（HTTP ${status}）。`);
+        if (!contentType?.includes('application/json')) throw new Error('点点定时任务返回了非 JSON 响应。');
+        resolve(JSON.parse(body));
+      } catch (error) { reject(error); }
+    });
+    request.end();
+  });
+  try {
+    const profile = await get(`/tbo/by-thread/${encodeURIComponent(threadId)}`);
+    if (typeof profile.id !== 'string' || !profile.id) throw new Error('点点资料缺少身份。');
+    const schedules = [];
+    let cursor;
+    do {
+      const query = new URLSearchParams({ limit: '100', ...(cursor ? { cursor } : {}) });
+      const page = await get(`/tbo/${encodeURIComponent(profile.id)}/automations?${query}`);
+      if (!Array.isArray(page.items) || page.cursor != null && typeof page.cursor !== 'string') throw new Error('点点定时任务列表格式无效。');
+      for (const item of page.items) {
+        if (typeof item.id !== 'string' || typeof item.title !== 'string' || typeof item.is_enabled !== 'boolean'
+          || !Array.isArray(item.next_run_times)) throw new Error('点点定时任务信息不完整。');
+        const watching = item.timing_mode === 'condition_watch';
+        if (item.executor !== 'local' && !watching && item.next_run_times.length === 0) continue;
+        schedules.push({ id: item.id, title: item.display_title?.trim() || item.title.trim(),
+          status: !item.is_enabled ? 'paused' : watching ? 'monitoring' : 'scheduled',
+          schedule: watching ? '' : item.display_schedule || '',
+          nextRunAt: item.is_enabled && !watching ? item.next_run_times[0] || null : null });
+      }
+      cursor = page.cursor;
+    } while (cursor);
+    if (dotsServer.profileIdentity !== identity) throw new Error('点点连接已变化，请重新读取。');
+    return { threadId, schedules };
+  } finally { session.destroy(); }
+}

package/dist/src/dots-summary-tasks.mjs

@@ -0,0 +1,32 @@
+import events from '../shared/app-server-events.cjs';
+
+export async function readDotsSummaryTasks(dotsServer, threadId) {
+  await dotsServer.source(threadId, 'aeon');
+  const catalog = await dotsServer.taskCatalog(false);
+  // Use the existing account-scoped local profile map, without a remote profile
+  // request. A Dot keeps its identity when its active root thread changes.
+  await dotsServer.refreshProfiles();
+  const identity = dotsServer.profileIdentity;
+  const profileId = dotsServer.profileNames.get(threadId)?.profileId;
+  const tasks = await Promise.all(catalog.filter(thread => thread.threadSource === 'aeon_child').map(async thread => {
+    const page = await dotsServer.nativeRequest('thread/items/list', {
+      threadId: thread.id, limit: 1, sortDirection: 'asc',
+    });
+    if (!Array.isArray(page.data)) throw new Error('点点任务未返回委派来源。');
+    const item = page.data[0]?.item;
+    if (item?.type !== 'userMessage' || !Array.isArray(item.content)
+      || !item.content.some(part => {
+        const sourceId = part.type === 'text' && events.parseCodexDelegation(part.text)?.sourceThreadId;
+        return sourceId && (sourceId === threadId || profileId
+          && dotsServer.profileNames.get(sourceId)?.profileId === profileId);
+      })) return null;
+
+    return {
+      id: thread.id, hostId: 'durable', threadSource: 'aeon_child',
+      title: thread.name?.trim() || '未命名任务', cwd: thread.cwd,
+      recencyAt: thread.recencyAt ?? thread.updatedAt,
+    };
+  }));
+  if (identity !== dotsServer.profileIdentity) throw new Error('点点账号已变化，请重新读取任务。');
+  return { threadId, tasks: tasks.filter(task => task !== null) };
+}

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

@@ -0,0 +1,411 @@
+import WebSocket from 'ws';
+import { HostedHistoryAppServer } from './hosted-history-app-server.mjs';
+import { createDotsAvatarReader } from './dots-avatar.mjs';
+import { readDotsCatalog } from './dots-profile.mjs';
+
+const hostedAppServerUrl = 'wss://codex-cloud-backend.chatgpt.com/';
+export const dotsTaskRevision = turn => turn ? JSON.stringify([turn.id, turn.status]) : '';
+
+// 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) {
+    super(localServer.url, historyCache);
+    this.historySource = 'aeon_child';
+    this.localServer = localServer;
+    this.url = hostedAppServerUrl;
+    this.threadSources = new Map();
+    this.catalogWatches = new Map();
+    this.readProfiles = readProfiles;
+    this.readAvatar = createDotsAvatarReader(localServer);
+    this.profileNames = new Map();
+    this.liveProfiles = new Map();
+    this.liveRoots = new Map();
+    this.rootIdentity = null;
+    this.catalogPages = new Map();
+    this.profileRefresh = null;
+    this.profileAttemptAt = 0;
+    this.on('turn', ({ thread }) => {
+      thread.chatRevision = dotsTaskRevision(thread.turns.at(-1));
+      this.saveHistoryWindow(thread.id);
+    });
+    this.on('disconnected', () => {
+      this.profileIdentity = null;
+      this.catalogPages.clear(); this.profileRefresh = null; this.profileAttemptAt = 0;
+      this.catalogWatches.clear();
+    });
+  }
+
+  get historyIdentity() { return this.profileIdentity; }
+
+  async connect() {
+    if (this.resetting) await this.resetting;
+    if (this.connecting) return this.connecting;
+    return super.connect();
+  }
+
+  async open() {
+    await super.open();
+    const socket = this.socket, identity = this.profileIdentity;
+    // Load confirmed display metadata before chat snapshots can publish a name
+    // or avatar. This reads local state, not the slow live profile request.
+    await this.refreshProfiles().catch(error => this.emit('profile-error', error));
+    if (!this.ready || this.socket !== socket || this.profileIdentity !== identity) throw new Error('点点连接已变化，请重新连接。');
+    this.emit('connected');
+  }
+
+  setProfileIdentity(identity) {
+    const key = JSON.stringify([identity.accountId, identity.userId]);
+    if (this.rootIdentity !== key) {
+      this.liveRoots.clear(); this.profileNames.clear(); this.liveProfiles.clear();
+    }
+    this.profileIdentity = identity; this.rootIdentity = key;
+  }
+
+  async openSocket() {
+    await this.localServer.connect();
+    const auth = await this.localServer.request('getAuthStatus', { includeToken: true, refreshToken: false });
+    if (!['chatgpt', 'chatgptAuthTokens'].includes(auth.authMethod) || !auth.authToken) {
+      throw new Error('读取 Dots 任务需要 Codex 内核已登录 ChatGPT。');
+    }
+    const identity = JSON.parse(Buffer.from(auth.authToken.split('.')[1], 'base64url').toString('utf8'));
+    const accountId = identity['https://api.openai.com/auth']?.chatgpt_account_id;
+    if (!accountId) throw new Error('Codex 内核没有可用于读取 Dots 任务的 ChatGPT 账号身份。');
+    this.setProfileIdentity({ accountId, userId: identity['https://api.openai.com/auth']?.chatgpt_user_id });
+    // Credentials stay in this process and go only to the fixed official host.
+    return new WebSocket(hostedAppServerUrl,
+      ['codex-app-server', 'codex-client.desktop', `openai-bearer.${auth.authToken}`], {
+        headers: { 'ChatGPT-Account-Id': accountId, 'X-OpenAI-Product-Sku': 'codex' },
+        handshakeTimeout: 15000,
+      });
+  }
+
+  request(method, params, transform = value => value) {
+    return this.nativeRequest(method, params, value => {
+      if (method === 'thread/read' || method === 'thread/resume') {
+        if (value.thread.threadSource !== 'aeon_child') throw new Error('该会话不是 Dots 委派任务。');
+        value.thread = { ...value.thread, hostId: 'durable', cwd: dotsTaskCwd(value.thread) };
+        if (method === 'thread/resume') value.cwd = value.thread.cwd;
+      }
+      return transform(value);
+    });
+  }
+
+  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) {
+        // 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.
+        this.ready = false;
+        const resetting = new Promise(resolve => socket.once('close', resolve)).finally(() => {
+          if (this.resetting === resetting) this.resetting = null;
+        });
+        this.resetting = resetting;
+        console.warn(JSON.stringify({ time: new Date().toISOString(), event: 'dots-connection-reset',
+          reason: error.code, method, threadId: params?.threadId }));
+        socket.terminate();
+      }
+      throw error;
+    });
+  }
+
+  watchCatalogTask(threadId) {
+    return this.watchExecution(threadId, 'aeon_child');
+  }
+
+  watchExecution(threadId, expectedSource) {
+    const current = this.catalogWatches.get(threadId);
+    if (current) return current;
+    // Hosted thread/list does not subscribe to task notifications. Resume only
+    // metadata, with no settings overrides or history window, to register a watch.
+    // A slow background watch does not prove the shared socket has stalled.
+    // Keep foreground history/streams alive; this read reports its own failure.
+    const work = super.request('thread/resume', { threadId, excludeTurns: true }).then(result => {
+      if (result.thread.threadSource !== expectedSource) throw new Error('执行订阅返回了不同来源的对话。');
+    }).catch(error => {
+      if (this.catalogWatches.get(threadId) === work) this.catalogWatches.delete(threadId);
+      throw error;
+    });
+    this.catalogWatches.set(threadId, work);
+    return work;
+  }
+
+  async latestTaskState(threadId, refresh = false) {
+    const record = this.threads.get(threadId);
+    const epoch = this.epoch, sequence = record?.sequence;
+    let turn;
+    if (!refresh && record && !record.needsReload && !record.hydrating && !record.historyTrimmed) {
+      turn = record.thread.turns.at(-1);
+    } else {
+      const page = await this.initialTurnsPage(threadId);
+      if (epoch !== this.epoch) throw new Error('云端连接已变化，请重新核对任务状态。');
+      const current = this.threads.get(threadId);
+      // Live events received during the metadata read outrank its older result.
+      turn = current && current.sequence !== sequence ? current.thread.turns.at(-1) : page.data[0];
+      if (current && !current.hydrating && dotsTaskRevision(current.thread.turns.at(-1)) !== dotsTaskRevision(turn)) {
+        current.needsReload = true;
+      }
+    }
+    return { chatRevision: dotsTaskRevision(turn), lastTurnStatus: turn?.status || null };
+  }
+
+  async timeline(threadId, pageOptions = {}, knownSync) {
+    const result = await super.timeline(threadId, { ...pageOptions, maxTurns: 1 }, knownSync);
+    result.thread.chatRevision = dotsTaskRevision(this.threads.get(threadId)?.thread.turns.at(-1));
+    await this.saveHistoryWindow(threadId, true);
+    return result;
+  }
+
+  async source(threadId, expected) {
+    let source = this.threadSources.get(threadId);
+    if (!source) {
+      await this.connect();
+      const { thread } = await this.nativeRequest('thread/read', { threadId, includeTurns: false });
+      source = thread.threadSource; this.threadSources.set(threadId, source);
+    }
+    if (!['aeon', 'aeon_child'].includes(source) || expected && source !== expected) throw new Error('该会话不是对应的 Dots 对话。');
+    return source;
+  }
+
+  notification(method, params) {
+    if (['thread/started', 'thread/archived', 'thread/unarchived', 'thread/deleted',
+      'thread/name/updated', 'thread/status/changed', 'thread/project/updated', 'turn/started', 'turn/completed'].includes(method)) {
+      this.catalogPages.clear();
+    }
+    if (this.threadSources.get(params.threadId) === 'aeon') this.serverRequests.notification(method, params);
+    if (params.thread?.threadSource) this.threadSources.set(params.thread.id, params.thread.threadSource);
+    this.emit('host-notification', { method, params });
+    if (this.threadSources.get(params.threadId || params.thread?.id) !== 'aeon') {
+      this.invalidateHistory(method, params);
+      super.notification(method, params);
+    }
+  }
+
+  async unsubscribeThread() {
+    // Page interest is local; the hosted watch/window last until socket disconnect.
+    // Do not turn page closure into thread/stop or another execution command.
+  }
+
+  keepThreadLoaded(_threadId, record) {
+    // Hosted watches last for the socket, independently of phone snapshot tokens.
+    return this.ready && Boolean(record && !record.readOnly);
+  }
+
+  isThreadObserved(threadId, record) { return this.keepThreadLoaded(threadId, record); }
+
+  async resumeTimeline(threadId, apply, options = {}) {
+    // The hosted protocol loads history separately. Register the resumed thread
+    // before requesting its page so notifications can update the hydrating record.
+    const scope = this.historyScope(threadId), head = options.reconcileObserved ? null : await this.restoreHistoryHead(threadId);
+    return this.request('thread/resume', { threadId, excludeTurns: true }, value => {
+      if (scope !== this.historyScope(threadId)) throw new Error('云端账号连接已变化，请重新读取历史。');
+      this.diskHeads.set(threadId, { head, updatedAt: value.thread.updatedAt, scope });
+      return apply({ ...value, initialTurnsPage: { data: [], nextCursor: null } });
+    });
+  }
+
+  async history(threadId, cursor, options = {}) {
+    await this.connect(); await this.source(threadId, 'aeon_child');
+    return super.history(threadId, cursor, options);
+  }
+
+  initialTurnsPage(threadId) {
+    return this.request('thread/turns/list', {
+      threadId, limit: 1, sortDirection: 'desc', itemsView: 'notLoaded',
+    });
+  }
+
+  async models() {
+    await this.connect();
+    const models = []; let cursor;
+    do {
+      const result = await this.request('model/list', { limit: 100, ...(cursor ? { cursor } : {}) });
+      models.push(...result.data); cursor = result.nextCursor;
+    } while (cursor);
+    // Hosted app-server has model/list but no local config/read.
+    return { models: models.filter(model => !model.hidden), enabledReasoningEfforts: null };
+  }
+
+  async readContext(threadId, refreshSettings = false) {
+    if (refreshSettings) {
+      await this.connect();
+      const previous = this.settingsNotifications.get(threadId);
+      // Hosted thread/read can report stored defaults even after a turn override.
+      // Resume without overrides reads the live settings, as Desktop does.
+      const settings = await this.request('thread/resume', { threadId, excludeTurns: true });
+      if (settings.model && this.settingsNotifications.get(threadId) === previous) {
+        this.contexts.set(threadId, { ...this.contexts.get(threadId), model: settings.model,
+          thinking: settings.reasoningEffort, serviceTier: settings.serviceTier ?? null });
+      }
+    }
+    return this.context(threadId);
+  }
+
+  async send(args) {
+    try {
+      await this.connect();
+      const record = this.threads.get(args.threadId);
+      if (!record || record.needsReload) await this.timeline(args.threadId);
+    } catch (error) { error.deliveryUnknown = false; throw error; }
+    return super.send(args);
+  }
+
+  async interrupt(threadId) {
+    await this.connect();
+    this.requireWritable(threadId);
+    const result = await this.request('thread/stop', { threadId });
+    const record = this.threads.get(threadId);
+    if (record) record.needsReload = true;
+    return result;
+  }
+
+  async taskCatalog(archived = false, refresh = false) {
+    await this.connect();
+    const cached = this.catalogPages.get(archived);
+    if (cached?.work) return cached.work;
+    if (!refresh && cached?.tasks && Date.now() - cached.at < 30000) return cached.tasks;
+    const identity = this.profileIdentity;
+    const entry = {};
+    const work = this.readTaskCatalog(archived).then(tasks => {
+      if (identity !== this.profileIdentity) throw new Error('点点账号已变化，请重新读取目录。');
+      entry.tasks = tasks; entry.at = Date.now();
+      return tasks;
+    }).finally(() => { entry.work = null; });
+    entry.work = work;
+    this.catalogPages.set(archived, entry);
+    return work;
+  }
+
+  async readTaskCatalog(archived) {
+    const tasks = [];
+    let cursor;
+    do {
+      const page = await this.request('thread/list', {
+        // Hosted recency_at can omit existing delegated threads with no cursor.
+        // Fetch by updated_at; the merged catalog still uses each thread's recency.
+        limit: 100, sortKey: 'updated_at', sortDirection: 'desc', archived,
+        ...(cursor ? { cursor } : {}),
+      });
+      for (const thread of page.data) this.threadSources.set(thread.id, thread.threadSource);
+      tasks.push(...page.data.filter(thread => ['aeon', 'aeon_child'].includes(thread.threadSource))
+        .map(thread => ({ ...thread, cwd: dotsTaskCwd(thread) })));
+      cursor = page.nextCursor;
+    } while (cursor);
+    return tasks;
+  }
+
+  async catalog(archived = false, refresh = false) {
+    const tasks = await this.taskCatalog(archived, refresh);
+    await this.refreshProfiles();
+    this.refreshLiveProfiles();
+    // Subscription failure must not discard an authoritative catalog snapshot.
+    // Watches continue independently; failed watches are retried by the next catalog read.
+    if (!archived) for (const thread of tasks.filter(thread => thread.threadSource === 'aeon_child')) {
+      void this.watchCatalogTask(thread.id).catch(error => {
+        console.error('Dots 任务订阅失败：', thread.id, error.message);
+      });
+    }
+    return [...tasks.filter(thread => thread.threadSource === 'aeon_child'),
+      ...(archived ? [] : this.liveRoots.values())].map(thread => thread.threadSource === 'aeon' ? { ...thread,
+      name: this.profileName(thread.id), avatar: this.profileAvatar(thread.id), color: this.profileColor(thread.id) } : thread);
+  }
+
+  async tasks(archived = false) { return (await this.taskCatalog(archived)).filter(thread => thread.threadSource === 'aeon_child'); }
+
+  async refreshProfiles() {
+    const identity = this.profileIdentity;
+    const names = identity ? await this.readProfiles(identity) : new Map();
+    if (identity !== this.profileIdentity) throw new Error('点点账号已变化，请重新读取目录。');
+    const byProfile = new Map([...this.liveProfiles.values()].map(profile => [profile.profileId, profile]));
+    for (const [id, profile] of names) {
+      if (byProfile.has(profile.profileId)) names.set(id, byProfile.get(profile.profileId));
+    }
+    for (const [id, profile] of this.liveProfiles) names.set(id, byProfile.get(profile.profileId));
+    for (const [id, profile] of names) {
+      const previous = this.profileNames.get(id);
+      if (previous?.avatar && previous.avatarFileId === profile.avatarFileId) profile.avatar = previous.avatar;
+    }
+    if (identity === this.profileIdentity) this.profileNames = names;
+  }
+
+  refreshLiveProfiles() {
+    if (this.profileRefresh || Date.now() - this.profileAttemptAt < 60000) return;
+    const identity = this.profileIdentity;
+    this.profileAttemptAt = Date.now();
+    const snapshot = () => JSON.stringify([[...this.profileNames], [...this.liveRoots]]);
+    let published = snapshot();
+    const publish = () => {
+      const next = snapshot();
+      if (identity !== this.profileIdentity || published === next) return;
+      published = next;
+      this.emit('notification', { method: 'thread/name/updated', params: {} });
+    };
+    const work = (async () => {
+      try {
+        const { profiles: live, rootThreadIds } = await readDotsCatalog(this.localServer, identity);
+        if (identity !== this.profileIdentity) return;
+        const roots = new Map();
+        for (const threadId of rootThreadIds) {
+          const { thread } = await this.nativeRequest('thread/read', { threadId, includeTurns: false });
+          if (identity !== this.profileIdentity) return;
+          if (thread.id !== threadId || thread.threadSource !== 'aeon') throw new Error('点点目录返回了非主线程。');
+          roots.set(threadId, { ...thread, cwd: dotsTaskCwd(thread) });
+        }
+        if (identity !== this.profileIdentity) return;
+        this.liveProfiles = live;
+        this.liveRoots = roots;
+        for (const id of roots.keys()) this.threadSources.set(id, 'aeon');
+        await this.refreshProfiles();
+        publish();
+      } catch (error) {
+        if (identity !== this.profileIdentity) return;
+        this.emit('profile-error', error);
+      }
+      await Promise.all([...new Set(this.profileNames.values())].map(async profile => {
+        try { profile.avatar = await this.readAvatar(profile, identity); }
+        catch (error) { this.emit('profile-error', error); }
+      }));
+      publish();
+      if (identity === this.profileIdentity && this.liveProfiles.size) await this.readProfiles.save?.(identity, this.liveProfiles);
+    })().catch(error => this.emit('profile-error', error))
+      .finally(() => { if (this.profileRefresh === work) this.profileRefresh = null; });
+    this.profileRefresh = work;
+  }
+
+  profileName(threadId) { return this.profileNames.get(threadId)?.name || 'Dots'; }
+  profileAvatar(threadId) { return this.profileNames.get(threadId)?.avatar || ''; }
+  profileColor(threadId) { return this.profileNames.get(threadId)?.color || ''; }
+}
+
+function dotsTaskCwd(thread) {
+  return thread.environments?.[0]?.cwd || thread.cwd;
+}
+
+export async function readDotsTasks(localAppServerUrl) {
+  const local = new SharedAppServer(localAppServerUrl);
+  const cloud = new DotsAppServer(local);
+  try {
+    const tasks = await cloud.tasks();
+    const summaries = await Promise.all(tasks.map(async thread => {
+      const turns = await cloud.request('thread/turns/list', {
+        threadId: thread.id, limit: 1, sortDirection: 'desc', itemsView: 'notLoaded',
+      });
+      const latest = turns.data[0];
+      return {
+        id: thread.id, hostId: 'durable', threadSource: thread.threadSource,
+        title: thread.name || thread.preview || '', model: thread.model,
+        cwd: thread.environments?.[0]?.cwd || thread.cwd,
+        environments: thread.environments, createdAt: thread.createdAt, updatedAt: thread.updatedAt,
+        recencyAt: thread.recencyAt ?? thread.updatedAt, status: thread.status?.type,
+        latestTurn: latest ? { id: latest.id, status: latest.status,
+          startedAt: latest.startedAt, completedAt: latest.completedAt, error: latest.error } : null,
+      };
+    }));
+    return { source: 'codex-cloud-app-server', readAt: new Date().toISOString(), tasks: summaries };
+  } finally {
+    cloud.close();
+    local.close();
+  }
+}

package/dist/src/file-transfer-range.mjs

@@ -0,0 +1,22 @@
+export const FILE_READ_LIMIT = 20 * 1024 * 1024;
+export const FILE_PART_BYTES = 256 * 1024;
+export class FileRangeError extends Error {
+  constructor(statusCode, message) { super(message); this.statusCode = statusCode; }
+}
+
+export function fileRange(query, size, revision) {
+  const offset = Number(query.get('offset') || 0);
+  const length = Number(query.get('length') || FILE_PART_BYTES);
+  if (!Number.isSafeInteger(offset) || offset < 0 || offset >= size ||
+      !Number.isSafeInteger(length) || length < 1 || length > FILE_PART_BYTES) {
+    throw new FileRangeError(400, '无效的文件读取范围。');
+  }
+  if ((offset && !query.get('revision')) || (query.has('revision') && query.get('revision') !== revision)) {
+    throw new FileRangeError(409, '文件已变化，请重新打开。');
+  }
+  return { offset, length: Math.min(length, size - offset) };
+}
+
+export function fileRevision(stat) {
+  return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}`;
+}