cx-viewer 1.0.3 → 1.0.4

package/src/utils/requestTools.js

@@ -0,0 +1,19 @@
+import { isMainAgent } from './contentFilter.js';
+import { formatToolAsXml } from './toolsXmlFormatter.js';
+import { getResponseTools } from '../../lib/openai-body.js';
+
+function chooseLatestMainAgentRequest(requests) {
+  if (!Array.isArray(requests) || requests.length === 0) return null;
+  if (requests.length === 1) return requests[0];
+  for (let i = requests.length - 1; i >= 0; i--) {
+    if (isMainAgent(requests[i])) return requests[i];
+  }
+  return null;
+}
+
+export function extractLoadedTools(requests) {
+  const chosen = chooseLatestMainAgentRequest(requests);
+  const tools = getResponseTools(chosen?.body);
+  if (!Array.isArray(tools) || tools.length === 0) return [];
+  return tools.map(formatToolAsXml).filter(Boolean);
+}

package/src/utils/requestType.js

@@ -0,0 +1,284 @@
+/**
+ * 请求类型分类工具
+ * classifyRequest(req, nextReq?) 返回 { type, subType }
+ * type: 'MainAgent' | 'SubAgent' | 'Teammate' | 'Tool' | 'Responses' | 'Count' | 'Preflight' | 'Plan' | 'Synthetic' | 'Metadata'
+ *
+ * Synthetic: Codex CLI 在主会话里合成的内部工具查询
+ * （idle 返回 recap / 会话标题生成 / 压缩摘要等），HTTP 层 role=user 但并非用户手输。
+ * subType: 'Recap' | 'Title' | 'Compact' | 'Topic' | 'Summary'
+ */
+// SYNTHETIC_PROMPTS 已抬到 contentFilter.js，让 isSystemText 也能共用（ChatView 字符串分支过滤）。
+// requestType.js 继续维护 getSyntheticSubType —— 走的是"last user message + isMainAgent 门槛"的更强
+// 形式判断（用于 RequestList 打 Synthetic tag）；isSystemText 走的是"纯文本起首匹配"（用于对话流隐藏）。
+import { getInputItemText, getResponseConversationItems, getResponseInputItems, getResponseInstructions, getResponseTools } from '../../lib/openai-body.js';
+import { isMainAgent, isTeammate, getInstructionsText, getEntryUpstreamLane, extractTeammateName, SYNTHETIC_PROMPTS } from './contentFilter.js';
+
+function getMessageText(msg) {
+  return getInputItemText(msg);
+}
+
+function getSubAgentSubType(req) {
+  if (req?.subAgentName) return req.subAgentName;
+  const body = req.body || {};
+  const instructionsText = getInstructionsText(body);
+
+  if (/Extract any file paths/i.test(instructionsText)) return 'Shell';
+  if (/process shell commands/i.test(instructionsText)) return 'Shell';
+  if (/command execution specialist/i.test(instructionsText)) return 'Shell';
+  if (/file search specialist/i.test(instructionsText)) return 'Search';
+  if (/planning specialist/i.test(instructionsText)) return 'Plan';
+  if (/general-purpose agent/i.test(instructionsText)) return 'General';
+  if (/security monitor/i.test(instructionsText)) return 'Advisor';
+  if (/performing a web search/i.test(instructionsText)) return 'web_search';
+
+  const input = getResponseInputItems(body);
+  for (let i = input.length - 1; i >= 0; i--) {
+    if (input[i].role !== 'user') continue;
+    const text = getMessageText(input[i]);
+    if (/^Command:/m.test(text)) return 'Shell';
+    break;
+  }
+
+  return null;
+}
+
+function getResponsesLaneSubType(req) {
+  const lane = getEntryUpstreamLane(req);
+  if (!lane || !lane.startsWith('responses:')) return null;
+  return getSubAgentSubType(req) || 'OpenAI Responses';
+}
+
+/**
+ * 判断请求是否为 Codex 内部合成的工具查询。
+ * 必须同时满足：(1) 来自主会话（isMainAgent 通过），(2) 最后一条 user input item 的起首
+ * 命中 SYNTHETIC_PROMPTS 白名单。返回匹配的 subType 或 null。
+ *
+ * 为什么不用"input 项短"作为启发式：拦截日志里 teammate 消息 / tool_result
+ * 也常出现 input.length <= 3，会把它们误判为 Synthetic。白名单精确度更高，
+ * 代价是 Codex 新增合成类型需要手工加 pattern。
+ */
+function getSyntheticSubType(req) {
+  if (!isMainAgent(req)) return null;
+  const input = getResponseInputItems(req.body);
+  if (!input.length) return null;
+  const last = input[input.length - 1];
+  if (!last || last.role !== 'user') return null;
+  const text = getMessageText(last).trim();
+  if (!text) return null;
+  for (const { subType, pattern } of SYNTHETIC_PROMPTS) {
+    if (pattern.test(text)) return subType;
+  }
+  return null;
+}
+
+function isCountRequest(req) {
+  const input = getResponseConversationItems(req.body);
+  if (input.length !== 1) return false;
+  const msg = input[0];
+  return msg.role === 'user' && msg.content === 'count';
+}
+
+function isQuotaCheck(req) {
+  const body = req.body || {};
+  if (body.max_tokens !== 1) return false;
+  if (getResponseInstructions(body)) return false;
+  if (getResponseTools(body).length > 0) return false;
+  const input = getResponseConversationItems(body);
+  if (input.length !== 1) return false;
+  return input[0].role === 'user' && input[0].content === 'quota';
+}
+
+function isCodexToolEvent(req) {
+  if (!req || req.mainAgent !== false || req.subAgent !== false) return false;
+  if (['TOOL', 'TOOL_RESULT', 'SUBAGENT', 'EVENT'].includes(req.method)) return true;
+  return typeof req.url === 'string' && req.url.startsWith('codex://');
+}
+
+export function isToolRequest(req) {
+  if (!req || req.mainAgent !== false || req.subAgent !== false) return false;
+  if (['TOOL', 'TOOL_RESULT'].includes(req.method)) return true;
+  const url = typeof req.url === 'string' ? req.url : '';
+  return /^codex:\/\/(?:tool|tool_result|mcp_tool|dynamic_tool|collab)\b/.test(url);
+}
+
+function getToolSubType(req) {
+  const body = req?.body || {};
+  const name = body.tool_name || body.event_name;
+  if (name) return String(name);
+  const url = typeof req?.url === 'string' ? req.url : '';
+  const m = url.match(/^codex:\/\/(?:tool|tool_result|mcp_tool|dynamic_tool|collab)\/([^?#]+)/);
+  if (!m) return null;
+  try {
+    return decodeURIComponent(m[1]) || null;
+  } catch {
+    return m[1] || null;
+  }
+}
+
+export function isModelCatalogRequest(req) {
+  if (!req) return false;
+  const method = String(req.method || 'GET').toUpperCase();
+  if (method !== 'GET') return false;
+
+  const urls = [req.proxyUrl, req.url].filter(Boolean);
+  for (const url of urls) {
+    try {
+      const pathname = new URL(url).pathname.replace(/\/+$/, '');
+      if (
+        pathname === '/backend-api/codex/models' ||
+        pathname.endsWith('/codex/models') ||
+        pathname === '/v1/models'
+      ) {
+        return true;
+      }
+    } catch {
+      if (/\/(?:backend-api\/)?codex\/models(?:[?#]|$)/.test(String(url)) || /\/v1\/models(?:[?#]|$)/.test(String(url))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Preflight 判断：
+ * 1. tools 为空或不存在
+ * 2. input 仅一条 user item
+ * 3. instructions 包含 Codex 特征
+ * 4. 下一条请求的 input 中包含本条 item 的文本（前80字符匹配）
+ */
+function isPreflightRequest(req, nextReq) {
+  const body = req.body || {};
+  const tools = getResponseTools(body);
+  const input = getResponseConversationItems(body);
+
+  // 条件1: tools 为空
+  if (Array.isArray(tools) && tools.length > 0) return false;
+
+  // 条件2: 仅一条 user input item
+  if (input.length !== 1 || input[0].role !== 'user') return false;
+
+  const text = getMessageText(input[0]);
+  if (!text) return false;
+
+  // 排除 count 请求
+  if (text.trim() === 'count') return false;
+
+  // 排除工具类请求（shell 命令、安全策略检查、系统通知等）
+  const trimmed = text.trim();
+  if (/^Command:/m.test(text) || /^<policy_spec>/i.test(trimmed) || /^<task-notification>/i.test(trimmed)) return false;
+
+  // 条件3: instructions 包含 Codex 特征，但排除 shell 处理器
+  const instructionsText = getInstructionsText(body);
+  if (!instructionsText.includes('Codex')) return false;
+  if (/process shell commands/i.test(instructionsText)) return false;
+  if (/Extract any file paths/i.test(instructionsText)) return false;
+
+  // 条件4: 下一条请求的 input 中包含本条文本
+  if (nextReq) {
+    const nextInput = getResponseConversationItems(nextReq.body);
+    const sig = text.slice(0, 80);
+    const found = nextInput.some(m => getMessageText(m).includes(sig));
+    if (found) return true;
+  }
+
+  return false;
+}
+
+/**
+ * 分类请求
+ * @param {object} req - 当前请求
+ * @param {object} [nextReq] - 下一条请求（用于 Preflight 判断）
+ */
+export function classifyRequest(req, nextReq) {
+  // Teammate 子进程的请求优先识别（收敛于 contentFilter.isTeammate）
+  if (isTeammate(req)) {
+    if (req.teammate) return { type: 'Teammate', subType: req.teammate };
+    if (req._cachedTeammateName === undefined) {
+      req._cachedTeammateName = extractTeammateName(req.body) || null;
+    }
+    return { type: 'Teammate', subType: req._cachedTeammateName };
+  }
+
+  // Synthetic 检查要在 MainAgent 之前——这类请求 mainAgent=true，
+  // 不拦截就会被当作普通主会话轮次，用户看不出是 Codex 合成的。
+  const syntheticSub = getSyntheticSubType(req);
+  if (syntheticSub) {
+    return { type: 'Synthetic', subType: syntheticSub };
+  }
+
+  if (isMainAgent(req)) {
+    return { type: 'MainAgent', subType: null };
+  }
+
+  if (req.isCountTokens || isCountRequest(req)) {
+    return { type: 'Count', subType: null };
+  }
+
+  if (isQuotaCheck(req)) {
+    return { type: 'Count', subType: 'Quota' };
+  }
+
+  if (isCodexToolEvent(req)) {
+    if (isToolRequest(req)) {
+      return { type: 'Tool', subType: getToolSubType(req) };
+    }
+    return { type: 'Synthetic', subType: req.method || 'Tool' };
+  }
+
+  if (isModelCatalogRequest(req)) {
+    return { type: 'Metadata', subType: 'Models' };
+  }
+
+  const responsesLaneSubType = getResponsesLaneSubType(req);
+  if (responsesLaneSubType) {
+    // Slimming removes the body fields used by MainAgent heuristics. Historical
+    // transport entries can therefore reach this fallback with stale capture
+    // flags (`subAgent: true`, `subAgentName: OpenAI Responses`). They are
+    // Responses traffic, not delegated agents. Preserve genuine named
+    // subagents while giving transport records their own neutral category.
+    const isTransportLabel = /^(?:OpenAI Responses|Responses(?:\s|$))/i.test(responsesLaneSubType);
+    if (req.subAgent && !isTransportLabel) {
+      return { type: 'SubAgent', subType: responsesLaneSubType };
+    }
+    return { type: 'Responses', subType: responsesLaneSubType };
+  }
+
+  if (req.subAgent) {
+    return { type: 'SubAgent', subType: getSubAgentSubType(req) };
+  }
+
+  if (isPreflightRequest(req, nextReq)) {
+    // Preflight 内容以 "Implement the following plan:" 开头 → Plan:Prompt
+    const text = getMessageText(getResponseConversationItems(req.body)[0]);
+    if (/Implement the following plan:/i.test(text.trim())) {
+      return { type: 'Plan', subType: 'Prompt' };
+    }
+    return { type: 'Preflight', subType: null };
+  }
+
+  const subType = getSubAgentSubType(req);
+  if (subType) return { type: 'SubAgent', subType };
+  return { type: 'Metadata', subType: null };
+}
+
+// Tag 显示文本
+export function formatRequestTag(type, subType) {
+  if (type === 'Teammate' && subType) return `Teammate:${subType}`;
+  if (type === 'Plan' && subType) return `Plan:${subType}`;
+  if (type === 'SubAgent' && subType) return `SubAgent:${subType}`;
+  if (type === 'Responses' && subType) return subType;
+  if (type === 'Tool' && subType) return `Tool:${subType}`;
+  if (type === 'Synthetic' && subType) return `Synthetic:${subType}`;
+  if (type === 'Count' && subType) return `Count:${subType}`;
+  if (type === 'Metadata' && subType) return `Metadata:${subType}`;
+  return type;
+}
+
+// Teammate label: "Teammate: name(model-short)" or "Teammate: name"
+export function formatTeammateLabel(name, model) {
+  const displayName = name || 'X';
+  if (!model) return `Teammate: ${displayName}`;
+  const short = model.replace(/^codex-/i, '').replace(/-\d{8}$/, '');
+  return `Teammate: ${displayName}(${short})`;
+}

package/src/utils/resizeCalc.js

@@ -0,0 +1,21 @@
+// 拖拽 resize 的纯几何计算 —— 把 startX/Y/curX/curY/startW/startH 换成 clamp 后的 {w, h}。
+// 单测可独立验证 4 个 clamp 边界 + 任意方向(dirX/dirY ∈ {-1, +1}),不依赖 DOM/React。
+//
+// 方向参数语义:
+//   dirX = -1 →  鼠标往左拉时 w 变大(handle 在左侧,例:左上 / 左下)
+//   dirX = +1 →  鼠标往右拉时 w 变大(handle 在右侧,例:右上 / 右下)
+//   dirY 同理(-1 = handle 在上侧)
+//
+// 调用方需保证 clamp 区间合法(min ≤ max);若不合法则 max 取胜(避 NaN)。
+export function calcResizedSize({ startX, startY, curX, curY, startW, startH, dirX, dirY, clamp }) {
+  const dx = (curX - startX) * dirX;
+  const dy = (curY - startY) * dirY;
+  let w = startW + dx;
+  let h = startH + dy;
+  const { minW, maxW, minH, maxH } = clamp || {};
+  if (typeof minW === 'number' && w < minW) w = minW;
+  if (typeof maxW === 'number' && w > maxW) w = maxW;
+  if (typeof minH === 'number' && h < minH) h = minH;
+  if (typeof maxH === 'number' && h > maxH) h = maxH;
+  return { w: Math.round(w), h: Math.round(h) };
+}

package/src/utils/resolveLocalized.js

@@ -0,0 +1,17 @@
+// 把「纯字符串 或 {lang: str} 本地化对象」解析成当前语言下的字符串。
+// 用于 ultraAgents 预设专家的 title / description：服务端原样下发本地化对象，
+// 前端按 getLang() 解析，语言切换无需重新请求。(content 是单语言字符串，不走本处。)
+//
+// 回退顺序：精确语言 → 去区域后的主语言(zh-TW→zh, pt-BR→pt) → en → zh → 首个非空字符串值。
+// 异常输入（数组 / 数字 / null / 空对象 / 全空串对象）一律安全返回 ''，绝不抛错。
+export function resolveLocalized(field, lang) {
+  if (typeof field === 'string') return field;
+  if (!field || typeof field !== 'object' || Array.isArray(field)) return '';
+  const pick = (k) => (typeof field[k] === 'string' && field[k].trim() ? field[k] : null);
+  const base = typeof lang === 'string' ? lang.split('-')[0] : '';
+  return pick(lang)
+    || pick(base)
+    || pick('en')
+    || pick('zh')
+    || (Object.values(field).find(v => typeof v === 'string' && v.trim()) || '');
+}

package/src/utils/seqResourceLoaders.js

@@ -0,0 +1,79 @@
+// 三态加载 + seq 防污 共用实现（class 组件用）。
+// 三态契约：state[key] === null  → 未加载（loading）
+//          state[key] === false → 加载失败
+//          state[key] === <data> → 加载成功
+// 组件 instance 上必须存在 `_<name>Seq` 计数字段（constructor 初始化为 0）。
+// workspace 切换时 componentDidUpdate 应 `++this._<name>Seq` 失效在途请求。
+//
+// ─── 抽取边界（有意为之，请勿扩张）────────────────────────────────────────────
+// 这里**只覆盖 lazy-load 静默路径**：组件首次挂载/workspace 切换时自动 fire，失败
+// 落 false 让上游 chip / popover 进入空态。
+// 用户主动触发的 refresh（带 toast、loading spinner、错误 message）刻意保留在
+// AppHeader.jsx (handleRefreshMemory) / Mobile.jsx 各自的 inline 实现里，原因：
+//   1) 主动 refresh 需要 caller 决定 toast 文案、loading 视觉、错误反馈策略；
+//      若硬塞进 loader 内部，loader 必须 import message → 反向耦合 antd UI 层。
+//   2) loadMemoryDetail / loadCodexMdDetail 也是用户点击驱动，含「成功后跳详情面板」
+//      副作用，同样不属于"加载即更新 state"语义，留 caller 自管更清晰。
+// 即：本文件 = 静默路径，inline = 用户触发路径。两者并存是设计选择，不是抽取漏。
+// ────────────────────────────────────────────────────────────────────────────
+
+import { apiUrl } from './apiUrl.js';
+
+async function _seqGuardedFetch(component, seqProp, url) {
+  const seq = ++component[seqProp];
+  let r;
+  try {
+    r = await fetch(url);
+  } catch (e) {
+    if (seq !== component[seqProp]) return { stale: true };
+    return { stale: false, ok: false, error: e, errorKind: 'network' };
+  }
+  try {
+    const data = await r.json();
+    if (seq !== component[seqProp]) return { stale: true };
+    return { stale: false, ok: r.ok, status: r.status, data };
+  } catch (e) {
+    if (seq !== component[seqProp]) return { stale: true };
+    return { stale: false, ok: false, error: e, errorKind: 'parse', status: r.status };
+  }
+}
+
+// 拉取项目文件系统 skills。
+// 失败时若 _fsSkills 已是数组（前次成功结果）→ 保留不 clobber，
+// 避免 popover chip 从乐观态回退到历史空态。
+// 返回 { ok: true, skills } / { ok: false, reason: 'local_log'|'stale'|'http:NNN'|'network'|'parse'|<server msg> }
+export async function loadFsSkills(component, { isLocalLog } = {}) {
+  if (isLocalLog) return { ok: false, reason: 'local_log' };
+  const res = await _seqGuardedFetch(component, '_fsSkillsSeq', apiUrl('/api/skills'));
+  if (res.stale) return { ok: false, reason: 'stale' };
+  if (res.error) {
+    component.setState(prev => ({ _fsSkills: Array.isArray(prev._fsSkills) ? prev._fsSkills : false }));
+    return { ok: false, reason: res.errorKind || res.error.message || 'network' };
+  }
+  if (!res.ok || !res.data?.ok || !Array.isArray(res.data?.skills)) {
+    const reason = (res.data && res.data.error) || `http:${res.status}`;
+    component.setState(prev => ({ _fsSkills: Array.isArray(prev._fsSkills) ? prev._fsSkills : false }));
+    return { ok: false, reason };
+  }
+  component.setState({ _fsSkills: res.data.skills });
+  return { ok: true, skills: res.data.skills };
+}
+
+// 拉取项目入口 MEMORY.md。lazy-load 失败静默回退 false；用户主动刷新走 handleRefreshMemory（带 toast）。
+export async function loadProjectMemory(component) {
+  const res = await _seqGuardedFetch(component, '_memorySeq', apiUrl('/api/project-memory'));
+  if (res.stale) return;
+  if (res.error || !res.ok) { component.setState({ _memory: false }); return; }
+  component.setState({ _memory: res.data });
+}
+
+// 拉取 AGENTS.md 候选清单。三态：null/false/[]/[{id,scope,tail,...}]。
+export async function loadCodexMdList(component) {
+  const res = await _seqGuardedFetch(component, '_codexMdSeq', apiUrl('/api/codex-md'));
+  if (res.stale) return;
+  if (res.error || !res.ok || !Array.isArray(res.data?.entries)) {
+    component.setState({ _codexMd: false });
+    return;
+  }
+  component.setState({ _codexMd: res.data.entries });
+}