@walkhi/code-relax 0.1.0-beta.4 → 0.1.0-beta.41

package/dist/src/dots-message-images.mjs

@@ -0,0 +1,319 @@
+import crypto from 'node:crypto';
+import http2 from 'node:http2';
+import sharp from 'sharp';
+import { fileRange } from './file-transfer-range.mjs';
+
+const fileId = value => typeof value === 'string' && /^[A-Za-z0-9_-]{1,256}$/.test(value);
+const formats = { jpeg: 'image/jpeg', png: 'image/png', webp: 'image/webp', gif: 'image/gif', bmp: 'image/bmp' };
+
+// Official API reads use HTTP/2, as do the existing Dots history adapters.
+function officialFetch(input, options = {}) {
+  const url = new URL(input);
+  if (url.origin !== 'https://chatgpt.com') return fetch(input, options);
+  return new Promise((resolve, reject) => {
+    const session = http2.connect(url.origin);
+    let request;
+    const close = () => { clearTimeout(connectTimer); request?.destroy(); session.destroy(); options.signal?.removeEventListener('abort', abort); };
+    const abort = () => { reject(options.signal.reason || new Error('点点附件读取已取消。')); close(); };
+    const connectTimer = setTimeout(() => { reject(new Error('点点附件连接超时。')); close(); }, 30000);
+    session.once('connect', () => clearTimeout(connectTimer));
+    session.on('error', error => { reject(error); close(); });
+    request = session.request({ ':method': 'GET', ':path': url.pathname + url.search,
+      'user-agent': 'Code-Relax/0.1.0', ...options.headers });
+    request.on('error', error => { reject(error); close(); });
+    request.once('close', () => { reject(new Error('点点附件连接已断开。')); close(); });
+    options.signal?.addEventListener('abort', abort, { once: true });
+    if (options.signal?.aborted) { abort(); return; }
+    request.once('response', values => {
+      const status = values[':status'];
+      const headers = new Headers(Object.entries(values).filter(([key]) => !key.startsWith(':')));
+      const body = { cancel: close, async *[Symbol.asyncIterator]() {
+        try { for await (const chunk of request) yield chunk; } finally { close(); }
+      } };
+      resolve({ status, ok: status >= 200 && status < 300, headers, body, async json() {
+        const chunks = []; let size = 0;
+        for await (const chunk of body) {
+          size += chunk.length;
+          if (size > 1024 * 1024) throw new Error('点点附件信息响应过大。');
+          chunks.push(chunk);
+        }
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+      } });
+    });
+    request.end();
+  });
+}
+
+export function dotsImageReference(value) {
+  let source;
+  if (value?.chatFile != null) {
+    const { conversationId, messageId, sandboxPath } = value.chatFile;
+    if (!fileId(conversationId) || value.roomId || value.libraryFileId) return null;
+    if (sandboxPath != null) {
+      if (!fileId(messageId) || typeof sandboxPath !== 'string' || !sandboxPath.startsWith('/')
+        || sandboxPath.length > 2048 || /[\x00-\x1f]/.test(sandboxPath)) return null;
+      source = { chatFile: { conversationId, messageId, sandboxPath } };
+    } else if (fileId(value.fileId)) source = { fileId: value.fileId, chatFile: { conversationId } };
+  } else if ((fileId(value?.fileId) || fileId(value?.libraryFileId)) && (value.libraryFileId == null || fileId(value.libraryFileId))) {
+    if (value.roomId != null && !fileId(value.roomId)) return null;
+    source = { ...(fileId(value.fileId) ? { fileId: value.fileId } : {}), ...(value.libraryFileId ? { libraryFileId: value.libraryFileId } : {}),
+      ...(value.roomId ? { roomId: value.roomId } : {}) };
+  } else if (typeof value?.url === 'string' && value.url.length <= 2048) {
+    try {
+      const url = new URL(value.url);
+      if (url.protocol === 'https:' && !url.username && !url.password && !url.port && !url.hash
+        && url.hostname.endsWith('.oaiusercontent.com') && url.pathname.startsWith('/files/')) source = { url: url.href };
+    } catch { /* Not an official image reference. */ }
+  }
+  if (!source) return null;
+  return { ...source, type: value.type === 'file' ? 'file' : 'image',
+    mimeType: /^[A-Za-z0-9.+-]+\/[A-Za-z0-9.+-]+$/.test(value.mimeType || '') ? value.mimeType : '',
+    name: typeof value.name === 'string' ? value.name.slice(0, 128) : value.type === 'file' ? 'Library 附件' : '图片' };
+}
+
+// Register attachment references projected from authoritative messages. Fetch bytes on demand.
+// Phone caches keep opaque capabilities. Explicit copy-link requests return official URLs.
+export class DotsMessageImages {
+  constructor({ localServer, identity, cache, capabilityKey, maxEntries, maxBytes, fetchImpl = officialFetch }) {
+    Object.assign(this, { localServer, identity, cache, capabilityKey, maxEntries, maxBytes, fetchImpl });
+  }
+
+  imageId(reference, identity) {
+    const url = reference.url ? new URL(reference.url) : null;
+    return crypto.createHmac('sha256', this.capabilityKey)
+      .update(JSON.stringify(['dots-image', identity.accountId, identity.userId,
+        ...(reference.chatFile ? ['chat-file', reference.fileId || '', reference.chatFile]
+          : url ? ['url', url.origin + url.pathname] : [reference.fileId, reference.libraryFileId || '', ...(reference.roomId ? [reference.roomId] : [])])]))
+      .digest('hex');
+  }
+
+  remember(value, identity = this.identity()) {
+    const reference = dotsImageReference(value);
+    if (!reference || !identity?.accountId) return null;
+    const id = this.imageId(reference, identity);
+    const cached = this.cache.get(id);
+    if (!cached || reference.url && reference.url !== cached.dotsFile?.url) {
+      const iv = crypto.randomBytes(12), cipher = crypto.createCipheriv('aes-256-gcm', this.capabilityKey, iv);
+      const bytes = Buffer.concat([cipher.update(JSON.stringify({ reference, identity })), cipher.final()]);
+      const recoveryToken = Buffer.concat([iv, cipher.getAuthTag(), bytes]).toString('base64url');
+      if (!cached) while (this.cache.size >= this.maxEntries) this.cache.delete(this.cache.keys().next().value);
+      const image = cached || {};
+      Object.assign(image, { id, dotsFile: reference, identity: { ...identity }, recoveryToken,
+        name: reference.name, mimeType: image.mimeType || reference.mimeType });
+      this.cache.set(id, image);
+    }
+    return this.cache.get(id);
+  }
+
+  restore(id, token) {
+    if (!token || token.length > 4096) return null;
+    try {
+      const bytes = Buffer.from(token, 'base64url');
+      if (bytes.length < 29) return null;
+      const decipher = crypto.createDecipheriv('aes-256-gcm', this.capabilityKey, bytes.subarray(0, 12));
+      decipher.setAuthTag(bytes.subarray(12, 28));
+      const { reference, identity } = JSON.parse(Buffer.concat([decipher.update(bytes.subarray(28)), decipher.final()]));
+      if (!dotsImageReference(reference) || !identity?.accountId || this.imageId(reference, identity) !== id) return null;
+      return this.remember(reference, identity);
+    } catch { return null; }
+  }
+
+  async authorization(identity) {
+    const auth = await this.localServer.request('getAuthStatus', { includeToken: true, refreshToken: false });
+    if (!['chatgpt', 'chatgptAuthTokens'].includes(auth.authMethod) || !auth.authToken) {
+      throw new Error('点点附件需要 Codex 内核已登录 ChatGPT。');
+    }
+    const principal = auth.authToken && JSON.parse(Buffer.from(auth.authToken.split('.')[1], 'base64url'))['https://api.openai.com/auth'];
+    if (!identity?.accountId || principal?.chatgpt_account_id !== identity.accountId || principal.chatgpt_user_id !== identity.userId) {
+      throw new Error('点点附件的账号已变化，请重新连接对话。');
+    }
+    return { Authorization: `Bearer ${auth.authToken}`, 'ChatGPT-Account-Id': identity.accountId };
+  }
+
+  async json(route, headers) {
+    const result = await this.fetchImpl(`https://chatgpt.com/backend-api${route}`, {
+      headers: { accept: 'application/json', ...headers },
+      redirect: 'error', signal: AbortSignal.timeout(30000),
+    });
+    if (!result.ok) { await result.body?.cancel(); throw Object.assign(new Error(`点点附件信息读取失败（${result.status}）。`), { status: result.status }); }
+    const body = await result.json();
+    if (body.status === 'error') throw new Error(`点点图片文件请求失败（${body.error_code || '未知错误'}）。`);
+    return body;
+  }
+
+  libraryId(image) {
+    return image.dotsFile.libraryFileId || (image.dotsFile.fileId?.startsWith('libfile_') ? image.dotsFile.fileId : '');
+  }
+
+  async metadata(image, headers) {
+    headers ||= await this.authorization(image.identity);
+    if (image.size) return image;
+    if (!image.metadataLoading) {
+      image.metadataLoading = (async () => {
+        const library = this.libraryId(image);
+        if (!library) throw new Error('点点附件缺少 Library 文件身份。');
+        const route = `/files/library/files/${encodeURIComponent(library)}`;
+        let value;
+        try { value = await this.json(route, headers); }
+        catch (error) {
+          // Desktop 26.930.4958.0 explicitly reads /node after 403/404.
+          if (![403, 404].includes(error.status)) throw error;
+          value = await this.json(route + '/node', headers);
+        }
+        const name = value.file_name || value.name, size = value.file_size_bytes, mimeType = value.mime_type;
+        if (typeof name !== 'string' || !name || !Number.isSafeInteger(size) || size < 1
+          || typeof mimeType !== 'string' || !/^[A-Za-z0-9.+-]+\/[A-Za-z0-9.+-]+$/.test(mimeType)) {
+          throw new Error('点点附件文件信息不完整。');
+        }
+        Object.assign(image, { name: name.replace(/[\\/\x00-\x1f]/g, '_').slice(0, 128), size, mimeType });
+      })().finally(() => { image.metadataLoading = null; });
+    }
+    await image.metadataLoading;
+    return image;
+  }
+
+  async prepareTimeline(thread) {
+    const files = new Map();
+    for (const turn of thread?.turns || []) for (const item of turn.items || []) {
+      for (const attachment of [...(item.attachments || []), ...(Array.isArray(item.content) ? item.content : [])]) {
+        if (!['file', 'image', 'input_image'].includes(attachment?.type)) continue;
+        const image = this.remember(attachment);
+        if (image && !image.size && this.libraryId(image)) files.set(image.id, image);
+      }
+    }
+    if (!files.size) return false;
+    let headers;
+    try { headers = await this.authorization(files.values().next().value.identity); }
+    catch (error) { console.error(`读取点点附件信息失败：${error.message}`); return false; }
+    const results = await Promise.allSettled([...files.values()].map(image => this.metadata(image, headers)));
+    for (const result of results) if (result.status === 'rejected') console.error(`读取点点附件信息失败：${result.reason.message}`);
+    return results.some(result => result.status === 'fulfilled');
+  }
+
+  async contentUrl(image, headers, download = false) {
+    const file = image.dotsFile;
+    let url;
+    if (file.url) url = new URL(file.url);
+    else {
+      const library = this.libraryId(image);
+      const chat = file.chatFile;
+      const chatRoute = chat && (chat.sandboxPath
+        ? `/conversation/${encodeURIComponent(chat.conversationId)}/interpreter/download?${new URLSearchParams({
+          message_id: chat.messageId, sandbox_path: chat.sandboxPath, ...(download ? { download_intent: 'true' } : {}) })}`
+        : `/conversation/${encodeURIComponent(chat.conversationId)}/attachment/${encodeURIComponent(file.fileId)}/download`);
+      const result = await this.json(chatRoute || (file.roomId ? `/messaging/rooms/${encodeURIComponent(file.roomId)}/files/${encodeURIComponent(file.fileId)}`
+        : library ? `/files/library/files/${encodeURIComponent(library)}/${download ? 'download_url' : 'content_url'}`
+        : `/files/download/${encodeURIComponent(file.fileId)}?download_intent=${download}&inline=${!download}`), headers);
+      url = new URL(result.download_url || result.content_url, 'https://chatgpt.com');
+      const redirected = /^\/api\/library\/files\/([^/]+)\/(download|content)$/.exec(url.pathname);
+      if (url.origin === 'https://chatgpt.com' && redirected) {
+        url.pathname = `/backend-api/files/library/files/${redirected[1]}/${redirected[2]}_redirect`;
+      } else if (url.origin === 'https://chatgpt.com' && /^\/files\/library\/files\/[^/]+\/(download|content)_redirect$/.test(url.pathname)) {
+        url.pathname = '/backend-api' + url.pathname;
+      }
+    }
+    const authenticated = url.origin === 'https://chatgpt.com' && url.pathname.startsWith('/backend-api/');
+    if (url.protocol !== 'https:' || url.username || url.password || url.port
+      || !(authenticated || url.hostname.endsWith('.oaiusercontent.com'))) throw new Error('点点附件下载地址无效。');
+    return url;
+  }
+
+  async fileLink(image) {
+    const headers = await this.authorization(image.identity);
+    const library = this.libraryId(image);
+    if (library) {
+      // Desktop uses this official redirect route for Library downloads. Copy
+      // the stable entry point; let opening it resolve the current signed URL.
+      return `https://chatgpt.com/backend-api/files/library/files/${encodeURIComponent(library)}/download_redirect`;
+    }
+    let url = await this.contentUrl(image, headers, true);
+    // Library download_url can be an Estuary URL served directly by ChatGPT,
+    // not a redirect to oaiusercontent. Keep the official URL for browser login.
+    if (url.origin === 'https://chatgpt.com' && url.pathname === '/backend-api/estuary/content') return url.href;
+    if (url.origin === 'https://chatgpt.com') {
+      const response = await this.fetchImpl(url, { headers, redirect: 'manual', signal: AbortSignal.timeout(30000) });
+      try {
+        if (![301, 302, 303, 307, 308].includes(response.status) || !response.headers.get('location')) {
+          throw new Error('点点附件未返回可复制的网络链接。');
+        }
+        url = new URL(response.headers.get('location'), url);
+      } finally { await response.body?.cancel(); }
+    }
+    if (url.protocol !== 'https:' || url.username || url.password || url.port
+      || !url.hostname.endsWith('.oaiusercontent.com')) throw new Error('点点附件网络链接无效。');
+    return url.href;
+  }
+
+  async readPart(image, query) {
+    if (image.buffer || !this.libraryId(image)) {
+      // Inline file IDs and signed image references use their existing reader.
+      await this.load(image);
+      const size = image.buffer.length, revision = image.id;
+      const { offset, length } = fileRange(query, size, revision);
+      return { name: image.name, size, offset, revision, mimeType: image.mimeType, bytes: image.buffer.subarray(offset, offset + length) };
+    }
+    const headers = await this.authorization(image.identity);
+    await this.metadata(image, headers);
+    if (image.size > this.maxBytes) throw new Error('点点附件超过 20 MiB 下载上限。');
+    const revision = image.id;
+    const { offset, length } = fileRange(query, image.size, revision);
+    if (!offset || !image.downloadUrl) image.downloadUrl = await this.contentUrl(image, headers, true);
+    const url = image.downloadUrl;
+    const response = await this.fetchImpl(url, { redirect: 'error',
+      headers: { ...(url.origin === 'https://chatgpt.com' ? headers : {}), Range: `bytes=${offset}-${offset + length - 1}` } });
+    try {
+      if (response.status !== 206 || response.headers.get('content-range') !== `bytes ${offset}-${offset + length - 1}/${image.size}`) {
+        throw new Error(`点点附件分片响应无效（HTTP ${response.status}）。`);
+      }
+      const chunks = []; let size = 0;
+      for await (const chunk of response.body) {
+        size += chunk.length;
+        if (size > length) throw new Error('点点附件分片内容超出范围。');
+        chunks.push(chunk);
+      }
+      if (size !== length) throw new Error('点点附件分片内容不完整。');
+      return { name: image.name, size: image.size, offset, revision, mimeType: image.mimeType, bytes: Buffer.concat(chunks) };
+    } finally { await response.body?.cancel(); }
+  }
+
+  async load(image) {
+    const headers = await this.authorization(image.identity);
+    if (image.buffer) return image;
+    if (!image.loading) {
+      image.loading = (async () => {
+        const file = image.dotsFile;
+        const url = await this.contentUrl(image, headers);
+        const authenticated = url.origin === 'https://chatgpt.com' && url.pathname.startsWith('/backend-api/');
+        if (url.protocol !== 'https:' || url.username || url.password || url.port
+          || !(authenticated || url.hostname.endsWith('.oaiusercontent.com'))) throw new Error('点点图片下载地址无效。');
+        const response = await this.fetchImpl(url, { redirect: 'error',
+          ...(authenticated ? { headers } : {}) });
+        try {
+          if (!response.ok) throw new Error(`点点图片下载失败（${response.status}）。`);
+          if (Number(response.headers.get('content-length')) > this.maxBytes) throw new Error('点点图片超过 20 MiB 下载上限。');
+          const chunks = []; let size = 0;
+          for await (const chunk of response.body) {
+            size += chunk.length;
+            if (size > this.maxBytes) throw new Error('点点图片超过 20 MiB 下载上限。');
+            chunks.push(chunk);
+          }
+          const buffer = Buffer.concat(chunks);
+          const mimeType = response.headers.get('content-type')?.split(';')[0] || 'application/octet-stream';
+          if (file.type !== 'file') {
+            const metadata = await sharp(buffer, { limitInputPixels: 40_000_000 }).metadata();
+            if (!formats[metadata.format]) throw new Error('点点附件不是可显示的图片。');
+            Object.assign(image, { buffer, mimeType: formats[metadata.format] });
+          } else Object.assign(image, { buffer, mimeType });
+          const disposition = response.headers.get('content-disposition') || '';
+          const encoded = /filename\*=UTF-8''([^;]+)/i.exec(disposition)?.[1];
+          let name = /filename="([^"]+)"/i.exec(disposition)?.[1];
+          try { if (encoded) name = decodeURIComponent(encoded); } catch {}
+          if (name) image.name = name.replace(/[\\/\x00-\x1f]/g, '_').slice(0, 128);
+        } finally { if (!response.bodyUsed) await response.body?.cancel(); }
+      })().finally(() => { image.loading = null; });
+    }
+    await image.loading;
+    return image;
+  }
+
+}

