@muyichengshayu/promptx 0.1.7 → 0.1.9

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.1.9
+
+- 新增 `PromptX Glass Light` 毛玻璃主题，统一覆盖工作台主容器、任务列表、设置面板、弹窗、下拉、状态标签与图片预览层。
+- 优化执行区视觉层次，补齐提示词 / 执行过程 / 回复三类消息卡片，以及 Markdown 中引用、代码块、表格等内容样式。
+- 单独收敛手机端观感：压低玻璃强度与阴影，收紧任务卡、详情头部、设置页导航与表单布局。
+- 修复 Markdown 表格在新主题下布局错乱的问题，改为使用外层滚动容器承载表格边框与横向滚动。
+- 编辑区右上角主按钮在任务执行中保持“发送”文案并禁用，不再切换成“停止”，减少误触和语义跳变。
+
+## 0.1.8
+
+- 新增 OpenCode 执行引擎接入，补齐 runner、契约测试、Doctor 检查与文档说明，并支持在项目配置里直接选择 OpenCode。
+- 项目管理里的执行引擎列表改为服务端下发，避免前后端版本不一致时前端看不到新引擎选项。
+- 优化项目编辑规则：项目未执行前允许切换执行引擎，执行后自动锁定，保持与工作目录一致的配置心智。
+- 强化运行停止逻辑：用户点击停止后会立即进入强制停止流程，并补齐更可靠的跨平台子进程终止处理与“正在停止...”反馈。
+
 ## 0.1.7
 
 - 新增多引擎运行器抽象，除了 Codex 之外，现已支持接入 Claude Code，并统一项目层的执行引擎配置与展示。

package/README.md

@@ -2,13 +2,14 @@
 
 PromptX 是一个面向本机 AI 协作的轻量工作台。
 
-它适合先整理需求、截图、文本、PDF、禅道 Bug 等上下文，再持续发送给本机 Codex，在同一页里查看执行过程和多轮结果。
+它适合先整理需求、截图、文本、PDF、禅道 Bug 等上下文，再持续发送给本机 AI Agent，在同一页里查看执行过程和多轮结果。
 
 ## 核心能力
 
 - 左侧管理任务，中间查看项目执行过程，右侧整理输入内容
 - 支持文本、图片、`md`、`txt`、`pdf`
-- 支持为任务绑定本机项目，并持续复用同一个 Codex 线程
+- 支持为任务绑定本机项目，并持续复用同一个执行引擎线程
+- 支持多执行引擎，当前已接入 `Codex`、`Claude Code`、`OpenCode`
 - 支持查看执行过程、代码变更和最终回复
 - 支持公开页与 Raw 导出
 - 内置禅道 Chrome 扩展，可一键把 Bug 内容带入工作台
@@ -30,8 +31,12 @@ PromptX 是一个面向本机 AI 协作的轻量工作台。
 ## 运行前提
 
 - 已安装 Node，支持 `20`、`22`、`24`，推荐 `22`
-- 本机可以正常运行 `codex --version`
-- Codex 已开启高权限，并使用满血模式
+- 本机至少安装一个可用执行引擎
+- 当前支持：
+  - `codex --version`
+  - `claude --version`
+  - `opencode --version`
+- 如使用 Codex，建议开启高权限并使用满血模式
 
 ## 安装
 
@@ -67,9 +72,21 @@ promptx doctor
 1. 打开工作台，新建或选择一个任务
 2. 在右侧整理文本、图片、文件等上下文
 3. 在中间选择一个 PromptX 项目
-4. 点击发送，把当前内容交给 Codex
+4. 为项目选择执行引擎，并点击发送
 5. 在中间继续查看执行过程，并按需多轮发送
 
+## 当前支持的执行引擎
+
+- `Codex`
+- `Claude Code`
+- `OpenCode`
+
+PromptX 内部已经开始使用统一的 agent run 事件协议，后续继续扩展其他执行引擎时，前端展示层和执行过程面板可以尽量复用。
+
+如需查看这套协议约定，可参考：
+
+- `docs/agent-run-protocol.md`
+
 ## 远程访问 Relay（预览）
 
 如果你希望在手机上远程访问自己电脑上的 PromptX，或想在云端部署多租户 Relay，请直接查看：
