@fieldwangai/agentflow 0.1.85 → 0.1.86

package/bin/lib/mcp-server.mjs

@@ -0,0 +1,328 @@
+const DEFAULT_BASE_URL = "http://127.0.0.1:8875";
+
+function envBaseUrl() {
+  return String(process.env.AGENTFLOW_BASE_URL || DEFAULT_BASE_URL).replace(/\/+$/, "");
+}
+
+function envToken() {
+  return String(process.env.AGENTFLOW_TOKEN || process.env.AGENTFLOW_SESSION_TOKEN || "").trim();
+}
+
+function toolText(data) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: typeof data === "string" ? data : JSON.stringify(data, null, 2),
+      },
+    ],
+  };
+}
+
+function toolError(error) {
+  return {
+    isError: true,
+    content: [{ type: "text", text: String(error?.message || error || "Unknown error") }],
+  };
+}
+
+async function httpJson(pathname, { method = "GET", body } = {}) {
+  const baseUrl = envBaseUrl();
+  const token = envToken();
+  const url = new URL(pathname, baseUrl);
+  const headers = {
+    Accept: "application/json",
+  };
+  if (body !== undefined) headers["Content-Type"] = "application/json";
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+    headers.Cookie = `af_session=${encodeURIComponent(token)}`;
+  }
+  const response = await fetch(url, {
+    method,
+    headers,
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  const text = await response.text();
+  let data = null;
+  try {
+    data = text ? JSON.parse(text) : null;
+  } catch {
+    data = { text };
+  }
+  if (!response.ok) {
+    const message = data?.error || data?.message || text || `HTTP ${response.status}`;
+    throw new Error(message);
+  }
+  return data;
+}
+
+function query(params = {}) {
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(params || {})) {
+    if (value === undefined || value === null || value === "") continue;
+    search.set(key, String(value));
+  }
+  const s = search.toString();
+  return s ? `?${s}` : "";
+}
+
+function displayKind(definitionId) {
+  const id = String(definitionId || "");
+  if (id === "display_markdown") return "markdown";
+  if (id === "display_mermaid") return "mermaid";
+  if (id === "display_ascii") return "ascii";
+  if (id === "display_html") return "html";
+  if (id === "display_react_app") return "react";
+  if (id === "display_image") return "image";
+  if (id === "display_chart") return "chart";
+  if (id === "display_table") return "table";
+  return "";
+}
+
+function slotText(slots, names = []) {
+  const wanted = new Set(names.map(String));
+  for (const slot of Array.isArray(slots) ? slots : []) {
+    const name = String(slot?.name || "");
+    if (wanted.size && !wanted.has(name)) continue;
+    const value = slot?.value ?? slot?.default ?? "";
+    if (String(value || "").trim()) return String(value);
+  }
+  return "";
+}
+
+function extractDisplayOutputs(graph) {
+  const instances = graph?.instances && typeof graph.instances === "object" ? graph.instances : {};
+  const outputs = [];
+  for (const [nodeId, instance] of Object.entries(instances)) {
+    const kind = displayKind(instance?.definitionId);
+    if (!kind) continue;
+    const primary = kind === "image" ? "src" : "content";
+    const content = String(instance?.body || "") ||
+      slotText(instance?.input, [primary, "content", "markdown", "html", "src"]) ||
+      slotText(instance?.output, [primary, "content", "markdown", "html", "src"]);
+    outputs.push({
+      nodeId,
+      label: String(instance?.label || instance?.displayName || nodeId),
+      definitionId: String(instance?.definitionId || ""),
+      kind,
+      content,
+      hasContent: Boolean(String(content || "").trim()),
+    });
+  }
+  return outputs;
+}
+
+const tools = [
+  {
+    name: "agentflow_list_flows",
+    description: "List AgentFlow flows visible to the configured user.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "agentflow_get_workspace_graph",
+    description: "Read a flow as a workspace graph before running or inspecting display nodes.",
+    inputSchema: {
+      type: "object",
+      required: ["flowId"],
+      properties: {
+        flowId: { type: "string" },
+        flowSource: { type: "string", default: "user" },
+      },
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "agentflow_run_flow",
+    description: "Run an AgentFlow workspace flow and return the merged graph plus display outputs.",
+    inputSchema: {
+      type: "object",
+      required: ["flowId"],
+      properties: {
+        flowId: { type: "string" },
+        flowSource: { type: "string", default: "user" },
+        runNodeId: { type: "string", description: "Optional run/schedule node id. Empty runs from the graph start." },
+        inputs: { type: "object", description: "Optional flow input values." },
+      },
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "agentflow_get_run_status",
+    description: "Get active workspace run status for a flow.",
+    inputSchema: {
+      type: "object",
+      required: ["flowId"],
+      properties: {
+        flowId: { type: "string" },
+        flowSource: { type: "string", default: "user" },
+      },
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "agentflow_get_run_logs",
+    description: "Read workspace run logs. Provide runId for a specific run, or flowId to list recent runs.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        flowId: { type: "string" },
+        flowSource: { type: "string" },
+        runId: { type: "string" },
+        limit: { type: "number", default: 20 },
+      },
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "agentflow_get_display_outputs",
+    description: "Extract display node outputs from a workspace graph.",
+    inputSchema: {
+      type: "object",
+      required: ["flowId"],
+      properties: {
+        flowId: { type: "string" },
+        flowSource: { type: "string", default: "user" },
+      },
+      additionalProperties: false,
+    },
+  },
+];
+
+async function callTool(name, args = {}) {
+  if (name === "agentflow_list_flows") {
+    return toolText(await httpJson("/api/flows"));
+  }
+  if (name === "agentflow_get_workspace_graph") {
+    const flowSource = args.flowSource || "user";
+    return toolText(await httpJson(`/api/workspace/graph${query({ flowId: args.flowId, flowSource })}`));
+  }
+  if (name === "agentflow_run_flow") {
+    const flowSource = args.flowSource || "user";
+    const graphPayload = await httpJson(`/api/workspace/graph${query({ flowId: args.flowId, flowSource })}`);
+    const runPayload = {
+      flowId: args.flowId,
+      flowSource,
+      runNodeId: args.runNodeId || "",
+      graph: graphPayload.graph,
+      inputs: args.inputs && typeof args.inputs === "object" ? args.inputs : {},
+    };
+    const result = await httpJson("/api/workspace/run", { method: "POST", body: runPayload });
+    return toolText({
+      ok: result?.ok === true,
+      flowId: args.flowId,
+      flowSource,
+      runNodeId: args.runNodeId || "",
+      order: result?.order || [],
+      pauseNodeIds: result?.pauseNodeIds || [],
+      touchedNodeIds: result?.touchedNodeIds || [],
+      displayOutputs: extractDisplayOutputs(result?.graph),
+      graph: result?.graph || null,
+    });
+  }
+  if (name === "agentflow_get_run_status") {
+    return toolText(await httpJson(`/api/workspace/run/status${query({ flowId: args.flowId, flowSource: args.flowSource || "user" })}`));
+  }
+  if (name === "agentflow_get_run_logs") {
+    if (args.runId) {
+      return toolText(await httpJson(`/api/workspace/run-logs/${encodeURIComponent(String(args.runId))}`));
+    }
+    return toolText(await httpJson(`/api/workspace/run-logs${query({
+      flowId: args.flowId || "",
+      flowSource: args.flowSource || "",
+      limit: args.limit || 20,
+    })}`));
+  }
+  if (name === "agentflow_get_display_outputs") {
+    const flowSource = args.flowSource || "user";
+    const graphPayload = await httpJson(`/api/workspace/graph${query({ flowId: args.flowId, flowSource })}`);
+    return toolText({
+      flowId: args.flowId,
+      flowSource,
+      displayOutputs: extractDisplayOutputs(graphPayload.graph),
+    });
+  }
+  return toolError(`Unknown tool: ${name}`);
+}
+
+function response(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+
+function errorResponse(id, error) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code: -32000,
+      message: String(error?.message || error || "Unknown error"),
+    },
+  };
+}
+
+function writeMessage(message) {
+  process.stdout.write(JSON.stringify(message) + "\n");
+}
+
+async function handleMessage(message) {
+  if (!message || typeof message !== "object") return;
+  const id = message.id;
+  const method = String(message.method || "");
+  try {
+    if (method === "initialize") {
+      writeMessage(response(id, {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: "agentflow", version: "0.1.0" },
+      }));
+      return;
+    }
+    if (method === "notifications/initialized") return;
+    if (method === "tools/list") {
+      writeMessage(response(id, { tools }));
+      return;
+    }
+    if (method === "tools/call") {
+      const params = message.params || {};
+      const result = await callTool(String(params.name || ""), params.arguments || {});
+      writeMessage(response(id, result));
+      return;
+    }
+    if (id !== undefined) writeMessage(errorResponse(id, `Unknown method: ${method}`));
+  } catch (e) {
+    if (id !== undefined) writeMessage(errorResponse(id, e));
+  }
+}
+
+function feedLine(line) {
+  const text = String(line || "").trim();
+  if (!text) return;
+  try {
+    void handleMessage(JSON.parse(text));
+  } catch (e) {
+    writeMessage(errorResponse(null, e));
+  }
+}
+
+export async function startMcpServer() {
+  process.stdin.setEncoding("utf8");
+  let buffer = "";
+  process.stdin.on("data", (chunk) => {
+    buffer += chunk;
+    let idx = buffer.indexOf("\n");
+    while (idx >= 0) {
+      const line = buffer.slice(0, idx);
+      buffer = buffer.slice(idx + 1);
+      feedLine(line);
+      idx = buffer.indexOf("\n");
+    }
+  });
+  process.stdin.on("end", () => {
+    if (buffer.trim()) feedLine(buffer);
+  });
+  await new Promise(() => {});
+}

