@muyichengshayu/promptx 0.2.8 → 0.2.9

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.2.9
+
+- 接入 `Kimi Code CLI` 执行引擎：工作台 Agent 选择器新增 Kimi Code 选项，支持本地会话发现、线程复用、TodoList 过程展示与停止控制，与现有 Codex / Claude Code / OpenCode 并列为第四类 Agent。
+- 工作台 Agent 选择器与过滤状态持久化：切换任务后会自动恢复上次选中的 Agent 引擎和中栏过滤条件，不再每次回到默认值。
+- runner 状态提示支持多语言：idle 进度提示（排队中、运行中、停止中）通过 `messageKey` 机制走前端 i18n 翻译，英文环境下显示对应英文文案。
+- 修复图片上传地址在云主机部署下失效的问题：前端 `API_BASE` 改为运行时按 `window.location.origin` 计算，数据库中只存相对路径；同时兼容已存的老数据（`localhost` / `127.0.0.1` 绝对路径在显示时自动替换为当前 host），runner 收到的 prompt 仍会正确转换为本地地址。
+
 ## 0.2.8
 
 - 修复 `Claude Code` 的 `TodoWrite` 过程映射：待办列表会被归一为结构化 `todo_list` 事件，正确展示待办内容、进行中与已完成状态，不再只暴露原始工具输入。

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

