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

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

@@ -0,0 +1,318 @@
+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);
+    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,199 @@
+import { EventEmitter } from 'node:events';
+
+// Desktop 26.1016.6573.0: room-live activity and responding heartbeats are
+// independent. Heartbeats expire after 10s; Dot reply handoff lasts at most 5s.
+const typingTimeout = 10000, handoffTimeout = 5000;
+const statusLabels = {
+  working: '正在处理…', searching: '正在搜索…', creating: '正在创建…',
+  payment: '等待支付', 'needs input': '等待你的输入', paused: '已暂停',
+};
+const waitingStates = new Set(['payment', 'needs input', 'paused']);
+const retryableStatus = status => status == null || status === 408 || status === 429 || status >= 500;
+
+export class DotsRoomActivity extends EventEmitter {
+  constructor(server) {
+    super(); this.server = server; this.watches = new Map();
+    this.message = (topic, event) => {
+      for (const watch of this.watches.values()) {
+        if (topic === 'calpico-chatgpt-messaging') { this.roomEvent(watch, event); continue; }
+        if (event?.type !== 'calpico-room-live') continue;
+        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); }
+    };
+  }
+  retryUnavailable(threadId) {
+    const watch = this.watches.get(threadId);
+    if (!watch?.unavailable || !watch.listeners.size || watch.controller || watch.timer) return false;
+    watch.attempts = 0;
+    void this.start(watch);
+    return true;
+  }
+  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 });
+  }
+  refresh(watch) {
+    const activity = watch.typing ? { kind: 'replying', label: '正在回复…', spinning: true }
+      : watch.liveActivity || (watch.handoffTimer ? { kind: 'replying', label: '正在回复…', spinning: true }
+        : watch.unavailable ? { kind: 'unavailable', label: '活动状态暂不可用', spinning: false }
+          : watch.idle ? { kind: 'idle', label: '空闲', spinning: false } : null);
+    this.publish(watch, activity);
+  }
+  clearReply(watch) {
+    clearTimeout(watch.typingTimer); clearTimeout(watch.handoffTimer);
+    watch.typingTimer = null; watch.handoffTimer = null; watch.typing = false; watch.handoffMessageId = null;
+  }
+  handoff(watch, messageId = null) {
+    const wasTyping = watch.typing;
+    clearTimeout(watch.typingTimer); watch.typingTimer = null; watch.typing = false;
+    if (messageId && (wasTyping || watch.handoffTimer)) watch.handoffMessageId = messageId;
+    if (wasTyping && !watch.handoffTimer) {
+      watch.handoffTimer = setTimeout(() => {
+        watch.handoffTimer = null; watch.handoffMessageId = null;
+        if (this.watches.get(watch.threadId) === watch) this.refresh(watch);
+      }, handoffTimeout);
+      watch.handoffTimer.unref();
+    }
+    this.refresh(watch);
+  }
+  completeReply(threadId, turns) {
+    const watch = this.watches.get(threadId);
+    if (!watch?.handoffMessageId || !turns.some(turn => turn.id === watch.handoffMessageId
+      && turn.items.some(item => item.type === 'agentMessage' && !item.dotsStreaming))) return;
+    // The matching formal message has entered the existing chat stream.
+    clearTimeout(watch.handoffTimer); watch.handoffTimer = null; watch.handoffMessageId = null;
+    this.refresh(watch);
+  }
+  roomEvent(watch, event) {
+    if (!this.server.rooms.ready || !watch.roomId || event?.payload?.room_id !== watch.roomId) return;
+    const payload = event.payload, heartbeat = event.type === 'calpico-is-responding-heartbeat';
+    if (!heartbeat && event.type !== 'calpico-message-add') return;
+    const room = this.server.bindings.get(watch.threadId);
+    const sender = heartbeat ? payload.source : payload.message;
+    if (room?.id !== watch.roomId || !room.aeon_id || heartbeat && sender?.role !== 'user'
+      || !sender?.account_user_id
+      || !room.members.some(member => member.account_user_id === sender.account_user_id && member.aeon_id === room.aeon_id)) return;
+    if (!heartbeat || payload.typing === false) {
+      this.handoff(watch, heartbeat ? null : payload.message.id); return;
+    }
+    if (payload.typing != null && payload.typing !== true) return;
+    this.clearReply(watch); watch.typing = true;
+    watch.typingTimer = setTimeout(() => {
+      watch.typingTimer = null;
+      if (this.watches.get(watch.threadId) === watch) this.handoff(watch);
+    }, typingTimeout);
+    watch.typingTimer.unref(); this.refresh(watch);
+  }
+  apply(watch, value) {
+    if (value.subscription_id !== watch.subscriptionId || !Number.isSafeInteger(value.revision) || value.revision <= watch.revision) return;
+    if (value.type === 'calpico-room-live-error') {
+      watch.revision = value.revision;
+      this.fail(watch, new Error('点点活动暂不可用。'), value.code === 'temporarily_unavailable'); return;
+    }
+    if (value.type !== 'calpico-room-live-state' || !Array.isArray(value.threads)) return;
+    watch.revision = value.revision;
+    clearTimeout(watch.initialTimer); watch.initialTimer = null;
+    const current = value.threads[0];
+    watch.idle = value.threads.length === 0;
+    if (value.threads.some(thread => thread.stream_state === 'attached')) watch.attempts = 0;
+    watch.unavailable = false; watch.liveActivity = null;
+    if (current?.stream_state !== 'attached') { this.refresh(watch); return; }
+    if (current.turn_status === 'failed') {
+      this.clearReply(watch); watch.liveActivity = { kind: 'error', label: '回复出错', spinning: false };
+      this.refresh(watch); return;
+    }
+    const status = typeof current.activity_status?.status_type === 'string' ? current.activity_status.status_type.toLowerCase() : '';
+    if (current.turn_status !== 'in_progress') {
+      watch.idle = ['completed', 'interrupted'].includes(current.turn_status) || status === 'ready';
+      this.refresh(watch); return;
+    }
+    const label = current.activity_status?.status_label;
+    watch.idle = status === 'ready';
+    if (status !== 'ready') {
+      const waiting = waitingStates.has(status);
+      const fallback = Object.hasOwn(statusLabels, status) ? statusLabels[status] : null;
+      if (waiting) this.clearReply(watch);
+      watch.liveActivity = { kind: waiting ? 'waiting' : fallback ? 'operation' : 'thinking',
+        label: typeof label === 'string' && label.trim() ? label : fallback || '正在思考…', spinning: !waiting };
+    }
+    this.refresh(watch);
+  }
+  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;
+    // Ready/keepalive on SSE does not establish delivery on the Celsius topic.
+    watch.initialTimer = setTimeout(() => {
+      if (current()) this.fail(watch, new Error('点点活动首次状态等待超时。'), true);
+    }, 30000);
+    watch.initialTimer.unref();
+    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;
+          // The live SSE sends {} keepalives after ready; they carry no identity.
+          if (value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0) 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, retryableStatus(error.status)); }
+  }
+  fail(watch, error, retry) {
+    console.error(JSON.stringify({ time: new Date().toISOString(), event: 'dots-room-activity',
+      threadId: watch.threadId, roomId: watch.roomId, status: error.status || 0,
+      stage: watch.subscriptionId ? 'state' : 'subscribe', retry, attempts: watch.attempts,
+      responseKind: error.details?.responseKind || 'none' }));
+    this.stop(watch, true); watch.unavailable = true; this.refresh(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, keepReply = false) {
+    watch.generation++; clearTimeout(watch.timer); watch.timer = null;
+    clearTimeout(watch.initialTimer); watch.initialTimer = null;
+    watch.controller?.abort(); watch.controller = null; watch.pending?.clear(); watch.liveActivity = null;
+    watch.subscriptionId = null; watch.revision = -1; watch.idle = false;
+    if (!keepReply) { this.clearReply(watch); watch.unavailable = false; watch.roomId = null; }
+    if (!keepReply) 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); }
+}