package/dist/src/dots-profile.mjs

@@ -0,0 +1,77 @@
+import http2 from 'node:http2';
+
+const colors = new Set(['black', 'blue', 'green', 'orange', 'pink', 'purple', 'red', 'yellow']);
+export function dotsProfile(profile) {
+  const name = typeof profile?.display_name === 'string' ? profile.display_name.trim() : '';
+  const pointer = profile?.avatar_manifest?.snapshot?.asset_pointer;
+  return { profileId: profile.id, activeRootThreadId: profile.active_root_thread_id || '',
+    messagingRoomId: typeof profile.messaging_room_id === 'string' ? profile.messaging_room_id : '',
+    name: name && !['O', 'o', 'Orbit', 'orbit', 'dot'].includes(name) ? name : 'Dots',
+    avatarFileId: typeof pointer === 'string' && /^sediment:\/\/file_[a-f0-9]+$/.test(pointer)
+      ? pointer.slice('sediment://'.length) : '', color: colors.has(profile.color) ? profile.color : '' };
+}
+
+// Desktop 26.930.7945.0 discovers roots through /tbo and its thread attachments.
+// Hosted thread/list can omit every aeon root while thread/read still resolves it.
+export async function readDotsCatalog(localServer, identity) {
+  const auth = await localServer.request('getAuthStatus', { includeToken: true, refreshToken: false });
+  const principal = JSON.parse(Buffer.from(auth.authToken.split('.')[1], 'base64url'))['https://api.openai.com/auth'];
+  if (!identity || principal?.chatgpt_account_id !== identity.accountId || principal.chatgpt_user_id !== identity.userId) {
+    throw new Error('点点账号已变化，请重新连接。');
+  }
+  const session = http2.connect('https://chatgpt.com');
+  session.on('error', () => {}); // Individual requests report the transport error.
+  try {
+    const get = route => new Promise((resolve, reject) => {
+      const request = session.request({ ':method': 'GET', ':path': `/backend-api${route}`,
+        authorization: `Bearer ${auth.authToken}`, 'chatgpt-account-id': identity.accountId,
+        'user-agent': 'Code-Relax/0.1.0', accept: 'application/json' });
+      let status, body = '', size = 0;
+      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));
+      request.on('end', () => {
+        try {
+          if (status !== 200) throw new Error(`读取点点目录失败（HTTP ${status}）。`);
+          resolve(JSON.parse(body));
+        } catch (error) { reject(error); }
+      });
+      request.end();
+    });
+    const profiles = new Map(), rootThreadIds = new Set();
+    let cursor;
+    do {
+      const query = new URLSearchParams({ limit: '25', ...(cursor ? { cursor } : {}) });
+      const page = await get(`/tbo?${query}`);
+      for (const value of page.items) {
+        if (typeof value.id !== 'string' || !value.id
+          || value.active_root_thread_id != null && typeof value.active_root_thread_id !== 'string') {
+          throw new Error('点点资料缺少有效身份。');
+        }
+        const profile = dotsProfile(value);
+        let threadCursor;
+        do {
+          const threadQuery = new URLSearchParams({ limit: '100', include_hidden: 'true',
+            ...(threadCursor ? { cursor: threadCursor } : {}) });
+          const attachments = await get(`/tbo/${encodeURIComponent(value.id)}/threads?${threadQuery}`);
+          for (const attachment of attachments.items) {
+            const id = attachment.thread_id;
+            profiles.set(id, profile);
+            if (value.status !== 'deleting' && (!profile.activeRootThreadId || profile.activeRootThreadId === id)
+              && (attachment.parent_thread_id === null || attachment.parent_thread_id === id)) rootThreadIds.add(id);
+          }
+          threadCursor = attachments.cursor;
+        } while (threadCursor);
+      }
+      cursor = page.cursor;
+    } while (cursor);
+    return { profiles, rootThreadIds };
+  } finally { session.destroy(); }
+}

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