@@ -7,12 +7,14 @@ import {
 import { codexRunner } from './codexRunner.js'
 import { claudeCodeRunner } from './claudeCodeRunner.js'
 import { openCodeRunner } from './openCodeRunner.js'
+import { kimiCodeRunner } from './kimiCodeRunner.js'
 import { shellRunner } from './shellRunner.js'
 
 const runnerRegistry = new Map([
   [codexRunner.engine, codexRunner],
   [claudeCodeRunner.engine, claudeCodeRunner],
   [openCodeRunner.engine, openCodeRunner],
+  [kimiCodeRunner.engine, kimiCodeRunner],
   [shellRunner.engine, shellRunner],
 ])
 

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

@@ -0,0 +1,561 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { execFileSync, spawn } from 'node:child_process'
+import {
+  AGENT_ENGINES,
+  AGENT_RUN_ITEM_TYPES,
+  createAgentEventEnvelopeEvent,
+  createCompletedEnvelopeEvent,
+  createItemCompletedEvent,
+  createItemStartedEvent,
+  createStatusEnvelopeEvent,
+  createStderrEnvelopeEvent,
+  createStdoutEnvelopeEvent,
+  createThreadStartedEvent,
+  createTurnCompletedEvent,
+  getAgentEngineLabel,
+} from '../../../../packages/shared/src/index.js'
+import { createManagedSpawnOptions, forceStopChildProcess } from '../processControl.js'
+
+const KIMI_CODE_BIN = process.env.KIMI_CODE_BIN || 'kimi'
+const RESOLVED_KIMI_CODE_BIN = resolveKimiCodeBinary()
+
+function resolveKimiCodeBinary() {
+  if (process.platform !== 'win32') {
+    return KIMI_CODE_BIN
+  }
+
+  if (path.extname(KIMI_CODE_BIN)) {
+    return KIMI_CODE_BIN
+  }
+
+  if (fs.existsSync(`${KIMI_CODE_BIN}.cmd`)) {
+    return `${KIMI_CODE_BIN}.cmd`
+  }
+
+  if (fs.existsSync(`${KIMI_CODE_BIN}.bat`)) {
+    return `${KIMI_CODE_BIN}.bat`
+  }
+
+  if (fs.existsSync(KIMI_CODE_BIN)) {
+    return KIMI_CODE_BIN
+  }
+
+  try {
+    const output = execFileSync('where.exe', [KIMI_CODE_BIN], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      windowsHide: true,
+    }).trim()
+
+    if (!output) {
+      return KIMI_CODE_BIN
+    }
+
+    const candidates = output
+      .split(/\r?\n/g)
+      .map((line) => line.trim())
+      .filter(Boolean)
+
+    return candidates.find((item) => /\.(cmd|bat)$/i.test(item))
+      || candidates.find((item) => /\.(exe|com)$/i.test(item))
+      || candidates[0]
+      || KIMI_CODE_BIN
+  } catch {
+    return KIMI_CODE_BIN
+  }
+}
+
+function createKimiSpawn(commandArgs = [], cwd = '') {
+  const options = createManagedSpawnOptions({
+    cwd,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+
+  if (process.platform === 'win32' && /\.(cmd|bat)$/i.test(RESOLVED_KIMI_CODE_BIN)) {
+    return spawn(
+      process.env.ComSpec || 'cmd.exe',
+      ['/d', '/s', '/c', RESOLVED_KIMI_CODE_BIN, ...commandArgs],
+      options
+    )
+  }
+
+  return spawn(RESOLVED_KIMI_CODE_BIN, commandArgs, options)
+}
+
+function normalizeSpawnError(error) {
+  if (error?.code === 'ENOENT') {
+    const attempted = RESOLVED_KIMI_CODE_BIN === KIMI_CODE_BIN
+      ? KIMI_CODE_BIN
+      : `${KIMI_CODE_BIN} -> ${RESOLVED_KIMI_CODE_BIN}`
+    return new Error(
+      `找不到 Kimi Code CLI（尝试执行：${attempted}）。请先确认终端里可以运行 \`kimi --version\`，或设置环境变量 \`KIMI_CODE_BIN\`。`
+    )
+  }
+
+  return error
+}
+
+function parseJsonLine(line = '') {
+  const text = String(line || '').trim()
+  if (!text) {
+    return null
+  }
+
+  try {
+    return JSON.parse(text)
+  } catch {
+    return null
+  }
+}
+
+function splitBufferedLines(buffer = '') {
+  const text = String(buffer || '')
+  if (!text) {
+    return { lines: [], rest: '' }
+  }
+
+  const normalized = text.replace(/\r\n/g, '\n')
+  const parts = normalized.split('\n')
+  const rest = parts.pop() || ''
+
+  return {
+    lines: parts.map((line) => line.trim()).filter(Boolean),
+    rest,
+  }
+}
+
+function flushBufferedText(buffer = '') {
+  const { lines, rest } = splitBufferedLines(buffer)
+  const tail = String(rest || '').trim()
+  return tail ? [...lines, tail] : lines
+}
+
+function stringifyKimiToolResultContent(value) {
+  if (typeof value === 'string') {
+    return value.trim()
+  }
+
+  if (value == null) {
+    return ''
+  }
+
+  if (Array.isArray(value)) {
+    const parts = []
+    for (const item of value) {
+      if (item && typeof item === 'object') {
+        const text = String(item.text || '').trim()
+        if (text) parts.push(text)
+      } else if (typeof item === 'string') {
+        const text = item.trim()
+        if (text) parts.push(text)
+      }
+    }
+    return parts.join('\n').trim()
+  }
+
+  try {
+    const compact = JSON.stringify(value)
+    return compact.length <= 12000 ? compact : `${compact.slice(0, 11997)}...`
+  } catch {
+    return String(value || '').trim()
+  }
+}
+
+function buildKimiToolCommand(name = '', input = {}) {
+  const toolName = String(name || 'Kimi tool').trim() || 'Kimi tool'
+  if (!input || typeof input !== 'object') {
+    return toolName
+  }
+
+  const command = String(input.command || '').trim()
+  if (command) {
+    return `${toolName}: ${command}`
+  }
+
+  const singleValueKeys = ['file_path', 'path', 'pattern', 'query', 'url', 'description']
+  for (const key of singleValueKeys) {
+    const value = String(input[key] || '').trim()
+    if (value) {
+      return `${toolName}: ${value}`
+    }
+  }
+
+  try {
+    const compact = JSON.stringify(input)
+    return compact.length <= 240 ? `${toolName}: ${compact}` : `${toolName}: ${compact.slice(0, 237)}...`
+  } catch {
+    return toolName
+  }
+}
+
+function isKimiTodoToolName(name = '') {
+  return String(name || '').trim().toLowerCase() === 'settodolist'
+}
+
+function normalizeKimiTodoStatus(status = '') {
+  const normalized = String(status || '').trim().toLowerCase()
+  if (normalized === 'done') {
+    return 'completed'
+  }
+  if (normalized === 'in_progress') {
+    return 'in_progress'
+  }
+  return 'pending'
+}
+
+function normalizeKimiTodoItems(items = []) {
+  return (Array.isArray(items) ? items : [])
+    .map((entry) => {
+      if (!entry || typeof entry !== 'object') {
+        return null
+      }
+
+      const status = normalizeKimiTodoStatus(entry.status)
+      const text = String(entry.title || entry.text || '').trim()
+      if (!text) {
+        return null
+      }
+
+      return {
+        text,
+        status,
+        completed: status === 'completed',
+      }
+    })
+    .filter(Boolean)
+}
+
+function extractKimiSessionIdFromStderrLine(line = '') {
+  const match = String(line || '').match(/To resume this session:\s*kimi\s+(?:-r|--session|--resume)\s+([a-f0-9-]+)/i)
+  return match?.[1] ? String(match[1]).trim() : ''
+}
+
+export function isKimiInfoStderrLine(line = '') {
+  const text = String(line || '').trim()
+  if (!text) {
+    return true
+  }
+  if (/^To resume this session:/i.test(text)) {
+    return true
+  }
+  if (/^Shell cwd was reset to /i.test(text)) {
+    return true
+  }
+  return false
+}
+
+export function createKimiNormalizationState() {
+  return {
+    turnStarted: false,
+    toolUses: new Map(),
+  }
+}
+
+export function normalizeKimiEvents(event = {}, state = createKimiNormalizationState()) {
+  const role = String(event?.role || '').trim().toLowerCase()
+  const normalizedEvents = []
+
+  if (role === 'assistant') {
+    if (!state.turnStarted) {
+      state.turnStarted = true
+      normalizedEvents.push({ type: 'turn.started' })
+    }
+
+    const content = Array.isArray(event.content) ? event.content : []
+    content.forEach((block) => {
+      const blockType = String(block?.type || '').trim().toLowerCase()
+      if (blockType === 'think') {
+        const text = String(block?.think || '').trim()
+        if (text) {
+          normalizedEvents.push({
+            ...createItemStartedEvent({
+              type: AGENT_RUN_ITEM_TYPES.REASONING,
+              text,
+            }),
+          })
+        }
+        return
+      }
+
+      if (blockType === 'text') {
+        const text = String(block?.text || '').trim()
+        if (text) {
+          normalizedEvents.push({
+            ...createItemCompletedEvent({
+              type: AGENT_RUN_ITEM_TYPES.AGENT_MESSAGE,
+              text,
+            }),
+          })
+        }
+        return
+      }
+    })
+
+    const toolCalls = Array.isArray(event.tool_calls) ? event.tool_calls : []
+    toolCalls.forEach((toolCall) => {
+      const toolUseId = String(toolCall?.id || '').trim()
+      const name = String(toolCall?.function?.name || toolCall?.name || 'Kimi tool').trim() || 'Kimi tool'
+      const argsText = toolCall?.function?.arguments || toolCall?.arguments || '{}'
+      let parsedArgs = {}
+      try {
+        parsedArgs = JSON.parse(argsText)
+      } catch {
+        parsedArgs = {}
+      }
+      const command = buildKimiToolCommand(name, parsedArgs)
+      const isTodoTool = isKimiTodoToolName(name)
+      const todoItems = normalizeKimiTodoItems(parsedArgs.todos)
+
+      if (toolUseId) {
+        state.toolUses.set(toolUseId, {
+          name,
+          command,
+          kind: isTodoTool ? 'todo' : 'command',
+          todoItems,
+        })
+      }
+
+      if (isTodoTool) {
+        normalizedEvents.push({
+          ...createItemStartedEvent({
+            type: AGENT_RUN_ITEM_TYPES.TODO_LIST,
+            items: todoItems,
+          }),
+        })
+        return
+      }
+
+      normalizedEvents.push({
+        ...createItemStartedEvent({
+          type: AGENT_RUN_ITEM_TYPES.COMMAND_EXECUTION,
+          command,
+          status: 'in_progress',
+        }),
+      })
+    })
+
+    return normalizedEvents
+  }
+
+  if (role === 'tool') {
+    const toolCallId = String(event?.tool_call_id || '').trim()
+    const remembered = toolCallId ? state.toolUses.get(toolCallId) : null
+    const output = stringifyKimiToolResultContent(event?.content)
+    const todoTool = remembered?.kind === 'todo'
+
+    if (toolCallId) {
+      state.toolUses.delete(toolCallId)
+    }
+
+    if (todoTool) {
+      normalizedEvents.push({
+        ...createItemCompletedEvent({
+          type: AGENT_RUN_ITEM_TYPES.TODO_LIST,
+          items: Array.isArray(remembered?.todoItems) ? remembered.todoItems : [],
+        }),
+      })
+      return normalizedEvents
+    }
+
+    normalizedEvents.push({
+      ...createItemCompletedEvent({
+        type: AGENT_RUN_ITEM_TYPES.COMMAND_EXECUTION,
+        command: remembered?.command || remembered?.name || 'Kimi tool',
+        status: 'completed',
+        exit_code: 0,
+        aggregated_output: output,
+      }),
+    })
+
+    return normalizedEvents
+  }
+
+  return [{
+    type: `kimi.${role || 'event'}`,
+    detail: stringifyKimiToolResultContent(event?.content),
+  }]
+}
+
+export function normalizeKimiEvent(event = {}, state = createKimiNormalizationState()) {
+  return normalizeKimiEvents(event, state)[0] || null
+}
+
+function createExecArgs(session, prompt) {
+  const args = [
+    '--print',
+    '--output-format', 'stream-json',
+  ]
+
+  const sessionId = String(session?.engineSessionId || session?.engineThreadId || session?.codexThreadId || '').trim()
+  if (sessionId) {
+    args.push('--session', sessionId)
+  }
+
+  if (session?.cwd) {
+    args.push('--work-dir', session.cwd)
+  }
+
+  args.push('-p', String(prompt || ''))
+
+  return args
+}
+
+function createKimiRunStatusEvent(session = {}) {
+  const hasExistingThread = Boolean(
+    String(session?.engineSessionId || session?.engineThreadId || session?.codexThreadId || '').trim()
+  )
+
+  return createStatusEnvelopeEvent({
+    stage: hasExistingThread ? 'resuming' : 'starting',
+    message: hasExistingThread
+      ? '已连接 PromptX 项目，正在继续这轮执行。'
+      : '已创建 PromptX 项目，正在启动第一轮执行。',
+  })
+}
+
+export function streamPromptToKimiCodeSession(sessionInput, prompt, callbacks = {}) {
+  const session = sessionInput && typeof sessionInput === 'object' ? sessionInput : null
+  const normalizedPrompt = String(prompt || '').trim()
+
+  if (!session?.id || !session?.cwd) {
+    throw new Error('缺少 PromptX 项目。')
+  }
+  if (!normalizedPrompt) {
+    throw new Error('没有可发送的提示词。')
+  }
+
+  const onEvent = typeof callbacks.onEvent === 'function' ? callbacks.onEvent : () => {}
+  const onThreadStarted = typeof callbacks.onThreadStarted === 'function' ? callbacks.onThreadStarted : () => {}
+
+  const child = createKimiSpawn(createExecArgs(session, normalizedPrompt), session.cwd)
+  onEvent(createKimiRunStatusEvent(session))
+
+  let stdoutBuffer = ''
+  let stderrBuffer = ''
+  let lastStderrLine = ''
+  let finalMessage = ''
+  let finalSessionId = String(session.engineSessionId || session.engineThreadId || session.codexThreadId || '').trim()
+  const normalizationState = createKimiNormalizationState()
+
+  const rememberSessionId = (sessionId) => {
+    const value = String(sessionId || '').trim()
+    if (!value || value === finalSessionId) {
+      return
+    }
+
+    finalSessionId = value
+    onThreadStarted(value)
+  }
+
+  const emitKimiJsonLine = (line) => {
+    const event = parseJsonLine(line)
+    if (!event) {
+      onEvent(createStdoutEnvelopeEvent(line))
+      return
+    }
+
+    const normalizedEvents = normalizeKimiEvents(event, normalizationState)
+    normalizedEvents.forEach((normalizedEvent) => {
+      onEvent(createAgentEventEnvelopeEvent(normalizedEvent))
+    })
+
+    const role = String(event?.role || '').trim().toLowerCase()
+    if (role === 'assistant') {
+      const content = Array.isArray(event.content) ? event.content : []
+      const textBlocks = content
+        .filter((block) => String(block?.type || '').trim().toLowerCase() === 'text')
+        .map((block) => String(block?.text || '').trim())
+        .filter(Boolean)
+
+      if (textBlocks.length) {
+        const text = textBlocks.join('\n').trim()
+        finalMessage = `${finalMessage}${finalMessage ? '\n' : ''}${text}`
+      }
+    }
+  }
+
+  child.stdout.on('data', (chunk) => {
+    stdoutBuffer += chunk.toString()
+    const { lines, rest } = splitBufferedLines(stdoutBuffer)
+    stdoutBuffer = rest
+    lines.forEach(emitKimiJsonLine)
+  })
+
+  child.stderr.on('data', (chunk) => {
+    stderrBuffer += chunk.toString()
+    const { lines, rest } = splitBufferedLines(stderrBuffer)
+    stderrBuffer = rest
+    lines.forEach((line) => {
+      const sessionId = extractKimiSessionIdFromStderrLine(line)
+      if (sessionId) {
+        rememberSessionId(sessionId)
+      }
+
+      if (isKimiInfoStderrLine(line)) {
+        return
+      }
+
+      lastStderrLine = line
+      onEvent(createStderrEnvelopeEvent(line))
+    })
+  })
+
+  const result = new Promise((resolve, reject) => {
+    child.on('error', (error) => {
+      reject(normalizeSpawnError(error))
+    })
+
+    child.on('close', (code) => {
+      flushBufferedText(stdoutBuffer).forEach(emitKimiJsonLine)
+      flushBufferedText(stderrBuffer).forEach((line) => {
+        const sessionId = extractKimiSessionIdFromStderrLine(line)
+        if (sessionId) {
+          rememberSessionId(sessionId)
+        }
+
+        if (isKimiInfoStderrLine(line)) {
+          return
+        }
+
+        lastStderrLine = line
+        onEvent(createStderrEnvelopeEvent(line))
+      })
+
+      if (code !== 0) {
+        reject(new Error(lastStderrLine || 'Kimi Code 执行失败。'))
+        return
+      }
+
+      const message = finalMessage.trim()
+      onEvent(createAgentEventEnvelopeEvent(createTurnCompletedEvent()))
+      onEvent(createCompletedEnvelopeEvent(message))
+
+      resolve({
+        sessionId: session.id,
+        threadId: finalSessionId,
+        message,
+      })
+    })
+  })
+
+  return {
+    child,
+    result,
+    cancel(options = {}) {
+      forceStopChildProcess(child, options)
+    },
+  }
+}
+
+export const kimiCodeRunner = {
+  engine: AGENT_ENGINES.KIMI_CODE,
+  label: getAgentEngineLabel(AGENT_ENGINES.KIMI_CODE),
+  supportsWorkspaceHistory: false,
+  listKnownWorkspaces() {
+    return []
+  },
+  streamSessionPrompt(session, prompt, callbacks = {}) {
+    return streamPromptToKimiCodeSession(session, prompt, callbacks)
+  },
+}

package/apps/runner/src/runManager.js

@@ -216,6 +216,7 @@ function createIdleProgressEvent(context = {}) {
     return createStatusEnvelopeEvent({
       stage: 'queued',
       message: '当前仍在排队，等待 runner 空闲后开始执行。',
+      messageKey: 'runner.status.queued',
     })
   }
 
@@ -223,12 +224,16 @@ function createIdleProgressEvent(context = {}) {
     return createStatusEnvelopeEvent({
       stage: 'stopping',
       message: '正在停止执行，等待引擎退出...',
+      messageKey: 'runner.status.stopping',
     })
   }
 
+  const agentLabel = getAgentEngineLabel(context.engine || 'codex')
   return createStatusEnvelopeEvent({
     stage: 'running',
-    message: `${getAgentEngineLabel(context.engine || 'codex')} 仍在执行中，最近暂无新的过程输出。`,
+    message: `${agentLabel} 正在思考中...`,
+    messageKey: 'runner.status.thinking',
+    messageParams: { agentLabel },
   })
 }