@muyichengshayu/promptx 0.1.31 → 0.1.34

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.1.34
+
+- 统一图片预览层遮罩，直接复用和工作台弹窗一致的 `theme-modal-backdrop`，不再单独维护一套 overlay 背景，避免预览层与其它弹窗视觉割裂。
+- 修复放大图片时顶部工具按钮对比度不足的问题：为缩放、翻页和关闭按钮补上稳定的底色、边框和阴影，在亮图背景上也能清楚辨认。
+
+## 0.1.33
+
+- 修复安装包在 Node.js 22 下启动失败的问题：移除 `jimp` 及其 `@jimp/plugin-print -> simple-xml-to-json` 这条有问题的 ESM 依赖链，避免 `promptx start` 在加载阶段直接抛出 `does not provide an export named 'default'`。
+- 上传图片改为使用现有的 `@napi-rs/canvas` 完成读取、缩放和 JPEG 导出，不再依赖 `jimp`，同时保持上传后图片会统一缩放到 `1600x1600` 以内的现有语义。
+- 补充图片上传回归测试，并更新锁文件与打包产物校验，确保新安装包不再带入这条启动时会炸掉的依赖链。
+
+## 0.1.32
+
+- 继续收敛执行过程面板：统一过程事件卡片为白底轻边框，过程区与输入区统一等宽字体，移动端优先折行显示，减少横向滚动与样式不一致带来的阅读负担。
+- 精简子代理展示：`Codex / Claude Code / OpenCode` 的子代理事件统一为更轻量的一行摘要，移动端最多显示两行、桌面端单行；同时去掉多余的“更新”标签、局部展开/收起和重色块背景。
+- 下线执行过程中的代码类自动识别兼容：移除 `code_text / code_snippet / numbered_lines / build_error / search_results` 等旧分支，统一回退为稳定的文本或少量明确结构块，减少误判和错误代码块渲染。
+- 优化前端打包输出：为 `tiptap`、图标与 markdown 等依赖拆分 vendor chunk，消除 Vite 的大包告警，降低工作台主包体积。
+
 ## 0.1.31
 
 - 继续打磨执行过程展示：统一 `Codex / Claude Code / OpenCode` 的终端输出、搜索命中、构建报错与 diff 渲染，补齐移动端横向滚动、代码字体统一和多余元信息收敛，整体阅读更稳定。

package/apps/runner/src/engines/claudeCodeRunner.js

@@ -132,6 +132,45 @@ function flushBufferedText(buffer = '') {
   return tail ? [...lines, tail] : lines
 }
 