package/bin/lib/model-config.mjs

@@ -45,6 +45,14 @@ export function resolveCliAndModel(workspaceRoot, nodeModel, agentModelOverride)
     if (raw.startsWith("api:")) {
       return { cli: "api", model: raw, label: raw };
     }
+    if (raw.startsWith("codex:")) {
+      const m = raw.slice("codex:".length).trim();
+      return {
+        cli: "codex",
+        model: m || null,
+        label: m ? `codex: ${m}` : "codex (default)",
+      };
+    }
     if (raw.startsWith("claude-code:")) {
       const m = raw.slice("claude-code:".length).trim();
       return {
@@ -75,9 +83,11 @@ export function resolveCliAndModel(workspaceRoot, nodeModel, agentModelOverride)
           ? "opencode"
           : cfg.cli === "api"
             ? "api"
-            : cfg.cli === "claude-code"
-              ? "claude-code"
-              : "cursor";
+            : cfg.cli === "codex"
+              ? "codex"
+              : cfg.cli === "claude-code"
+                ? "claude-code"
+                : "cursor";
       const model = String(cfg.model).trim();
       return { cli, model, label: `${cli}: ${model}` };
     }
@@ -87,6 +97,15 @@ export function resolveCliAndModel(workspaceRoot, nodeModel, agentModelOverride)
     return { cli: "api", model: key, label: key };
   }
 
