@fieldwangai/agentflow 0.1.84 → 0.1.86

package/bin/lib/composer-agent.mjs

@@ -10,7 +10,7 @@ import path from "path";
 import { getAgentflowDataRoot, getAgentflowUserDataRoot, sanitizeAgentflowUserId } from "./paths.mjs";
 import { readMergedEnvObject } from "./user-env.mjs";
 import { resolveCliAndModel } from "./model-config.mjs";
-import { runClaudeCodeAgentWithPrompt, runCursorAgentWithPrompt, runOpenCodeAgentWithPrompt } from "./agent-runners.mjs";
+import { runCodexAgentWithPrompt, runClaudeCodeAgentWithPrompt, runCursorAgentWithPrompt, runOpenCodeAgentWithPrompt } from "./agent-runners.mjs";
 import { planComposerTasks, hasPlannerApiAvailable, shouldUsePhased, classifyComplexity, classifyTaskComplexity, PHASED_DEFINITIONS } from "./composer-planner.mjs";
 import { executeScriptOp, isSupportedScriptOp } from "./composer-script-ops.mjs";
 import { routeModel } from "./composer-model-router.mjs";
@@ -152,12 +152,149 @@ function materializeWorkspaceCursorMcpPrivateConfig(workspaceRoot, userId) {
   };
 }
 
