@walkhi/code-relax 0.1.0-beta.10 → 0.1.0-beta.100

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

@@ -0,0 +1,163 @@
+import http2 from 'node:http2';
+import { Readable } from 'node:stream';
+import { CelsiusClient } from './celsius-client.mjs';
+
+const topic = 'calpico-chatgpt-messaging';
+const identityKey = identity => JSON.stringify([identity?.accountId, identity?.userId]);
+
+// Desktop 26.1016.6573.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, responseKind = 'none';
+    const started = Date.now();
+    const clientId = method === 'POST' && /^[a-f0-9-]{36}$/i.test(body?.request_id || '') ? body.request_id : undefined;
+    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) {
+            error.details = { ...error.details, ...(status ? { upstreamStatus: status } : {}), responseKind };
+            if (!controller.signal.aborted) console.error(JSON.stringify({ time: new Date().toISOString(), event: 'dots-room-request', method,
+              route: route.split('?')[0], clientId, status: status || 0, responseKind,
+              ms: Date.now() - started, outcome: 'failed' }));
+            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 = method === 'POST' ? /^\/messaging\/rooms\/([^/]+)\/messages$/.exec(route)?.[1] : null;
+        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'];
+          const type = String(headers['content-type'] || '').split(';')[0].trim().toLowerCase();
+          responseKind = headers['cf-mitigated'] === 'challenge' ? 'challenge'
+            : type === 'application/json' ? 'json' : type === 'text/html' ? 'html' : type === 'text/event-stream' ? 'sse' : 'other';
+          if (roomRoute && current()) {
+            // Desktop replaces the route on every send response, including removal.
+            this.routes.delete(roomRoute);
+            const routeHint = headers['x-openai-thread-route'];
+            if (typeof routeHint === 'string' && routeHint && routeHint.length <= 1024) {
+              if (this.routes.size >= 128) this.routes.clear();
+              this.routes.set(roomRoute, routeHint);
+            }
+          }
+          if (status < 200 || status >= 300) {
+            const message = status === 401 ? '点点登录状态需要恢复，请重新连接。'
+              : status === 403 ? '点点服务拒绝访问（HTTP 403），请稍后重试。'
+                : status === 404 ? '点点消息暂不可用，请稍后重新同步。'
+                : status === 429 ? '点点暂时繁忙，请稍后再试。' : '点点请求尚未完成，请稍后核对。';
+            finish(Object.assign(new Error(message), { status }));
+          } else if (roomRoute || onEvent) {
+            console.log(JSON.stringify({ time: new Date().toISOString(), event: 'dots-room-request', method,
+              route: route.split('?')[0], clientId, status, responseKind, ms: Date.now() - started, outcome: 'response' }));
+          }
+        });
+        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');
+              // Desktop's ChatGPT SSE treats [DONE] as completion, not JSON.
+              if (data.trim() === '[DONE]') { finish(null, null); return; }
+              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; });
+        if (body instanceof Blob) {
+          const source = Readable.fromWeb(body.stream());
+          source.on('error', error => finish(error));
+          request.on('close', () => source.destroy());
+          source.pipe(request);
+        } else 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();
+  }
+}

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) };
+}