+  if (key && key.startsWith("codex:")) {
+    const model = key.slice("codex:".length) || "";
+    return {
+      cli: "codex",
+      model: model || null,
+      label: model ? `codex: ${model}` : "codex (default)",
+    };
+  }
+
   if (key && key.startsWith("claude-code:")) {
     const model = key.slice("claude-code:".length) || "";
     return {
@@ -109,6 +128,16 @@ export function resolveCliAndModel(workspaceRoot, nodeModel, agentModelOverride)
   if (envModel && envModel.startsWith("api:")) {
     return { cli: "api", model: envModel, label: envModel };
   }
+  if (!key) {
+    const codexModel = process.env.CODEX_MODEL && String(process.env.CODEX_MODEL).trim();
+    if (codexModel) {
+      return {
+        cli: "codex",
+        model: codexModel,
+        label: `codex: ${codexModel}`,
+      };
+    }
+  }
   const model = normalizeCursorModelForCli(key || envModel || "Auto");
   return {
     cli: "cursor",

package/bin/lib/model-lists.mjs

@@ -125,8 +125,68 @@ export function runOpencodeModels(workspaceRoot, provider) {
   });
 }
 
+function parseCodexModelList(stdout) {
+  const cleaned = stripAnsiModelList(stdout);
+  const start = cleaned.indexOf("{");
+  const end = cleaned.lastIndexOf("}");
+  if (start < 0 || end <= start) return [];
+  try {
+    const parsed = JSON.parse(cleaned.slice(start, end + 1));
+    const rows = Array.isArray(parsed?.models) ? parsed.models : [];
+    const seen = new Set();
+    const models = [];
+    for (const row of rows) {
+      if (!row || typeof row !== "object") continue;
+      const slug = typeof row.slug === "string" ? row.slug.trim() : "";
+      if (!slug || seen.has(slug)) continue;
+      seen.add(slug);
+      const display = typeof row.display_name === "string" ? row.display_name.trim() : "";
+      models.push(display && display !== slug ? `${slug} - ${display}` : slug);
+    }
+    return models;
+  } catch (_) {
+    return [];
+  }
+}
+
+export function runCodexModels(workspaceRoot) {
+  return new Promise((resolve) => {
+    const codexCmd = process.env.CODEX_CMD || "codex";
+    const child = spawn(codexCmd, ["debug", "models", "--bundled"], {
+      cwd: workspaceRoot,
+      shell: false,
+      env: envWithCommonBinPaths(),
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const finish = (models) => {
+      if (settled) return;
+      settled = true;
+      resolve(models);
+    };
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf-8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf-8");
+    });
+    child.on("close", (code) => {
+      if (code === 0) finish(parseCodexModelList(stdout || stderr));
+      else finish([]);
+    });
+    child.on("error", () => finish([]));
+    setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+      } catch {}
+      finish([]);
+    }, 10_000);
+  });
+}
+
 /**
- * 拉取 Cursor / OpenCode 模型列表并写入 ~/agentflow/model-lists.json
+ * 拉取 Cursor / OpenCode / Claude Code / Codex 模型列表并写入 ~/agentflow/model-lists.json
  * @param {string} workspaceRoot
  * @param {{ opencodeProviderOverride?: string }} [opts]
  */