+function tomlString(value) {
+  return JSON.stringify(String(value ?? ""));
+}
+
+function tomlArray(values) {
+  return `[${(Array.isArray(values) ? values : []).map((value) => tomlString(value)).join(", ")}]`;
+}
+
+function tomlInlineTable(obj) {
+  const entries = Object.entries(obj && typeof obj === "object" && !Array.isArray(obj) ? obj : {})
+    .filter(([key]) => String(key || "").trim())
+    .map(([key, value]) => `${tomlString(String(key).trim())} = ${tomlString(value)}`);
+  return `{ ${entries.join(", ")} }`;
+}
+
+function codexMcpName(name, used) {
+  const base = String(name || "mcp")
+    .trim()
+    .replace(/[^A-Za-z0-9_-]+/g, "_")
+    .replace(/^_+|_+$/g, "") || "mcp";
+  let out = base;
+  let i = 2;
+  while (used.has(out)) out = `${base}_${i++}`;
+  used.add(out);
+  return out;
+}
+
+function bearerFromHeaders(headers) {
+  const obj = headers && typeof headers === "object" && !Array.isArray(headers) ? headers : {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (String(key).toLowerCase() !== "authorization") continue;
+    const match = String(value ?? "").match(/^Bearer\s+(.+)$/i);
+    if (match?.[1]) return match[1].trim();
+  }
+  return "";
+}
+
+function mergedCursorMcpServersForCodex(workspaceRoot, userId) {
+  const safe = sanitizeAgentflowUserId(userId);
+  const workspace = path.resolve(workspaceRoot || process.cwd());
+  const localServers = cursorMcpServersFromFile(path.join(workspace, ".cursor", "mcp.json"));
+  const globalServers = cursorMcpServersFromFile(path.join(os.homedir(), ".cursor", "mcp.json"));
+  const privateServers = safe ? readUserMcpPrivateServers(safe) : {};
+  const merged = { ...globalServers, ...localServers };
+
+  for (const [name, privateServer] of Object.entries(privateServers)) {
+    const current = merged[name];
+    if (!current || typeof current !== "object" || Array.isArray(current)) continue;
+    const privateEnv = privateServer?.env && typeof privateServer.env === "object" && !Array.isArray(privateServer.env) ? privateServer.env : {};
+    const privateHeaders = privateServer?.headers && typeof privateServer.headers === "object" && !Array.isArray(privateServer.headers) ? privateServer.headers : {};
+    const currentEnv = current.env && typeof current.env === "object" && !Array.isArray(current.env) ? current.env : {};
+    const currentHeaders = current.headers && typeof current.headers === "object" && !Array.isArray(current.headers) ? current.headers : {};
+    merged[name] = {
+      ...current,
+      ...(Object.keys(privateEnv).length ? { env: { ...currentEnv, ...privateEnv } } : {}),
+      ...(Object.keys(privateHeaders).length ? { headers: { ...currentHeaders, ...privateHeaders } } : {}),
+    };
+  }
+
+  return merged;
+}
+
+function codexMcpOverridesFromCursorConfig(workspaceRoot, userId) {
+  const safe = sanitizeAgentflowUserId(userId);
+  const privateServers = safe ? readUserMcpPrivateServers(safe) : {};
+  const servers = mergedCursorMcpServersForCodex(workspaceRoot, userId);
+  const used = new Set();
+  const codexConfigArgs = [];
+  const env = {};
+
+  for (const [rawName, rawServer] of Object.entries(servers)) {
+    if (!rawServer || typeof rawServer !== "object" || Array.isArray(rawServer)) continue;
+    if (rawServer.disabled === true) continue;
+    const name = codexMcpName(rawName, used);
+    const prefix = `mcp_servers.${name}`;
+    const envObj = rawServer.env && typeof rawServer.env === "object" && !Array.isArray(rawServer.env) ? rawServer.env : {};
+    const headers = rawServer.headers && typeof rawServer.headers === "object" && !Array.isArray(rawServer.headers) ? rawServer.headers : {};
+    const privateServer = privateServers[rawName];
+    const privateEnv = privateServer?.env && typeof privateServer.env === "object" && !Array.isArray(privateServer.env) ? privateServer.env : {};
+    const url = String(rawServer.url || "").trim();
+    const command = String(rawServer.command || "").trim();
+
+    if (url) {
+      codexConfigArgs.push(`${prefix}.url=${tomlString(url)}`);
+      if (rawServer.bearer_token_env_var && String(rawServer.bearer_token_env_var).trim()) {
+        codexConfigArgs.push(`${prefix}.bearer_token_env_var=${tomlString(rawServer.bearer_token_env_var)}`);
+      }
+      if (rawServer.oauth_client_id && String(rawServer.oauth_client_id).trim()) {
+        codexConfigArgs.push(`${prefix}.oauth_client_id=${tomlString(rawServer.oauth_client_id)}`);
+      }
+      if (rawServer.oauth_resource && String(rawServer.oauth_resource).trim()) {
+        codexConfigArgs.push(`${prefix}.oauth_resource=${tomlString(rawServer.oauth_resource)}`);
+      }
+      const bearer = bearerFromHeaders(headers);
+      if (bearer) {
+        const envKey = `AGENTFLOW_CODEX_MCP_${name.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_BEARER`;
+        env[envKey] = bearer;
+        codexConfigArgs.push(`${prefix}.bearer_token_env_var=${tomlString(envKey)}`);
+      }
+      continue;
+    }
+
+    if (!command) continue;
+    codexConfigArgs.push(`${prefix}.command=${tomlString(command)}`);
+    if (Array.isArray(rawServer.args) && rawServer.args.length) {
+      codexConfigArgs.push(`${prefix}.args=${tomlArray(rawServer.args)}`);
+    }
+    if (rawServer.cwd && String(rawServer.cwd).trim()) {
+      codexConfigArgs.push(`${prefix}.cwd=${tomlString(rawServer.cwd)}`);
+    }
+    const publicEnvForConfig = {};
+    for (const [key, value] of Object.entries(envObj)) {
+      const envKey = String(key || "").trim();
+      if (!envKey) continue;
+      if (Object.prototype.hasOwnProperty.call(privateEnv, envKey)) {
+        env[envKey] = String(privateEnv[envKey] ?? "");
+      } else {
+        publicEnvForConfig[envKey] = value;
+      }
+    }
+    if (Object.keys(publicEnvForConfig).length) {
+      codexConfigArgs.push(`${prefix}.env=${tomlInlineTable(publicEnvForConfig)}`);
+    }
+  }
+
+  return { codexConfigArgs, env };
+}
+
 function agentflowUserEnv(userId) {
   const safe = sanitizeAgentflowUserId(userId);
   pruneCursorMcpPrivateEnvPlaceholders();
   return { ...readMergedEnvObject(safe), ...(safe ? readUserMcpPrivateEnvObject(safe) : {}), AGENTFLOW_USER_ID: safe };
 }
 