+function extractAgentTargetFromTexts(...values) {
+  const matcher = /(?:^|[\s`'"])([A-Za-z]:[\\/][^\s`'"]+\.[A-Za-z0-9]+|\/[^\s`'"]+\.[A-Za-z0-9]+|(?:[A-Za-z0-9._-]+\/)*[A-Za-z0-9._-]+\.[A-Za-z0-9]+)(?=$|[\s`'"])/i
+  for (const value of values) {
+    const text = String(value || '').trim()
+    if (!text) {
+      continue
+    }
+
+    const matched = text.match(matcher)
+    if (!matched?.[1]) {
+      continue
+    }
+
+    const normalized = matched[1].replace(/\\/g, '/')
+    const parts = normalized.split('/').filter(Boolean)
+    return parts[parts.length - 1] || normalized
+  }
+
+  return ''
+}
+
+function normalizeCollabAgentStatus(status = '') {
+  const normalized = String(status || '').trim().toLowerCase()
+  if (['completed', 'complete', 'succeeded', 'success', 'done'].includes(normalized)) {
+    return 'completed'
+  }
+  if (['failed', 'error', 'errored', 'cancelled', 'canceled', 'stopped'].includes(normalized)) {
+    return 'failed'
+  }
+  if (['running', 'in_progress', 'in-progress', 'pending_init', 'pending'].includes(normalized)) {
+    return normalized === 'pending_init' ? 'pending_init' : 'running'
+  }
+  return normalized || 'pending_init'
+}
+
+function isClaudeCollabToolName(name = '') {
+  return ['agent', 'task'].includes(String(name || '').trim().toLowerCase())
+}
+
 function collectTextParts(value, parts = []) {
   if (!value) {
     return parts
@@ -180,6 +219,29 @@ export function extractClaudeAssistantText(event = {}) {
   return parts.join('\n').trim()
 }
 
+function stringifyClaudeToolResultContent(value) {
+  const parts = []
+  collectTextParts(value, parts)
+  if (parts.length) {
+    return parts.join('\n').trim()
+  }
+
+  if (typeof value === 'string') {
+    return value.trim()
+  }
+
+  if (value == null) {
+    return ''
+  }
+
+  try {
+    const compact = JSON.stringify(value)
+    return compact.length <= 12000 ? compact : `${compact.slice(0, 11997)}...`
+  } catch {
+    return String(value || '').trim()
+  }
+}
+
 export function extractClaudeResultText(event = {}) {
   const parts = []
   if (event?.result) {
@@ -206,6 +268,8 @@ export function extractClaudeSessionId(event = {}) {
 export function createClaudeNormalizationState() {
   return {
     toolUses: new Map(),
+    taskIdToToolUseId: new Map(),
+    completedCollabToolUseIds: new Set(),
   }
 }
 
@@ -246,19 +310,61 @@ function buildClaudeToolCommand(name = '', input = {}) {
   return inputSummary ? `${toolName}: ${inputSummary}` : toolName
 }
 
+function buildClaudeCollabState(toolUse = {}, overrides = {}) {
+  const taskId = String(overrides.taskId || '').trim()
+  const message = stringifyClaudeToolResultContent(overrides.message)
+  const baseStatus = overrides.status ?? (message ? 'completed' : 'running')
+  const status = normalizeCollabAgentStatus(baseStatus)
+
+  return {
+    status,
+    message,
+    title: String(overrides.title || toolUse.description || '').trim(),
+    role: String(overrides.role || toolUse.role || '').trim(),
+    target: String(overrides.target || toolUse.target || '').trim(),
+    model: String(overrides.model || toolUse.model || '').trim(),
+    ...(taskId ? { task_id: taskId } : {}),
+  }
+}
+
 function createClaudeToolUseEvent(block = {}, state = createClaudeNormalizationState()) {
   const toolUseId = String(block?.id || '').trim()
   const name = String(block?.name || block?.tool_name || 'Claude Code tool').trim() || 'Claude Code tool'
   const input = block?.input && typeof block.input === 'object' ? block.input : {}
   const command = buildClaudeToolCommand(name, input)
+  const isCollabTool = isClaudeCollabToolName(name)
+  const collabPrompt = String(input.prompt || '').trim()
+  const collabDescription = String(input.description || '').trim()
+  const collabRole = String(input.subagent_type || input.agent || '').trim()
+  const collabModel = String(input.model || '').trim()
+  const collabTarget = extractAgentTargetFromTexts(collabDescription, collabPrompt)
 
   if (toolUseId) {
     state.toolUses.set(toolUseId, {
       name,
       command,
+      kind: isCollabTool ? 'collab' : 'command',
+      prompt: collabPrompt || collabDescription,
+      description: collabDescription,
+      role: collabRole,
+      model: collabModel,
+      target: collabTarget,
+      taskIds: [],
     })
   }
 
+  if (isCollabTool) {
+    return {
+      ...createItemStartedEvent({
+        type: AGENT_RUN_ITEM_TYPES.COLLAB_TOOL_CALL,
+        tool: 'spawn_agent',
+        receiver_thread_ids: [],
+        prompt: collabPrompt || collabDescription,
+        agents_states: {},
+      }),
+    }
+  }
+
   return {
     ...createItemStartedEvent({
       type: AGENT_RUN_ITEM_TYPES.COMMAND_EXECUTION,
@@ -271,12 +377,47 @@ function createClaudeToolUseEvent(block = {}, state = createClaudeNormalizationS
 function createClaudeToolResultEvent(block = {}, state = createClaudeNormalizationState()) {
   const toolUseId = String(block?.tool_use_id || block?.toolUseId || '').trim()
   const remembered = toolUseId ? state.toolUses.get(toolUseId) : null
-  const output = String(block?.content || block?.result || '').trim()
+  const output = stringifyClaudeToolResultContent(block?.content ?? block?.result)
   const isError = Boolean(block?.is_error)
+  const taskIds = Array.isArray(remembered?.taskIds) ? remembered.taskIds.filter(Boolean) : []
+  const collabTool = remembered?.kind === 'collab'
+
+  if (toolUseId && state.completedCollabToolUseIds.has(toolUseId)) {
+    return null
+  }
 
   if (toolUseId) {
     state.toolUses.delete(toolUseId)
   }
+  taskIds.forEach((taskId) => {
+    state.taskIdToToolUseId.delete(taskId)
+  })
+
+  if (collabTool) {
+    if (toolUseId) {
+      state.completedCollabToolUseIds.add(toolUseId)
+    }
+    const receiverThreadIds = taskIds.length
+      ? taskIds
+      : (toolUseId ? [`claude-agent-${toolUseId}`] : [])
+    const agentsStates = Object.fromEntries(
+      receiverThreadIds.map((taskId) => [taskId, buildClaudeCollabState(remembered, {
+        taskId,
+        status: isError ? 'failed' : 'completed',
+        message: output,
+      })])
+    )
+
+    return {
+      ...createItemCompletedEvent({
+        type: AGENT_RUN_ITEM_TYPES.COLLAB_TOOL_CALL,
+        tool: 'wait',
+        receiver_thread_ids: receiverThreadIds,
+        prompt: remembered?.prompt || remembered?.description || '',
+        agents_states: agentsStates,
+      }),
+    }
+  }
 
   return {
     ...createItemCompletedEvent({
@@ -289,6 +430,105 @@ function createClaudeToolResultEvent(block = {}, state = createClaudeNormalizati
   }
 }
 
+function resolveClaudeTaskToolUseId(event = {}, state = createClaudeNormalizationState()) {
+  const explicitToolUseId = String(event?.tool_use_id || event?.toolUseId || '').trim()
+  if (explicitToolUseId) {
+    return explicitToolUseId
+  }
+
+  const taskId = String(event?.task_id || event?.taskId || '').trim()
+  if (!taskId) {
+    return ''
+  }
+
+  return String(state.taskIdToToolUseId.get(taskId) || '').trim()
+}
+
+function createClaudeTaskStartedEvent(event = {}, state = createClaudeNormalizationState()) {
+  const toolUseId = resolveClaudeTaskToolUseId(event, state)
+  const taskId = String(event?.task_id || event?.taskId || '').trim()
+  const remembered = toolUseId ? state.toolUses.get(toolUseId) : null
+
+  if (!remembered || remembered.kind !== 'collab' || !taskId) {
+    return null
+  }
+
+  if (!Array.isArray(remembered.taskIds)) {
+    remembered.taskIds = []
+  }
+  if (!remembered.taskIds.includes(taskId)) {
+    remembered.taskIds.push(taskId)
+  }
+  state.taskIdToToolUseId.set(taskId, toolUseId)
+
+  return {
+    ...createItemCompletedEvent({
+      type: AGENT_RUN_ITEM_TYPES.COLLAB_TOOL_CALL,
+      tool: 'spawn_agent',
+      receiver_thread_ids: [taskId],
+      prompt: remembered.prompt || String(event?.prompt || event?.description || '').trim(),
+      agents_states: {
+        [taskId]: buildClaudeCollabState(remembered, {
+          taskId,
+          status: 'running',
+          title: String(event?.description || remembered.description || '').trim(),
+          target: extractAgentTargetFromTexts(event?.description, event?.prompt, remembered.target),
+        }),
+      },
+    }),
+  }
+}
+
+function createClaudeTaskFinishedEvent(event = {}, state = createClaudeNormalizationState()) {
+  const subtype = String(event?.subtype || '').trim().toLowerCase()
+  const toolUseId = resolveClaudeTaskToolUseId(event, state)
+  const taskId = String(event?.task_id || event?.taskId || '').trim()
+  const remembered = toolUseId ? state.toolUses.get(toolUseId) : null
+
+  if (!remembered || remembered.kind !== 'collab') {
+    return null
+  }
+
+  if (toolUseId && state.completedCollabToolUseIds.has(toolUseId)) {
+    return null
+  }
+
+  const failed = subtype === 'task_failed'
+  const output = stringifyClaudeToolResultContent(
+    event?.result
+      ?? event?.message
+      ?? event?.content
+      ?? event?.error
+      ?? event?.task_result
+  )
+
+  if (toolUseId) {
+    state.toolUses.delete(toolUseId)
+    state.completedCollabToolUseIds.add(toolUseId)
+  }
+  if (taskId) {
+    state.taskIdToToolUseId.delete(taskId)
+  }
+
+  return {
+    ...createItemCompletedEvent({
+      type: AGENT_RUN_ITEM_TYPES.COLLAB_TOOL_CALL,
+      tool: 'wait',
+      receiver_thread_ids: taskId ? [taskId] : (Array.isArray(remembered.taskIds) ? remembered.taskIds.filter(Boolean) : []),
+      prompt: remembered.prompt || remembered.description || '',
+      agents_states: {
+        [(taskId || `claude-agent-${toolUseId}`)]: buildClaudeCollabState(remembered, {
+          taskId,
+          status: failed ? 'failed' : 'completed',
+          message: output,
+          title: String(event?.description || remembered.description || '').trim(),
+          target: extractAgentTargetFromTexts(event?.description, event?.prompt, remembered.target),
+        }),
+      },
+    }),
+  }
+}
+
 function buildClaudeApiRetryReason(event = {}) {
   const status = Number(event?.error_status) || 0
   const code = String(event?.error || '').trim()
@@ -323,6 +563,19 @@ export function normalizeClaudeEvents(event = {}, state = createClaudeNormalizat
     return [createThreadStartedEvent(extractClaudeSessionId(event))]
   }
 
+  if (eventType === 'system' && String(event?.subtype || '').trim().toLowerCase() === 'task_started') {
+    const collabEvent = createClaudeTaskStartedEvent(event, state)
+    return collabEvent ? [collabEvent] : []
+  }
+
+  if (
+    eventType === 'system'
+    && ['task_result', 'task_completed', 'task_failed'].includes(String(event?.subtype || '').trim().toLowerCase())
+  ) {
+    const collabEvent = createClaudeTaskFinishedEvent(event, state)
+    return collabEvent ? [collabEvent] : []
+  }
+
   if (eventType === 'system' && String(event?.subtype || '').trim().toLowerCase() === 'api_retry') {
     if (isClaudeFatalAuthRetry(event)) {
       return [createErrorEvent(formatClaudeFatalAuthMessage(event))]
@@ -378,7 +631,10 @@ export function normalizeClaudeEvents(event = {}, state = createClaudeNormalizat
     blocks.forEach((block) => {
       const blockType = String(block?.type || '').trim().toLowerCase()
       if (blockType === 'tool_result') {
-        normalizedEvents.push(createClaudeToolResultEvent(block, state))
+        const toolResultEvent = createClaudeToolResultEvent(block, state)
+        if (toolResultEvent) {
+          normalizedEvents.push(toolResultEvent)
+        }
       }
     })
     return normalizedEvents

package/apps/runner/src/engines/openCodeRunner.js

@@ -133,6 +133,41 @@ function flushBufferedText(buffer = '') {
   return tail ? [...lines, tail] : lines
 }
 
+function extractAgentTargetFromTexts(...values) {
+  const matcher = /(?:^|[\s`'"])([A-Za-z]:[\\/][^\s`'"]+\.[A-Za-z0-9]+|\/[^\s`'"]+\.[A-Za-z0-9]+|(?:[A-Za-z0-9._-]+\/)*[A-Za-z0-9._-]+\.[A-Za-z0-9]+)(?=$|[\s`'"])/i
+  for (const value of values) {
+    const text = String(value || '').trim()
+    if (!text) {
+      continue
+    }
+
+    const matched = text.match(matcher)
+    if (!matched?.[1]) {
+      continue
+    }
+
+    const normalized = matched[1].replace(/\\/g, '/')
+    const parts = normalized.split('/').filter(Boolean)
+    return parts[parts.length - 1] || normalized
+  }
+
+  return ''
+}
+
+function normalizeCollabAgentStatus(status = '') {
+  const normalized = String(status || '').trim().toLowerCase()
+  if (['completed', 'complete', 'succeeded', 'success', 'done'].includes(normalized)) {
+    return 'completed'
+  }
+  if (['failed', 'error', 'errored', 'cancelled', 'canceled', 'stopped'].includes(normalized)) {
+    return 'failed'
+  }
+  if (['running', 'in_progress', 'in-progress', 'pending_init', 'pending'].includes(normalized)) {
+    return normalized === 'pending_init' ? 'pending_init' : 'running'
+  }
+  return normalized || 'pending_init'
+}
+
 function summarizeOpenCodeInput(input = {}) {
   if (!input || typeof input !== 'object') {
     return ''
@@ -295,6 +330,73 @@ export function createOpenCodeNormalizationState() {
   }
 }
 
+function isOpenCodeSubAgentTask(event = {}) {
+  const part = event?.part && typeof event.part === 'object' ? event.part : {}
+  const tool = String(part?.tool || '').trim().toLowerCase()
+  const input = part?.state?.input && typeof part.state.input === 'object'
+    ? part.state.input
+    : {}
+  return tool === 'task' && Boolean(String(input.subagent_type || '').trim())
+}
+
+function extractOpenCodeSubAgentSessionId(event = {}, output = '') {
+  const metadataSessionId = String(event?.part?.state?.metadata?.sessionId || '').trim()
+  if (metadataSessionId) {
+    return metadataSessionId
+  }
+
+  const matched = String(output || '').match(/task_id:\s*([^\s)]+)/i)
+  return matched?.[1] ? String(matched[1]).trim() : ''
+}
+
+function createOpenCodeSubAgentEvents(event = {}) {
+  const part = event?.part && typeof event.part === 'object' ? event.part : {}
+  const state = part?.state && typeof part.state === 'object' ? part.state : {}
+  const input = state?.input && typeof state.input === 'object' ? state.input : {}
+  const output = stringifyOpenCodeOutput(state?.output)
+  const sessionId = extractOpenCodeSubAgentSessionId(event, output)
+  const receiverThreadIds = sessionId ? [sessionId] : []
+  const collabPrompt = String(input.prompt || input.description || '').trim()
+  const collabStatus = normalizeCollabAgentStatus(state?.status)
+  const target = extractAgentTargetFromTexts(input.description, input.prompt, output)
+  const modelId = String(state?.metadata?.model?.modelID || '').trim()
+  const providerId = String(state?.metadata?.model?.providerID || '').trim()
+  const model = modelId
+    ? `${providerId ? `${providerId}/` : ''}${modelId}`
+    : ''
+  const agentsStates = sessionId
+    ? {
+        [sessionId]: {
+          status: collabStatus,
+          message: output,
+          title: String(input.description || part?.title || '').trim(),
+          role: String(input.subagent_type || '').trim(),
+          target,
+          model,
+        },
+      }
+    : {}
+  const spawnPayload = {
+    type: AGENT_RUN_ITEM_TYPES.COLLAB_TOOL_CALL,
+    tool: 'spawn_agent',
+    receiver_thread_ids: receiverThreadIds,
+    prompt: collabPrompt,
+    agents_states: agentsStates,
+  }
+
+  if (['completed', 'failed'].includes(collabStatus)) {
+    return [
+      createItemCompletedEvent(spawnPayload),
+      createItemCompletedEvent({
+        ...spawnPayload,
+        tool: 'wait',
+      }),
+    ]
+  }
+
+  return [createItemStartedEvent(spawnPayload)]
+}
+
 export function normalizeOpenCodeEvents(event = {}, state = createOpenCodeNormalizationState()) {
   const eventType = String(event?.type || '').trim().toLowerCase()
   const normalizedEvents = []
@@ -308,6 +410,10 @@ export function normalizeOpenCodeEvents(event = {}, state = createOpenCodeNormal
   }
 
   if (eventType === 'tool_use') {
+    if (isOpenCodeSubAgentTask(event)) {
+      return createOpenCodeSubAgentEvents(event)
+    }
+
     const command = buildOpenCodeToolCommand(event)
     const status = String(event?.part?.state?.status || '').trim().toLowerCase()
     const output = stringifyOpenCodeOutput(event?.part?.state?.output)