@@ -150,9 +210,11 @@ export async function updateModelLists(workspaceRoot, opts = {}) {
     cursor: [],
     opencode: [],
     claudeCode: [],
+    codex: [],
     cursorFetchedAt: null,
     opencodeFetchedAt: null,
     claudeCodeFetchedAt: null,
+    codexFetchedAt: null,
   };
   try {
     if (fs.existsSync(cachePath)) {
@@ -161,10 +223,11 @@ export async function updateModelLists(workspaceRoot, opts = {}) {
     }
   } catch (_) {}
 
-  const [cursorRaw, opencode, claudeCodeAvailable] = await Promise.all([
+  const [cursorRaw, opencode, claudeCodeAvailable, codex] = await Promise.all([
     runCursorModels(root),
     runOpencodeModels(root, opencodeProvider),
     probeClaudeCodeAvailable(),
+    runCodexModels(root),
   ]);
   const cursor = cursorRaw.filter(isCursorModelLine);
   const claudeCode = claudeCodeAvailable ? getBuiltinClaudeCodeModels() : [];
@@ -174,9 +237,11 @@ export async function updateModelLists(workspaceRoot, opts = {}) {
     cursor: cursor.length > 0 ? cursor : prev.cursor ?? [],
     opencode: opencode.length > 0 ? opencode : prev.opencode ?? [],
     claudeCode: claudeCode.length > 0 ? claudeCode : prev.claudeCode ?? [],
+    codex: codex.length > 0 ? codex : prev.codex ?? [],
     cursorFetchedAt: cursor.length > 0 ? now : prev.cursorFetchedAt ?? null,
     opencodeFetchedAt: opencode.length > 0 ? now : prev.opencodeFetchedAt ?? null,
     claudeCodeFetchedAt: claudeCode.length > 0 ? now : prev.claudeCodeFetchedAt ?? null,
+    codexFetchedAt: codex.length > 0 ? now : prev.codexFetchedAt ?? null,
   };
 
   try {
@@ -184,5 +249,5 @@ export async function updateModelLists(workspaceRoot, opts = {}) {
     fs.writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
   } catch (_) {}
 
-  return { cursor: data.cursor, opencode: data.opencode, claudeCode: data.claudeCode };
+  return { cursor: data.cursor, opencode: data.opencode, claudeCode: data.claudeCode, codex: data.codex };
 }

package/bin/lib/node-execute.mjs

@@ -4,6 +4,8 @@ import path from "path";
 import { outputNodeBasename, outputDirForNode } from "../pipeline/get-exec-id.mjs";
 import { writeResult } from "../pipeline/write-result.mjs";
 import {
+  runCodexAgentForNode,
+  runCodexAgentWithPrompt,
   runClaudeCodeAgentForNode,
   runClaudeCodeAgentWithPrompt,
   runCursorAgentForNode,
@@ -100,7 +102,7 @@ async function healToolNodejsWithAI(workspaceRoot, flowName, uuid, instanceId, r
 
   const prompt = buildHealPrompt(scriptPath, resolvedScript, errorInfo, scriptContent);
   const healCli =
-    cli === "opencode" ? "opencode" : cli === "claude-code" ? "claude-code" : "cursor";
+    cli === "opencode" ? "opencode" : cli === "codex" ? "codex" : cli === "claude-code" ? "claude-code" : "cursor";
 
   log.info(`[tool_nodejs AI 自愈] ${instanceId} 调用 ${healCli}${model ? ` (${model})` : ""} 修复 ${path.basename(scriptPath)}`);
   emitEvent(workspaceRoot, flowName, uuid, {
@@ -115,6 +117,9 @@ async function healToolNodejsWithAI(workspaceRoot, flowName, uuid, instanceId, r
     if (healCli === "opencode") {
       const { finished } = runOpenCodeAgentWithPrompt(workspaceRoot, prompt, { model: model || undefined, force: true });
       await finished;
+    } else if (healCli === "codex") {
+      const { finished } = runCodexAgentWithPrompt(workspaceRoot, prompt, { model: model || undefined, force: true });
+      await finished;
     } else if (healCli === "claude-code") {
       const { finished } = runClaudeCodeAgentWithPrompt(workspaceRoot, prompt, { model: model || undefined });
       await finished;
@@ -429,6 +434,22 @@ export async function executeNode(workspaceRoot, flowName, uuid, instanceId, pre
           execWorkspaceRoot,
         },
       );
+    } else if (cli === "codex") {
+      await runCodexAgentForNode(
+        workspaceRoot,
+        { promptPath, nodeContext: nodeContext ?? "", taskBody: taskBody ?? "", intermediatePath, resultPathRel: resultPath, subagent, instanceId },
+        {
+          model,
+          stderrBuffer: options.stderrBuffer,
+          force: options.force,
+          outputPrefix: options.outputPrefix,
+          prefixColor: options.prefixColor,
+          onToolCall: options.onToolCall,
+          flowName,
+          uuid,
+          execWorkspaceRoot,
+        },
+      );
     } else if (cli === "claude-code") {
       await runClaudeCodeAgentForNode(
         workspaceRoot,