@@ -0,0 +1,94 @@
+import { EventEmitter } from 'node:events';
+
+// Desktop's room-live SSE owns the watch; Celsius carries its revisioned state.
+export class DotsRoomActivity extends EventEmitter {
+  constructor(server) {
+    super(); this.server = server; this.watches = new Map();
+    this.message = (topic, event) => {
+      if (event?.type !== 'calpico-room-live') return;
+      for (const watch of this.watches.values()) {
+        const value = event.payload;
+        if (watch.topic !== topic || watch.roomId !== value?.room_id || value.version !== 1) continue;
+        if (!watch.subscriptionId) {
+          if (watch.pending.size >= 4) watch.pending.delete(watch.pending.keys().next().value);
+          const old = watch.pending.get(value.subscription_id);
+          if (!old || value.revision > old.revision) watch.pending.set(value.subscription_id, value);
+        } else this.apply(watch, value);
+      }
+    };
+    server.rooms.on('message', this.message);
+  }
+  acquire(threadId, listener) {
+    let watch = this.watches.get(threadId);
+    if (!watch) {
+      watch = { threadId, listeners: new Set(), activity: null, generation: 0, attempts: 0 };
+      this.watches.set(threadId, watch);
+    }
+    watch.listeners.add(listener); listener({ threadId, activity: watch.activity });
+    if (!watch.controller && !watch.timer) void this.start(watch);
+    let released = false;
+    return () => {
+      if (released) return; released = true; watch.listeners.delete(listener);
+      if (!watch.listeners.size) { this.watches.delete(threadId); this.stop(watch); }
+    };
+  }
+  publish(watch, activity) {
+    if (JSON.stringify(watch.activity) === JSON.stringify(activity)) return;
+    watch.activity = activity;
+    for (const listener of watch.listeners) listener({ threadId: watch.threadId, activity });
+  }
+  apply(watch, value) {
+    if (value.subscription_id !== watch.subscriptionId || !Number.isSafeInteger(value.revision) || value.revision <= watch.revision) return;
+    watch.revision = value.revision;
+    if (value.type === 'calpico-room-live-error') {
+      this.fail(watch, new Error('点点活动暂不可用。'), value.code === 'temporarily_unavailable'); return;
+    }
+    if (value.type !== 'calpico-room-live-state' || !Array.isArray(value.threads)) return;
+    const current = value.threads[0];
+    if (current?.stream_state !== 'attached' || current.turn_status !== 'in_progress') { this.publish(watch, null); return; }
+    watch.attempts = 0;
+    const label = current.activity_status?.status_label;
+    this.publish(watch, { kind: 'thinking', label: typeof label === 'string' && label.trim() ? label : '正在思考…' });
+  }
+  async start(watch) {
+    const generation = ++watch.generation, controller = new AbortController();
+    watch.controller = controller; watch.pending = new Map(); watch.subscriptionId = null; watch.revision = -1;
+    const current = () => this.watches.get(watch.threadId) === watch && generation === watch.generation && !controller.signal.aborted;
+    try {
+      await this.server.connect();
+      const room = this.server.bindings.get(watch.threadId) || await this.server.room(watch.threadId);
+      if (!current()) return;
+      watch.roomId = room.id; watch.topic = `calpico-room-live:${room.id}`;
+      await this.server.rooms.subscribe(watch.topic);
+      if (!current()) { if (!this.watches.has(watch.threadId)) await this.server.rooms.unsubscribe(watch.topic); return; }
+      await this.server.rooms.request(`/messaging/rooms/${encodeURIComponent(room.id)}/live`, {
+        method: 'POST', signal: controller.signal, onEvent: value => {
+          if (!current()) return;
+          if (value?.type !== 'calpico-room-live-ready' || value.version !== 1 || value.room_id !== room.id
+            || typeof value.subscription_id !== 'string' || watch.subscriptionId && watch.subscriptionId !== value.subscription_id) {
+            throw new Error('点点活动订阅身份无效。');
+          }
+          watch.subscriptionId = value.subscription_id;
+          const pending = watch.pending.get(value.subscription_id); watch.pending.clear();
+          if (pending) this.apply(watch, pending);
+        },
+      });
+      if (current()) this.fail(watch, new Error('点点活动连接已结束。'), true);
+    } catch (error) { if (current()) this.fail(watch, error, ![401, 403, 404].includes(error.status)); }
+  }
+  fail(watch, error, retry) {
+    this.stop(watch); this.emit('unavailable', error);
+    if (retry && watch.listeners.size && this.server.ready && watch.attempts < 5) {
+      watch.timer = setTimeout(() => { watch.timer = null; void this.start(watch); }, Math.min(30000, 1000 * 2 ** watch.attempts++));
+      watch.timer.unref();
+    }
+  }
+  stop(watch) {
+    watch.generation++; clearTimeout(watch.timer); watch.timer = null;
+    watch.controller?.abort(); watch.controller = null; watch.pending?.clear(); this.publish(watch, null);
+    // The SSE cancellation ends the server watch. The shared topic remains
+    // subscribed while this account socket lives, avoiding unsubscribe races.
+  }
+  close() { for (const watch of this.watches.values()) this.stop(watch); this.watches.clear(); }
+  dispose() { this.close(); this.server.rooms.off('message', this.message); }
+}

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