+function runCodexAgentWithPrivateMcp(cliWorkspace, prompt, options, userId) {
+  const { codexConfigArgs, env } = codexMcpOverridesFromCursorConfig(cliWorkspace, userId);
+  return runCodexAgentWithPrompt(cliWorkspace, prompt, {
+    ...options,
+    codexConfigArgs: [...(Array.isArray(options?.codexConfigArgs) ? options.codexConfigArgs : []), ...codexConfigArgs],
+    env: { ...(options?.env || {}), ...env },
+  });
+}
+
 function runCursorAgentWithPrivateMcp(cliWorkspace, prompt, options, userId) {
   const restore = materializeWorkspaceCursorMcpPrivateConfig(cliWorkspace, userId);
   let handle;
@@ -291,6 +428,13 @@ export function startComposerAgent(opts) {
     });
   }
 
+  if (cli === "codex") {
+    return runCodexAgentWithPrivateMcp(cliWs, prompt, {
+      ...common,
+      model: model || undefined,
+    }, opts.agentflowUserId);
+  }
+
   if (cli === "claude-code") {
     return runClaudeCodeAgentWithPrompt(cliWs, prompt, {
       ...common,
@@ -581,6 +725,15 @@ export async function runComposerPostFlowValidationAndRepair(opts) {
         });
         setChild(handle.child);
         await handle.finished;
+      } else if (cli === "codex") {
+        const handle = runCodexAgentWithPrivateMcp(cliWs, agentPrompt, {
+          onStreamEvent: stepEmit,
+          model: model || undefined,
+          force: Boolean(opts.force),
+          env,
+        }, opts.agentflowUserId || opts.flowContext?.userId);
+        setChild(handle.child);
+        await handle.finished;
       } else if (cli === "claude-code") {
         const handle = runClaudeCodeAgentWithPrompt(cliWs, agentPrompt, {
           onStreamEvent: stepEmit,
@@ -854,6 +1007,15 @@ export function startComposerMultiStep(opts) {
               });
               currentChild = handle.child;
               await handle.finished;
+            } else if (cli === "codex") {
+              const handle = runCodexAgentWithPrivateMcp(cliWs, agentPrompt, {
+                onStreamEvent: stepEmit,
+                model: model || undefined,
+                force: Boolean(opts.force),
+                env,
+              }, opts.agentflowUserId || opts.flowContext?.userId);
+              currentChild = handle.child;
+              await handle.finished;
             } else if (cli === "claude-code") {
               const handle = runClaudeCodeAgentWithPrompt(cliWs, agentPrompt, {
                 onStreamEvent: stepEmit,

package/bin/lib/composer-model-router.mjs

@@ -61,14 +61,16 @@ function classifyModel(modelId) {
 function loadModelLists() {
   try {
     const p = getModelListsAbs();
-    if (!fs.existsSync(p)) return { cursor: [], opencode: [] };
+    if (!fs.existsSync(p)) return { cursor: [], opencode: [], claudeCode: [], codex: [] };
     const data = JSON.parse(fs.readFileSync(p, "utf-8"));
     return {
       cursor: Array.isArray(data.cursor) ? data.cursor.map(String) : [],
       opencode: Array.isArray(data.opencode) ? data.opencode.map(String) : [],
+      claudeCode: Array.isArray(data.claudeCode) ? data.claudeCode.map(String) : [],
+      codex: Array.isArray(data.codex) ? data.codex.map(String) : [],
     };
   } catch {
-    return { cursor: [], opencode: [] };
+    return { cursor: [], opencode: [], claudeCode: [], codex: [] };
   }
 }
 
@@ -87,6 +89,18 @@ function buildModelTiers(modelList) {
   return tiers;
 }
 
+function modelEntryId(entry) {
+  const idx = String(entry || "").indexOf(" - ");
+  return idx >= 0 ? entry.slice(0, idx).trim() : String(entry || "").trim();
+}
+
+function prefixedModels(models, prefix) {
+  return (Array.isArray(models) ? models : [])
+    .map((m) => modelEntryId(m))
+    .filter(Boolean)
+    .map((m) => `${prefix}:${m}`);
+}
+
 // ─── 公开接口 ──────────────────────────────────────────────────────────────
 
 /**
@@ -105,7 +119,12 @@ export function routeModel(complexity, opts = {}) {
   }
 
   const lists = loadModelLists();
-  const allModels = [...lists.cursor];
+  const allModels = [
+    ...lists.cursor,
+    ...prefixedModels(lists.codex, "codex"),
+    ...prefixedModels(lists.claudeCode, "claude-code"),
+    ...prefixedModels(lists.opencode, "opencode"),
+  ];
   if (allModels.length === 0) {
     return { model: null, tier: complexity === "complex" ? "capable" : complexity === "simple" ? "fast" : "balanced", source: "no-models-available" };
   }
@@ -146,11 +165,17 @@ export function getModelTierInfo() {
   const lists = loadModelLists();
   const cursorTiers = buildModelTiers(lists.cursor);
   const opencodeTiers = buildModelTiers(lists.opencode);
+  const claudeCodeTiers = buildModelTiers(lists.claudeCode);
+  const codexTiers = buildModelTiers(lists.codex);
   return {
     cursor: cursorTiers,
     opencode: opencodeTiers,
+    claudeCode: claudeCodeTiers,
+    codex: codexTiers,
     totalCursor: lists.cursor.length,
     totalOpencode: lists.opencode.length,
+    totalClaudeCode: lists.claudeCode.length,
+    totalCodex: lists.codex.length,
   };
 }
 

package/bin/lib/composer-planner.mjs

@@ -12,7 +12,7 @@ import { buildPlannerSkillContext } from "./composer-skill-router.mjs";
 import { buildNodeSchemaPromptSection } from "./composer-node-schema.mjs";
 import { formatInstancePlannerHint } from "./composer-flow-instances.mjs";
 import { resolveCliAndModel } from "./model-config.mjs";
-import { runClaudeCodeAgentWithPrompt, runCursorAgentWithPrompt, runOpenCodeAgentWithPrompt } from "./agent-runners.mjs";
+import { runCodexAgentWithPrompt, runClaudeCodeAgentWithPrompt, runCursorAgentWithPrompt, runOpenCodeAgentWithPrompt } from "./agent-runners.mjs";
 import { t } from "./i18n.mjs";
 
 const PLANNER_MAX_TOKENS = 2048;
@@ -428,6 +428,8 @@ async function classifyViaCli(userPrompt, cliWorkspace) {
 
   const runner = cli === "opencode"
     ? runOpenCodeAgentWithPrompt(cliWorkspace, prompt, { onStreamEvent, model: model || undefined })
+    : cli === "codex"
+      ? runCodexAgentWithPrompt(cliWorkspace, prompt, { onStreamEvent, model: model || undefined })
     : cli === "claude-code"
       ? runClaudeCodeAgentWithPrompt(cliWorkspace, prompt, { onStreamEvent, model: model || undefined })
       : runCursorAgentWithPrompt(cliWorkspace, prompt, { onStreamEvent, model: model || undefined, force: true });

package/bin/lib/help.mjs

@@ -8,7 +8,7 @@ export function printHelp() {
   // 根据语言输出不同的帮助文本
   if (isZh) {
     log.info(`
-AgentFlow CLI — 使用 Cursor / OpenCode / Claude Code CLI 流式输出驱动 apply/replay。
+AgentFlow CLI — 使用 Cursor / OpenCode / Claude Code / Codex CLI 流式输出驱动 apply/replay。
 
 用法：
   agentflow login [--provider github|google]   登录 AgentFlow Hub（默认 GitHub）
@@ -18,6 +18,7 @@ AgentFlow CLI — 使用 Cursor / OpenCode / Claude Code CLI 流式输出驱动
   agentflow download <slug|title> [--user|--workspace] [--as <id>] [--raw [--output <dir>]]  从 Hub 下载流程（默认 --user 安装到 ~/agentflow/pipelines/<id>；--workspace 安装到当前工程 .workspace/agentflow/pipelines/<id>；--raw 仅保留压缩包）
   agentflow list                              列出所有流水线
   agentflow ui [--host <addr>] [--port <n>] [--scheduler] [--no-open] [--hide-community-links]  本地 HTTP：流水线列表 + React Flow 节点流程图编辑保存（默认 127.0.0.1:8765；可用 AGENTFLOW_UI_HOST）
+  agentflow mcp                              启动 AgentFlow MCP stdio server，供 Cursor/Codex 运行流程并读取 display 输出
   agentflow scheduler start [--poll-ms <ms>]  启动定时执行调度器（读取各流水线 schedule.json）
   agentflow scheduler status [--json]         查看定时执行配置与状态
   agentflow scheduler cancel <FlowName> <uuid>  取消某次等待中的 watch/run
@@ -31,19 +32,19 @@ AgentFlow CLI — 使用 Cursor / OpenCode / Claude Code CLI 流式输出驱动
   agentflow run-status <flowName> <uuid>  输出该次运行的节点状态 JSON（供 UI 展示 success/pending 等角标）
   agentflow extract-thinking <flowName> <uuid>  从该次 run 的 logs/log.txt 提取 thinking，写入 logs/thinking_by_session_and_nodes.md
   agentflow extract-thinking -list             列出所有存在 logs/log.txt 的 run（可接 --json）
-  agentflow update-model-lists            拉取 Cursor / OpenCode 模型列表并写入 ~/agentflow/model-lists.json；--json 时输出 { cursor, opencode }
+  agentflow update-model-lists            拉取 Cursor / OpenCode / Claude Code / Codex 模型列表并写入 ~/agentflow/model-lists.json
   agentflow write-flow <flowId> --json --flow-source <user|workspace>   从 stdin 读入 YAML 写入用户目录或工作区（builtin 已弃用，将视为 workspace）
   agentflow --help
 
 选项：
   --workspace-root <path>  工作区根目录（默认：当前目录）
-  --dry-run                （仅 apply）打印就绪节点后退出，不执行 Cursor agent
-  --model <name>           后端模型。默认走 Cursor；前缀 opencode:<model>、claude-code:<model>、api:<provider>/<model> 可切换后端。覆盖 CURSOR_AGENT_MODEL。
+  --dry-run                （仅 apply）打印就绪节点后退出，不执行 agent 后端
+  --model <name>           后端模型。默认走 Cursor；前缀 opencode:<model>、claude-code:<model>、codex:<model>、api:<provider>/<model> 可切换后端。覆盖 CURSOR_AGENT_MODEL。
   --input <name>=<value>   （仅 apply）覆盖 flow 中 provide 节点的值。value 前缀 file: 表示文件路径。可多次使用。
   --debug                  显示调试日志（灰色，低优先级）
   --force                  传递 --force/--trust 给 Cursor；设置 OPENCODE_PERMISSION 允许 OpenCode 的 external_directory（默认开启）。使用 --no-force 禁用。
-  --parallel               并行运行同轮就绪节点（默认关闭）。多个 Cursor CLI 进程可能竞争 ~/.cursor/cli-config.json。
-  --machine-readable       向 stdout 每行输出一个 JSON 事件（apply-start/node-start/node-done/node-failed/apply-done/apply-paused）。供 UI 运行按钮使用：解析 stdout 显示当前节点；Cursor agent 输出转到 stderr。
+  --parallel               并行运行同轮就绪节点（默认关闭）。多个 CLI 进程可能竞争后端自身的本地配置。
+  --machine-readable       向 stdout 每行输出一个 JSON 事件（apply-start/node-start/node-done/node-failed/apply-done/apply-paused）。供 UI 运行按钮使用：解析 stdout 显示当前节点；agent 后端输出转到 stderr。
   --lang <code>            设置语言：en、zh（默认：zh，或从 LANG 环境变量检测）
 
 路径说明：
@@ -71,13 +72,13 @@ Apply：构建运行目录，解析流程，循环运行就绪节点。
 Resume：将 pending 和 failed 节点标记为成功（例如 UserCheck 确认后或重试失败后），然后继续 apply。
 Replay：运行单个节点（pre-process → execute → post-process）。
 
-需要：Node >=18，以下任一 CLI 在 PATH 中用于节点执行：Cursor CLI（'agent'，默认）、OpenCode CLI（'opencode'，env 覆盖 OPENCODE_CMD）、Claude Code CLI（'claude'，env 覆盖 CLAUDE_CODE_CMD，需先 'claude /login'）。
+需要：Node >=18，以下任一 CLI 在 PATH 中用于节点执行：Cursor CLI（'agent'，默认）、OpenCode CLI（'opencode'，env 覆盖 OPENCODE_CMD）、Claude Code CLI（'claude'，env 覆盖 CLAUDE_CODE_CMD，需先 'claude /login'）、Codex CLI（'codex'，env 覆盖 CODEX_CMD，需先 'codex login'）。
 Apply/replay 脚本已打包在 agentflow 包中（bin/pipeline/）。
 `);
   } else {
     // 英文版本
     log.info(`
-AgentFlow CLI — drive apply/replay with Cursor / OpenCode / Claude Code CLI streaming.
+AgentFlow CLI — drive apply/replay with Cursor / OpenCode / Claude Code / Codex CLI streaming.
 
 Usage:
   agentflow login [--provider github|google]   Login to AgentFlow Hub (default: GitHub)
@@ -87,6 +88,7 @@ Usage:
   agentflow download <slug|title> [--user|--workspace] [--as <id>] [--raw [--output <dir>]]  Download flow (default --user → ~/agentflow/pipelines/<id>; --workspace → current project's .workspace/agentflow/pipelines/<id>; --raw keeps the archive)
   agentflow list                              List all pipelines
   agentflow ui [--host <addr>] [--port <n>] [--scheduler] [--no-open] [--hide-community-links]  Local HTTP: pipeline list + React Flow node diagram editor (default 127.0.0.1:8765; AGENTFLOW_UI_HOST supported)
+  agentflow mcp                              Start the AgentFlow MCP stdio server for Cursor/Codex to run flows and read display outputs
   agentflow scheduler start [--poll-ms <ms>]  Start the scheduled-run scheduler (reads each pipeline schedule.json)
   agentflow scheduler status [--json]         Show scheduled-run configuration and state
   agentflow scheduler cancel <FlowName> <uuid>  Cancel a waiting watch/run
@@ -100,19 +102,19 @@ Usage:
   agentflow run-status <flowName> <uuid>  Output node status JSON for this run (for UI success/pending badges)
   agentflow extract-thinking <flowName> <uuid>  Extract thinking from run logs/log.txt, write to logs/thinking_by_session_and_nodes.md
   agentflow extract-thinking -list             List all runs with logs/log.txt (use --json)
-  agentflow update-model-lists            Fetch Cursor / OpenCode model lists to ~/agentflow/model-lists.json; --json outputs { cursor, opencode }
+  agentflow update-model-lists            Fetch Cursor / OpenCode / Claude Code / Codex model lists to ~/agentflow/model-lists.json
   agentflow write-flow <flowId> --json --flow-source <user|workspace>   Read YAML from stdin and write to user dir or workspace (builtin deprecated, treated as workspace)
   agentflow --help
 
 Options:
   --workspace-root <path>  Workspace root (default: cwd)
-  --dry-run                (apply only) Print ready nodes and exit without running Cursor agent
-  --model <name>           Backend model. Default routes to Cursor; prefixes opencode:<model>, claude-code:<model>, api:<provider>/<model> switch backend. Overrides CURSOR_AGENT_MODEL.
+  --dry-run                (apply only) Print ready nodes and exit without running an agent backend
+  --model <name>           Backend model. Default routes to Cursor; prefixes opencode:<model>, claude-code:<model>, codex:<model>, api:<provider>/<model> switch backend. Overrides CURSOR_AGENT_MODEL.
   --input <name>=<value>   (apply only) Override provide node values in flow. Prefix value with file: for file paths. Can be used multiple times.
   --debug                  Show debug logs (gray, low priority)
   --force                  Pass --force/--trust to Cursor; set OPENCODE_PERMISSION to allow external_directory for OpenCode (default: on). Use --no-force to disable.
-  --parallel               Run same-round ready nodes in parallel (default: off). Multiple Cursor CLI processes may race on ~/.cursor/cli-config.json.
-  --machine-readable       Emit one JSON event per line to stdout (apply-start/node-start/node-done/node-failed/apply-done/apply-paused). For UI run button: parse stdout to show current node; Cursor agent output goes to stderr.
+  --parallel               Run same-round ready nodes in parallel (default: off). Multiple CLI processes may race on backend-local config.
+  --machine-readable       Emit one JSON event per line to stdout (apply-start/node-start/node-done/node-failed/apply-done/apply-paused). For UI run button: parse stdout to show current node; agent backend output goes to stderr.
   --lang <code>            Set language: en, zh (default: en, or auto-detect from LANG env)
 
 Path notes:
@@ -140,7 +142,7 @@ Apply: builds run dir, parses flow, runs ready nodes in a loop.
 Resume: marks pending and failed node(s) as success (e.g. after UserCheck confirm or retry failed), then continues apply.
 Replay: runs a single node (pre-process → execute → post-process).
 
-Requires: Node >=18, any of Cursor CLI ('agent', default), OpenCode CLI ('opencode', env OPENCODE_CMD), or Claude Code CLI ('claude', env CLAUDE_CODE_CMD, run 'claude /login' first) in PATH for node execution.
+Requires: Node >=18, any of Cursor CLI ('agent', default), OpenCode CLI ('opencode', env OPENCODE_CMD), Claude Code CLI ('claude', env CLAUDE_CODE_CMD, run 'claude /login' first), or Codex CLI ('codex', env CODEX_CMD, run 'codex login' first) in PATH for node execution.
 Apply/replay scripts are bundled in the agentflow package (bin/pipeline/).
 `);
   }

package/bin/lib/locales/en.json

@@ -35,7 +35,7 @@
     "default": "Default"
   },
   "cli": {
-    "description": "AgentFlow CLI — drive apply/replay with Cursor or OpenCode CLI streaming",
+    "description": "AgentFlow CLI — drive apply/replay with Cursor, OpenCode, Claude Code, or Codex CLI streaming",
     "usage": "Usage",
     "commands": "Commands",
     "options": "Options",
@@ -341,6 +341,10 @@
       "displayName": "HTML Display",
       "description": "Render HTML in a sandboxed iframe on the Workspace canvas and pass the source downstream"
     },
+    "display_react_app": {
+      "displayName": "React App",
+      "description": "Preview a React project in a sandboxed iframe on the Workspace canvas and pass the project JSON downstream"
+    },
     "display_image": {
       "displayName": "Image Display",
       "description": "Preview an image URL, data URL, or image path on the Workspace canvas and pass the source downstream"

package/bin/lib/locales/zh.json

@@ -35,7 +35,7 @@
     "default": "默认"
   },
   "cli": {
-    "description": "AgentFlow CLI — 使用 Cursor 或 OpenCode CLI 流式输出驱动 apply/replay",
+    "description": "AgentFlow CLI — 使用 Cursor、OpenCode、Claude Code 或 Codex CLI 流式输出驱动 apply/replay",
     "usage": "用法",
     "commands": "命令",
     "options": "选项",
@@ -341,6 +341,10 @@
       "displayName": "HTML 展示",
       "description": "在 Workspace 画布中用 sandbox iframe 渲染 HTML，并将源码继续传给下游"
     },
+    "display_react_app": {
+      "displayName": "React 工程",
+      "description": "在 Workspace 画布中用 sandbox iframe 预览 React 工程，并将工程 JSON 继续传给下游"
+    },
     "display_image": {
       "displayName": "图片展示",
       "description": "在 Workspace 画布中预览图片 URL、data URL 或图片路径，并将来源继续传给下游"

package/bin/lib/main.mjs

@@ -32,6 +32,7 @@ import { hubPublish } from "./hub-publish.mjs";
 import { hubListRemote, hubDownload } from "./hub-remote.mjs";
 import { cancelScheduledRun, listScheduleStatuses, startScheduler } from "./scheduler.mjs";
 import { installFlowDependency, listMarketplacePackages, publishNodePackage } from "./marketplace.mjs";
+import { startMcpServer } from "./mcp-server.mjs";
 
 async function readStdin() {
   const chunks = [];
@@ -116,6 +117,10 @@ export async function main() {
     if (jsonMode) process.stdout.write(JSON.stringify(result) + "\n");
     process.exit(0);
   }
+  if (sub === "mcp") {
+    await startMcpServer();
+    return;
+  }
   const jsonOnlySubs = [
     "list-flows",
     "list-nodes",