@@ -103,10 +120,10 @@ promptx doctor
 
 ## 注意事项
 
-- 当前只支持 Codex，不支持其他模型后端
 - 当前以本机单用户使用为主，不包含账号体系和团队权限
 - 默认仅监听本机地址；如需跨设备访问，建议通过 Tailscale
-- 如果 Codex 运行在受限权限下，文件读写和自动修改能力会明显受限
+- 如果执行引擎运行在受限权限下，文件读写和自动修改能力会明显受限
+- 不同执行引擎的工具能力、输出事件丰富度和稳定性可能会有差异
 
 ## 本地数据目录
 

package/apps/server/src/agents/claudeCodeRunner.js

@@ -16,6 +16,7 @@ import {
   createTurnCompletedEvent,
   getAgentEngineLabel,
 } from '../../../../packages/shared/src/index.js'
+import { createManagedSpawnOptions, forceStopChildProcess } from '../processControl.js'
 
 const CLAUDE_CODE_BIN = process.env.CLAUDE_CODE_BIN || 'claude'
 const CLAUDE_DEFAULT_ARGS = ['--dangerously-skip-permissions']
@@ -68,16 +69,10 @@ function resolveClaudeCodeBinary() {
 }
 
 function createClaudeSpawn(commandArgs = [], cwd = '') {
-  const options = {
-    env: process.env,
+  const options = createManagedSpawnOptions({
+    cwd,
     stdio: ['ignore', 'pipe', 'pipe'],
-    windowsHide: true,
-  }
-
-  const normalizedCwd = String(cwd || '').trim()
-  if (normalizedCwd) {
-    options.cwd = normalizedCwd
-  }
+  })
 
   if (process.platform === 'win32' && /\.(cmd|bat)$/i.test(RESOLVED_CLAUDE_CODE_BIN)) {
     return spawn(
@@ -524,9 +519,7 @@ export function streamPromptToClaudeCodeSession(sessionInput, prompt, callbacks
     child,
     result,
     cancel() {
-      if (!child.killed) {
-        child.kill('SIGTERM')
-      }
+      forceStopChildProcess(child)
     },
   }
 }

package/apps/server/src/agents/index.js

@@ -6,10 +6,12 @@ import {
 } from '../../../../packages/shared/src/index.js'
 import { codexRunner } from './codexRunner.js'
 import { claudeCodeRunner } from './claudeCodeRunner.js'
+import { openCodeRunner } from './openCodeRunner.js'
 
 const runnerRegistry = new Map([
   [codexRunner.engine, codexRunner],
   [claudeCodeRunner.engine, claudeCodeRunner],
+  [openCodeRunner.engine, openCodeRunner],
 ])
 
 export function getAgentRunner(engine = AGENT_ENGINES.CODEX) {

package/apps/server/src/agents/openCodeRunner.js

@@ -0,0 +1,459 @@
+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,
+  createErrorEvent,
+  createItemCompletedEvent,
+  createItemStartedEvent,
+  createStatusEnvelopeEvent,
+  createStderrEnvelopeEvent,
+  createStdoutEnvelopeEvent,
+  createThreadStartedEvent,
+  createTurnCompletedEvent,
+  getAgentEngineLabel,
+} from '../../../../packages/shared/src/index.js'
+import { createManagedSpawnOptions, forceStopChildProcess } from '../processControl.js'
+
+const OPENCODE_BIN = process.env.OPENCODE_BIN || 'opencode'
+const RESOLVED_OPENCODE_BIN = resolveOpenCodeBinary()
+
+function resolveOpenCodeBinary() {
+  if (process.platform !== 'win32') {
+    return OPENCODE_BIN
+  }
+
+  if (path.extname(OPENCODE_BIN)) {
+    return OPENCODE_BIN
+  }
+
+  if (fs.existsSync(`${OPENCODE_BIN}.cmd`)) {
+    return `${OPENCODE_BIN}.cmd`
+  }
+
+  if (fs.existsSync(`${OPENCODE_BIN}.bat`)) {
+    return `${OPENCODE_BIN}.bat`
+  }
+
+  if (fs.existsSync(OPENCODE_BIN)) {
+    return OPENCODE_BIN
+  }
+
+  try {
+    const output = execFileSync('where.exe', [OPENCODE_BIN], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      windowsHide: true,
+    }).trim()
+
+    if (!output) {
+      return OPENCODE_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]
+      || OPENCODE_BIN
+  } catch {
+    return OPENCODE_BIN
+  }
+}
+
+function createOpenCodeSpawn(commandArgs = [], cwd = '') {
+  const options = createManagedSpawnOptions({
+    cwd,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+
+  if (process.platform === 'win32' && /\.(cmd|bat)$/i.test(RESOLVED_OPENCODE_BIN)) {
+    return spawn(
+      process.env.ComSpec || 'cmd.exe',
+      ['/d', '/s', '/c', RESOLVED_OPENCODE_BIN, ...commandArgs],
+      options
+    )
+  }
+
+  return spawn(RESOLVED_OPENCODE_BIN, commandArgs, options)
+}
+
+function normalizeSpawnError(error) {
+  if (error?.code === 'ENOENT') {
+    const attempted = RESOLVED_OPENCODE_BIN === OPENCODE_BIN
+      ? OPENCODE_BIN
+      : `${OPENCODE_BIN} -> ${RESOLVED_OPENCODE_BIN}`
+
+    return new Error(
+      `找不到 OpenCode CLI（尝试执行：${attempted}）。请先确认终端里可以运行 \`opencode --version\`，或设置环境变量 \`OPENCODE_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 summarizeOpenCodeInput(input = {}) {
+  if (!input || typeof input !== 'object') {
+    return ''
+  }
+
+  const command = String(input.command || '').trim()
+  if (command) {
+    return command
+  }
+
+  const singleValueKeys = ['filePath', 'path', 'pattern', 'query', 'url', 'description']
+  for (const key of singleValueKeys) {
+    const value = String(input[key] || '').trim()
+    if (value) {
+      return value
+    }
+  }
+
+  try {
+    const compact = JSON.stringify(input)
+    return compact.length <= 240 ? compact : `${compact.slice(0, 237)}...`
+  } catch {
+    return ''
+  }
+}
+
+function stringifyOpenCodeOutput(output) {
+  if (typeof output === 'string') {
+    return output.trim()
+  }
+
+  if (output == null) {
+    return ''
+  }
+
+  try {
+    const compact = JSON.stringify(output)
+    return compact.length <= 12000 ? compact : `${compact.slice(0, 11997)}...`
+  } catch {
+    return String(output || '').trim()
+  }
+}
+
+function buildOpenCodeToolCommand(event = {}) {
+  const part = event?.part && typeof event.part === 'object' ? event.part : event
+  const toolName = String(part?.tool || 'OpenCode tool').trim() || 'OpenCode tool'
+  const input = part?.state?.input && typeof part.state.input === 'object'
+    ? part.state.input
+    : {}
+  const inputSummary = summarizeOpenCodeInput(input)
+  return inputSummary ? `${toolName}: ${inputSummary}` : toolName
+}
+
+export function extractOpenCodeText(event = {}) {
+  return String(event?.part?.text || event?.text || '').trim()
+}
+
+export function extractOpenCodeSessionId(event = {}) {
+  const candidates = [
+    event?.sessionID,
+    event?.sessionId,
+    event?.part?.sessionID,
+    event?.part?.sessionId,
+  ]
+
+  return candidates.map((value) => String(value || '').trim()).find(Boolean) || ''
+}
+
+export function extractOpenCodeUsage(event = {}) {
+  const tokens = event?.part?.tokens
+  if (!tokens || typeof tokens !== 'object') {
+    return null
+  }
+
+  return {
+    input_tokens: Number(tokens.input) || 0,
+    output_tokens: Number(tokens.output) || 0,
+    cached_input_tokens: Number(tokens.cache?.read) || 0,
+  }
+}
+
+function createOpenCodeRunStatusEvent(session = {}) {
+  const hasExistingThread = Boolean(
+    String(session?.engineSessionId || session?.engineThreadId || session?.codexThreadId || '').trim()
+  )
+
+  return createStatusEnvelopeEvent({
+    stage: hasExistingThread ? 'resuming' : 'starting',
+    message: hasExistingThread
+      ? '已连接 PromptX 项目，正在继续这轮执行。'
+      : '已创建 PromptX 项目，正在启动第一轮执行。',
+  })
+}
+
+export function createOpenCodeNormalizationState() {
+  return {
+    turnStarted: false,
+  }
+}
+
+export function normalizeOpenCodeEvents(event = {}, state = createOpenCodeNormalizationState()) {
+  const eventType = String(event?.type || '').trim().toLowerCase()
+  const normalizedEvents = []
+
+  if (eventType === 'step_start') {
+    if (!state.turnStarted) {
+      state.turnStarted = true
+      normalizedEvents.push({ type: 'turn.started' })
+    }
+    return normalizedEvents
+  }
+
+  if (eventType === 'tool_use') {
+    const command = buildOpenCodeToolCommand(event)
+    const status = String(event?.part?.state?.status || '').trim().toLowerCase()
+    const output = stringifyOpenCodeOutput(event?.part?.state?.output)
+
+    normalizedEvents.push(createItemStartedEvent({
+      type: AGENT_RUN_ITEM_TYPES.COMMAND_EXECUTION,
+      command,
+      status: 'in_progress',
+    }))
+
+    if (status === 'completed' || status === 'failed' || status === 'error') {
+      normalizedEvents.push(createItemCompletedEvent({
+        type: AGENT_RUN_ITEM_TYPES.COMMAND_EXECUTION,
+        command,
+        status: status === 'completed' ? 'completed' : 'failed',
+        exit_code: status === 'completed' ? 0 : 1,
+        aggregated_output: output,
+      }))
+    }
+
+    return normalizedEvents
+  }
+
+  if (eventType === 'text') {
+    const text = extractOpenCodeText(event)
+    if (!text) {
+      return normalizedEvents
+    }
+
+    normalizedEvents.push(createItemCompletedEvent({
+      type: AGENT_RUN_ITEM_TYPES.AGENT_MESSAGE,
+      text,
+    }))
+    return normalizedEvents
+  }
+
+  if (eventType === 'step_finish') {
+    const reason = String(event?.part?.reason || '').trim().toLowerCase()
+    if (reason === 'stop') {
+      const usage = extractOpenCodeUsage(event)
+      normalizedEvents.push(createTurnCompletedEvent(usage ? { usage } : {}))
+      return normalizedEvents
+    }
+
+    return normalizedEvents
+  }
+
+  if (eventType === 'error') {
+    const message = extractOpenCodeText(event) || String(event?.message || event?.error || '').trim()
+    if (message) {
+      normalizedEvents.push(createErrorEvent(message))
+    }
+    return normalizedEvents
+  }
+
+  return [{
+    type: `opencode.${eventType || 'event'}`,
+    detail: extractOpenCodeText(event),
+  }]
+}
+
+export function normalizeOpenCodeEvent(event = {}, state = createOpenCodeNormalizationState()) {
+  return normalizeOpenCodeEvents(event, state)[0] || null
+}
+
+function createExecArgs(session, prompt) {
+  const args = [
+    'run',
+    '--format',
+    'json',
+  ]
+
+  const sessionId = String(session?.engineSessionId || session?.engineThreadId || session?.codexThreadId || '').trim()
+  if (sessionId) {
+    args.push('--session', sessionId)
+  }
+
+  if (session?.cwd) {
+    args.push('--dir', session.cwd)
+  }
+
+  args.push(String(prompt || ''))
+  return args
+}
+
+export function streamPromptToOpenCodeSession(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 = createOpenCodeSpawn(createExecArgs(session, normalizedPrompt), session.cwd)
+  onEvent(createOpenCodeRunStatusEvent(session))
+
+  let stdoutBuffer = ''
+  let stderrBuffer = ''
+  let lastStderrLine = ''
+  let finalMessage = ''
+  let finalSessionId = String(session.engineSessionId || session.engineThreadId || session.codexThreadId || '').trim()
+  const normalizationState = createOpenCodeNormalizationState()
+
+  const rememberSessionId = (sessionId) => {
+    const value = String(sessionId || '').trim()
+    if (!value || value === finalSessionId) {
+      return
+    }
+
+    finalSessionId = value
+    onThreadStarted(value)
+    onEvent(createAgentEventEnvelopeEvent(createThreadStartedEvent(value)))
+  }
+
+  const emitOpenCodeJsonLine = (line) => {
+    const event = parseJsonLine(line)
+    if (!event) {
+      onEvent(createStdoutEnvelopeEvent(line))
+      return
+    }
+
+    const sessionId = extractOpenCodeSessionId(event)
+    if (sessionId) {
+      rememberSessionId(sessionId)
+    }
+
+    const normalizedEvents = normalizeOpenCodeEvents(event, normalizationState)
+    normalizedEvents.forEach((normalizedEvent) => {
+      onEvent(createAgentEventEnvelopeEvent(normalizedEvent))
+    })
+
+    if (String(event?.type || '').trim().toLowerCase() === 'text') {
+      const text = extractOpenCodeText(event)
+      if (text) {
+        finalMessage = `${finalMessage}${finalMessage ? '\n' : ''}${text}`
+      }
+    }
+  }
+
+  child.stdout.on('data', (chunk) => {
+    stdoutBuffer += chunk.toString()
+    const { lines, rest } = splitBufferedLines(stdoutBuffer)
+    stdoutBuffer = rest
+    lines.forEach(emitOpenCodeJsonLine)
+  })
+
+  child.stderr.on('data', (chunk) => {
+    stderrBuffer += chunk.toString()
+    const { lines, rest } = splitBufferedLines(stderrBuffer)
+    stderrBuffer = rest
+    lines.forEach((line) => {
+      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(emitOpenCodeJsonLine)
+      flushBufferedText(stderrBuffer).forEach((line) => {
+        lastStderrLine = line
+        onEvent(createStderrEnvelopeEvent(line))
+      })
+
+      if (code !== 0) {
+        reject(new Error(lastStderrLine || 'OpenCode 执行失败。'))
+        return
+      }
+
+      const message = finalMessage.trim()
+      onEvent(createCompletedEnvelopeEvent(message))
+
+      resolve({
+        sessionId: session.id,
+        threadId: finalSessionId,
+        message,
+      })
+    })
+  })
+
+  return {
+    child,
+    result,
+    cancel() {
+      forceStopChildProcess(child)
+    },
+  }
+}
+
+export const openCodeRunner = {
+  engine: AGENT_ENGINES.OPENCODE,
+  label: getAgentEngineLabel(AGENT_ENGINES.OPENCODE),
+  supportsWorkspaceHistory: false,
+  listKnownWorkspaces() {
+    return []
+  },
+  streamSessionPrompt(session, prompt, callbacks = {}) {
+    return streamPromptToOpenCodeSession(session, prompt, callbacks)
+  },
+}

package/apps/server/src/codex.js

@@ -13,6 +13,7 @@ import {
   createStderrEnvelopeEvent,
   createStdoutEnvelopeEvent,
 } from '../../../packages/shared/src/index.js'
+import { createManagedSpawnOptions, forceStopChildProcess } from './processControl.js'
 
 const CODEX_BIN = process.env.CODEX_BIN || 'codex'
 const CODEX_HOME = process.env.CODEX_HOME || path.join(os.homedir(), '.codex')
@@ -79,16 +80,10 @@ function resolveCodexBinary() {
 }
 
 function createCodexSpawn(commandArgs = [], cwd = '') {
-  const options = {
-    env: process.env,
+  const options = createManagedSpawnOptions({
+    cwd,
     stdio: ['pipe', 'pipe', 'pipe'],
-    windowsHide: true,
-  }
-  const normalizedCwd = String(cwd || '').trim()
-
-  if (normalizedCwd) {
-    options.cwd = normalizedCwd
-  }
+  })
 
   if (process.platform === 'win32' && /\.(cmd|bat)$/i.test(RESOLVED_CODEX_BIN)) {
     return spawn(
@@ -550,25 +545,10 @@ export function streamPromptToCodexSession(sessionInput, prompt, callbacks = {})
     child,
     result,
     cancel() {
-      if (child.killed) {
+      if (child.killed || !child.pid) {
         return
       }
-
-      if (process.platform === 'win32' && child.pid) {
-        try {
-          execFileSync('taskkill.exe', ['/PID', String(child.pid), '/T', '/F'], {
-            stdio: 'ignore',
-            windowsHide: true,
-          })
-          return
-        } catch {
-          // Fall through to the default child kill when taskkill is unavailable.
-        }
-      }
-
-      if (!child.killed) {
-        child.kill('SIGTERM')
-      }
+      forceStopChildProcess(child)
     },
   }
 }