@@ -0,0 +1,135 @@
+import http2 from 'node:http2';
+import { CelsiusClient } from './celsius-client.mjs';
+
+const topic = 'calpico-chatgpt-messaging';
+const identityKey = identity => JSON.stringify([identity?.accountId, identity?.userId]);
+
+// Desktop 26.1002.7124.0: the DM API and Celsius share the kernel account,
+// but are independent of the hosted execution socket. Never replay a POST.
+export class DotsRoomClient extends CelsiusClient {
+  constructor(transport) {
+    super({ topics: [topic] }); this.transport = transport;
+    this.getConnection = () => this.request('/celsius/ws/user');
+    this.controllers = new Set(); this.routes = new Map();
+  }
+
+  async authorization() {
+    const identity = this.transport.profileIdentity, generation = this.generation;
+    const auth = await this.transport.localServer.request('getAuthStatus', { includeToken: true, refreshToken: false });
+    const principal = auth.authToken && JSON.parse(Buffer.from(auth.authToken.split('.')[1], 'base64url'))['https://api.openai.com/auth'];
+    if (!identity?.accountId || principal?.chatgpt_account_id !== identity.accountId
+      || principal.chatgpt_user_id !== identity.userId || generation !== this.generation
+      || identityKey(identity) !== identityKey(this.transport.profileIdentity)) throw new Error('点点账号已变化，请重新连接。');
+    return { identity, generation, headers: { authorization: `Bearer ${auth.authToken}`,
+      'chatgpt-account-id': identity.accountId, 'user-agent': 'Code-Relax/0.1.0' } };
+  }
+
+  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);
+    signal?.addEventListener('abort', cancelled, { once: true });
+    if (signal?.aborted) cancelled();
+    let sent = false, status, timer;
+    try {
+      return await new Promise((resolve, reject) => {
+        const session = http2.connect('https://chatgpt.com');
+        let request, settled = false, bytes = 0, text = '';
+        const current = () => auth.generation === this.generation
+          && identityKey(auth.identity) === identityKey(this.transport.profileIdentity);
+        const finish = (error, value) => {
+          if (settled) return; settled = true;
+          clearTimeout(timer); controller.signal.removeEventListener('abort', abort);
+          request?.destroy(); session.destroy();
+          if (error) {
+            if (method !== 'GET' && !onEvent) error.deliveryUnknown = sent && !(status >= 400 && status < 500 && status !== 408);
+            reject(error);
+          } else resolve(value);
+        };
+        const abort = () => finish(controller.signal.reason || new Error('点点请求已取消。'));
+        controller.signal.addEventListener('abort', abort, { once: true });
+        session.on('error', error => finish(error));
+        if (controller.signal.aborted) { abort(); return; }
+        const roomRoute = /^\/messaging\/rooms\/([^/]+)\/messages$/.exec(route)?.[1];
+        request = session.request({ ':method': method, ':path': `/backend-api${route}`, ...auth.headers,
+          accept: onEvent ? 'text/event-stream' : 'application/json',
+          ...(body != null ? { 'content-type': contentType || 'application/json' } : {}),
+          ...(roomRoute && this.routes.has(roomRoute) ? { 'x-openai-thread-route': this.routes.get(roomRoute) } : {}) });
+        timer = setTimeout(() => finish(new Error('点点请求超时，请重新核对状态。')), 30000);
+        request.setEncoding('utf8');
+        request.on('response', headers => {
+          status = headers[':status'];
+          if (roomRoute && typeof headers['x-openai-thread-route'] === 'string' && headers['x-openai-thread-route'].length <= 1024 && current()) this.routes.set(roomRoute, headers['x-openai-thread-route']);
+          if (status < 200 || status >= 300) {
+            console.error(JSON.stringify({ event: 'dots-room-request', method, status, route: route.split('?')[0] }));
+            const message = status === 401 ? '点点登录状态需要恢复，请重新连接。'
+              : status === 403 || status === 404 ? '点点消息暂不可用，请稍后重新同步。'
+                : status === 429 ? '点点暂时繁忙，请稍后再试。' : '点点请求尚未完成，请稍后核对。';
+            finish(Object.assign(new Error(message), { status }));
+          }
+        });
+        request.on('data', chunk => {
+          if (!current()) { finish(new Error('点点账号已变化，请重新连接。')); return; }
+          bytes += Buffer.byteLength(chunk); text += chunk;
+          if (onEvent) {
+            text = text.replace(/\r\n/g, '\n');
+            let end;
+            while ((end = text.indexOf('\n\n')) >= 0) {
+              const frame = text.slice(0, end); text = text.slice(end + 2);
+              const data = frame.split('\n').filter(line => line.startsWith('data:')).map(line => line.slice(5).trimStart()).join('\n');
+              if (data) try { onEvent(JSON.parse(data)); clearTimeout(timer); } catch (error) { finish(error); return; }
+            }
+            bytes = Buffer.byteLength(text);
+          }
+          if (bytes > 8 * 1024 * 1024) finish(new Error('点点响应超出单次读取上限。'));
+        });
+        request.on('error', error => finish(error));
+        request.on('end', () => {
+          if (!current()) { finish(new Error('点点账号已变化，请重新连接。')); return; }
+          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
+        // has been assigned an ID and may have submitted the request.
+        sent = !request.pending;
+        request.once('ready', () => { sent = true; });
+        request.end(body == null ? undefined : Buffer.isBuffer(body) ? body : JSON.stringify(body));
+      });
+    } finally { this.controllers.delete(controller); signal?.removeEventListener('abort', cancelled); }
+  }
+
+  async roomId(threadId) {
+    let profile = this.transport.liveProfiles.get(threadId);
+    if (!profile?.messagingRoomId) {
+      const value = await this.request(`/tbo/by-thread/${encodeURIComponent(threadId)}`);
+      profile = { messagingRoomId: value?.messaging_room_id };
+    }
+    if (typeof profile.messagingRoomId !== 'string' || !profile.messagingRoomId) throw new Error('点点消息房间暂不可用。');
+    return profile.messagingRoomId;
+  }
+
+  async room(id) {
+    const room = await this.request(`/messaging/rooms/${encodeURIComponent(id)}`);
+    if (room?.id !== id || room.type !== 'DM' || room.app_source !== 'chatgpt:messaging' || !Array.isArray(room.members)) {
+      throw new Error('点点消息房间身份不匹配。');
+    }
+    return room;
+  }
+
+  async messages(roomId, { before, after, around, limit = 20 } = {}) {
+    const query = new URLSearchParams({ limit: String(limit), ...(before ? { before } : {}),
+      ...(after ? { after } : {}), ...(around ? { around } : {}) });
+    const page = await this.request(`/messaging/rooms/${encodeURIComponent(roomId)}/messages?${query}`);
+    if (!Array.isArray(page?.items) || page.items.some(message => typeof message.id !== 'string' || !message.id)) throw new Error('点点消息页格式无效。');
+    // Null prev_cursor is also returned for nonempty middle pages. Desktop uses
+    // the first message ID; only an empty page proves that history is exhausted.
+    return { items: page.items, before: page.prev_cursor ?? page.items[0]?.id ?? null,
+      after: page.next_cursor ?? (after && page.items.length >= limit ? page.items.at(-1)?.id : null) };
+  }
+
+  close() {
+    super.close();
+    for (const controller of this.controllers) controller.abort(new Error('点点连接已结束。'));
+    this.controllers.clear(); this.routes.clear();
+  }
+}