@fieldwangai/agentflow 0.1.85 → 0.1.86

package/bin/lib/agent-runners.mjs

@@ -34,6 +34,219 @@ function writeAgentTextArtifacts(absResultPath, absRunDir, instanceId, text) {
   fs.writeFileSync(slotPath, body + "\n", "utf-8");
 }
 
+function envFlag(name, defaultValue = false) {
+  const raw = process.env[name];
+  if (raw == null || raw === "") return defaultValue;
+  return raw !== "0" && raw !== "false";
+}
+
+function cleanModel(value, fallbackEnvName = "") {
+  const raw = value ?? (fallbackEnvName ? process.env[fallbackEnvName] : null) ?? "";
+  const text = String(raw).trim();
+  if (!text) return "";
+  const dashIdx = text.indexOf(" - ");
+  return dashIdx >= 0 ? text.slice(0, dashIdx).trim() : text;
+}
+
+function hasGitMetadataAncestor(startDir) {
+  let cur = path.resolve(startDir || ".");
+  while (true) {
+    if (fs.existsSync(path.join(cur, ".git"))) return true;
+    const parent = path.dirname(cur);
+    if (parent === cur) return false;
+    cur = parent;
+  }
+}
+
+function shouldSkipCodexGitCheck(workspace) {
+  const raw = process.env.AGENTFLOW_CODEX_SKIP_GIT_CHECK;
+  if (raw === "1" || raw === "true") return true;
+  if (raw === "0" || raw === "false") return false;
+  return !hasGitMetadataAncestor(workspace);
+}
+
+function buildCodexExecArgs({ workspace, addDirs = [], model, outputLastMessagePath, promptText, configArgs = [] }) {
+  const args = [];
+  for (const cfg of Array.isArray(configArgs) ? configArgs : []) {
+    const value = String(cfg || "").trim();
+    if (value) args.push("-c", value);
+  }
+  const approval = String(process.env.AGENTFLOW_CODEX_APPROVAL || "never").trim();
+  if (approval) args.push("--ask-for-approval", approval);
+  args.push("exec", "--json", "--color", "never", "--cd", workspace, "--output-last-message", outputLastMessagePath);
+  if (envFlag("AGENTFLOW_CODEX_IGNORE_USER_CONFIG", true)) args.push("--ignore-user-config");
+  for (const dir of addDirs) {
+    const abs = path.resolve(dir);
+    if (abs && abs !== workspace) args.push("--add-dir", abs);
+  }
+  if (envFlag("AGENTFLOW_CODEX_DANGER", false)) {
+    args.push("--dangerously-bypass-approvals-and-sandbox");
+  } else {
+    args.push("--sandbox", String(process.env.AGENTFLOW_CODEX_SANDBOX || "workspace-write").trim() || "workspace-write");
+  }
+  if (shouldSkipCodexGitCheck(workspace)) args.push("--skip-git-repo-check");
+  if (envFlag("AGENTFLOW_CODEX_EPHEMERAL", false)) args.push("--ephemeral");
+  if (model) args.push("--model", model);
+  args.push(promptText);
+  return args;
+}
+
+function extractCodexText(event) {
+  if (!event || typeof event !== "object") return "";
+  const candidates = [
+    event.delta,
+    event.text,
+    event.message,
+    event.content,
+    event.output_text,
+    event.final_message,
+    event.item?.text,
+    event.item?.message,
+    event.item?.content,
+    event.msg?.content,
+  ];
+  for (const c of candidates) {
+    if (typeof c === "string" && c.trim()) return normalizeStreamTextChunk(c);
+    if (Array.isArray(c)) {
+      const parts = c
+        .map((part) => {
+          if (typeof part === "string") return part;
+          if (part && typeof part === "object") return part.text || part.content || part.output_text || "";
+          return "";
+        })
+        .filter(Boolean);
+      if (parts.length) return normalizeStreamTextChunk(parts.join(""));
+    }
+  }
+  return "";
+}
+
+function extractCodexToolName(event) {
+  if (!event || typeof event !== "object") return "";
+  const names = [event.name, event.tool_name, event.toolName, event.call?.name, event.item?.name, event.command?.name];
+  for (const name of names) {
+    if (typeof name === "string" && name.trim()) return name.trim();
+  }
+  return "";
+}
+
+function codexEventKind(event) {
+  const base = String(event?.type || event?.event || event?.kind || "unknown");
+  const itemType = typeof event?.item?.type === "string" && event.item.type.trim() ? event.item.type.trim() : "";
+  return itemType ? `${base}:${itemType}` : base;
+}
+
+function codexEventBaseKind(event) {
+  return String(event?.type || event?.event || event?.kind || "unknown");
+}
+
+function codexItemType(event) {
+  return typeof event?.item?.type === "string" ? event.item.type.trim().toLowerCase() : "";
+}
+
+function codexCommandText(event) {
+  const item = event?.item;
+  const candidates = [item?.command, item?.cmd, event?.command, event?.cmd];
+  for (const c of candidates) {
+    if (typeof c === "string" && c.trim()) return c.trim();
+  }
+  if (item?.command && typeof item.command === "object") {
+    const name = item.command.name || item.command.command || "";
+    const args = Array.isArray(item.command.args) ? item.command.args.join(" ") : "";
+    const text = `${name} ${args}`.trim();
+    if (text) return text;
+  }
+  return "";
+}
+
+function isNonFatalCodexErrorMessage(message) {
+  const lower = String(message || "").toLowerCase();
+  return lower.includes("reconnecting") || lower.includes("retrying") || lower.includes("timed out waiting for") || lower.includes("transport channel closed");
+}
+
+function handleCodexEvent(event, { emitNatural, emitStatus, onToolCall }) {
+  const kind = codexEventKind(event);
+  const baseKind = codexEventBaseKind(event);
+  const lower = kind.toLowerCase();
+  const baseLower = baseKind.toLowerCase();
+  const itemType = codexItemType(event);
+  const text = extractCodexText(event);
+
+  if (itemType === "agent_message") {
+    if (text) emitNatural("assistant", text);
+    return { handled: true, hadError: false };
+  }
+  if (itemType.includes("reason") || itemType.includes("thinking")) {
+    if (text) emitNatural("thinking", text);
+    if (onToolCall) onToolCall("thinking", "");
+    return { handled: true, hadError: false };
+  }
+  if (itemType === "command_execution" || itemType.includes("tool_call") || itemType.includes("tool")) {
+    const command = codexCommandText(event);
+    const status = String(event?.item?.status || event?.status || baseKind || "").toLowerCase();
+    const exitCode = event?.item?.exit_code ?? event?.exit_code;
+    const name = command || extractCodexToolName(event) || itemType || kind;
+    if (onToolCall) onToolCall(itemType || kind, name);
+    if (baseLower.includes("started") || status === "in_progress") {
+      emitStatus(`Codex command started: ${truncateComposerLine(name)}`);
+    } else if (baseLower.includes("completed") || status === "completed" || status === "failed") {
+      const suffix = exitCode == null ? "" : ` exit ${exitCode}`;
+      emitStatus(`Codex command ${status === "failed" || exitCode ? "finished" : "completed"}:${suffix} ${truncateComposerLine(name)}`);
+    } else {
+      emitStatus(`Codex ${truncateComposerLine(name)}`);
+    }
+    return { handled: true, hadError: false };
+  }
+
+  if (text && (lower.includes("message") || lower.includes("response") || lower.includes("delta") || lower === "assistant")) {
+    emitNatural("assistant", text);
+    return { handled: true, hadError: false };
+  }
+  if (text && lower.includes("reason")) {
+    emitNatural("thinking", text);
+    if (onToolCall) onToolCall("thinking", "");
+    return { handled: true, hadError: false };
+  }
+  if (lower.includes("tool") || lower.includes("exec") || lower.includes("command")) {
+    const toolName = extractCodexToolName(event) || kind;
+    if (onToolCall) onToolCall(kind, toolName);
+    emitStatus(`Codex ${toolName}`);
+    return { handled: true, hadError: false };
+  }
+  if (lower.includes("error") || event?.is_error) {
+    const msg = text || event?.message || event?.error || kind;
+    emitStatus(truncateComposerLine(String(msg)));
+    return { handled: true, hadError: !isNonFatalCodexErrorMessage(msg) };
+  }
+  if (baseLower === "thread.started" || baseLower === "turn.started" || baseLower === "turn.completed") {
+    return { handled: true, hadError: false };
+  }
+  return { handled: false, hadError: false };
+}
+
+function codexFailureMessage(code, stderrTail, { flowName = "", uuid = "" } = {}) {
+  const tail = String(stderrTail || "").trim();
+  const lower = tail.toLowerCase();
+  const hints = [];
+  if (lower.includes("login") || lower.includes("auth") || lower.includes("authentication") || lower.includes("not logged")) {
+    hints.push("Codex 可能未登录，请先执行 `codex login`。");
+  }
+  if (lower.includes("model") && (lower.includes("not found") || lower.includes("unknown") || lower.includes("invalid"))) {
+    hints.push("Codex 模型可能不可用，请检查 `codex:<model>` 或刷新模型列表。");
+  }
+  if (lower.includes("mcp") || lower.includes("config") || lower.includes("invalid transport")) {
+    hints.push("Codex MCP/配置加载失败，请检查 MCP 名称、URL、command/env 配置。");
+  }
+  if (lower.includes("network") || lower.includes("timeout") || lower.includes("connection")) {
+    hints.push("Codex 网络连接失败，请检查代理或网络环境。");
+  }
+  if (flowName && uuid) {
+    hints.push("完整 stderr 可在 run 日志中查看；需要直接透传 stderr 可设置 `AGENTFLOW_CODEX_STDERR_INHERIT=1` 后重跑。");
+  }
+  const suffix = hints.length ? ` ${hints.join(" ")}` : "";
+  return `Codex CLI exited ${code}. ${tail || "No result event received."}${suffix}`;
+}
+
 /**
  * Run Cursor CLI with stream-json, forward events to stdout, return success/failure.
  */
@@ -693,6 +906,225 @@ export function runClaudeCodeAgentForNode(
   });
 }
 
+/**
+ * Run Codex CLI (`codex exec`) in non-interactive JSONL mode for a node.
+ */
+export function runCodexAgentForNode(
+  workspaceRoot,
+  { promptPath, nodeContext, taskBody, intermediatePath, resultPathRel, subagent, instanceId },
+  options = {},
+) {
+  const absPromptPath = path.resolve(workspaceRoot, promptPath);
+  const absRunDir = path.resolve(workspaceRoot, intermediatePath);
+  const absResultPath = path.join(absRunDir, resultPathRel);
+  const nodeIntermediateDir = path.dirname(absPromptPath);
+  const outputDir = instanceId ? path.join(absRunDir, "output", instanceId) : path.join(absRunDir, "output");
+  if (instanceId) fs.mkdirSync(outputDir, { recursive: true });
+  const absWorkspaceRoot = path.resolve(workspaceRoot);
+  const execWorkspaceRoot = path.resolve(options.execWorkspaceRoot || workspaceRoot);
+  const replacements = {
+    workspaceRoot: execWorkspaceRoot,
+    executionWorkspaceRoot: execWorkspaceRoot,
+    pipelineWorkspace: absWorkspaceRoot,
+    promptPath: absPromptPath,
+    nodeContext: nodeContext ?? "",
+    taskBody: taskBody ?? "",
+    resultPath: absResultPath,
+    intermediatePath: path.join(absRunDir, "intermediate"),
+    outputDir,
+    flowName: options.flowName ?? "",
+    uuid: options.uuid ?? "",
+    instanceId: instanceId ?? "",
+  };
+  const agentContent = loadAgentPromptWithReplacements(workspaceRoot, subagent, replacements);
+  let agentPathForPrompt = getAgentPath(workspaceRoot, subagent);
+  if (agentContent) {
+    const resolvedAgentPath = path.join(nodeIntermediateDir, `agent-${subagent}.md`);
+    fs.mkdirSync(nodeIntermediateDir, { recursive: true });
+    fs.writeFileSync(resolvedAgentPath, agentContent, "utf8");
+    agentPathForPrompt = resolvedAgentPath;
+  }
+  const rawAgentContent =
+    agentContent != null
+      ? agentContent
+      : fs.existsSync(agentPathForPrompt)
+        ? fs.readFileSync(agentPathForPrompt, "utf8")
+        : "";
+  const promptText = stripYamlFrontmatter(rawAgentContent);
+
+  const model = cleanModel(options.model, "CODEX_MODEL");
+  const rawPrefix = options.outputPrefix != null ? `[${options.outputPrefix}] ` : "";
+  const coloredPrefix = rawPrefix && options.prefixColor ? options.prefixColor(rawPrefix) : rawPrefix;
+  const agentContentColor = options.contentColor ?? ((line) => chalk.gray(line));
+
+  return new Promise((resolve, reject) => {
+    const codexCmd = process.env.CODEX_CMD || "codex";
+    fs.mkdirSync(nodeIntermediateDir, { recursive: true });
+    const outputLastMessagePath = path.join(nodeIntermediateDir, "codex-last-message.txt");
+    const args = buildCodexExecArgs({
+      workspace: execWorkspaceRoot,
+      addDirs: [absWorkspaceRoot],
+      model,
+      outputLastMessagePath,
+      promptText,
+      configArgs: options.codexConfigArgs,
+    });
+    if (options.flowName && options.uuid) {
+      const argvLog = args.slice(0, -1).concat([`(prompt ${args[args.length - 1].length} chars)`]);
+      appendRunLogLine(
+        workspaceRoot,
+        options.flowName,
+        options.uuid,
+        "cli-raw",
+        `Codex CLI 完整参数: ${codexCmd} ${JSON.stringify(argvLog)}`,
+      );
+      appendRunLogLine(
+        workspaceRoot,
+        options.flowName,
+        options.uuid,
+        "cli-raw",
+        `Codex CLI prompt 前 800 字:\n${promptText.slice(0, 800)}${promptText.length > 800 ? "..." : ""}`,
+      );
+      appendRunLogLine(workspaceRoot, options.flowName, options.uuid, "cli-raw", `Codex CLI prompt 完整:\n${promptText}`);
+    }
+
+    const useStderrInherit =
+      process.env.AGENTFLOW_CODEX_STDERR_INHERIT === "1" ||
+      process.env.AGENTFLOW_CODEX_STDERR_INHERIT === "true";
+    const child = spawn(codexCmd, args, {
+      cwd: execWorkspaceRoot,
+      stdio: ["ignore", "pipe", useStderrInherit ? "inherit" : "pipe"],
+      shell: false,
+      env: childEnv(options),
+    });
+
+    let hadError = false;
+    const assistantTextChunks = [];
+    const STDERR_CAP_BYTES = 1024 * 1024;
+    const stderrChunks = [];
+    let stderrTotalBytes = 0;
+    const stderrBuffer = options.stderrBuffer || null;
+    let stderrLineBuffer = "";
+    const flowName = options.flowName ?? null;
+    const uuid = options.uuid ?? null;
+
+    const outStream = machineReadable ? process.stderr : process.stdout;
+    function writeStdout(text) {
+      if (coloredPrefix) writeWithPrefix(outStream, text, coloredPrefix, agentContentColor);
+      else if (text) outStream.write(agentContentColor(text));
+      if (text && flowName && uuid) appendRunLogLine(workspaceRoot, flowName, uuid, "codex-stdout", text);
+    }
+
+    function flushStderrLines() {
+      if (!coloredPrefix) return;
+      let idx;
+      while ((idx = stderrLineBuffer.indexOf("\n")) !== -1) {
+        const line = stderrLineBuffer.slice(0, idx + 1);
+        stderrLineBuffer = stderrLineBuffer.slice(idx + 1);
+        writeWithPrefix(process.stderr, line, coloredPrefix, agentContentColor);
+      }
+    }
+
+    if (!useStderrInherit) {
+      child.stderr.on("data", (chunk) => {
+        const s = typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf-8");
+        const len = buf.length;
+        while (stderrChunks.length > 0 && stderrTotalBytes + len > STDERR_CAP_BYTES) {
+          const drop = stderrChunks.shift();
+          stderrTotalBytes -= Buffer.isBuffer(drop) ? drop.length : Buffer.byteLength(drop, "utf-8");
+        }
+        stderrChunks.push(buf);
+        stderrTotalBytes += len;
+        if (stderrBuffer) {
+          stderrBuffer.push(chunk);
+        } else if (coloredPrefix) {
+          stderrLineBuffer += s;
+          flushStderrLines();
+        } else {
+          process.stderr.write(chunk);
+        }
+        if (flowName && uuid) appendRunLogLine(workspaceRoot, flowName, uuid, "codex-stderr", s);
+      });
+    }
+
+    const stdoutWidth = process.stdout.columns ?? 80;
+    const mdStreamer = createMarkdownStreamer({
+      render: (md) => renderMarkdown(md, { width: stdoutWidth }),
+      spacing: "single",
+    });
+
+    function emitNatural(_kind, text) {
+      assistantTextChunks.push(text);
+      const out = mdStreamer.push(text);
+      if (out) writeStdout(out);
+    }
+
+    function emitStatus(line) {
+      if (line) writeStdout(`[codex] ${line}\n`);
+    }
+
+    child.stdout.setEncoding("utf-8");
+    let stdoutLineBuffer = "";
+    child.stdout.on("data", (chunk) => {
+      stdoutLineBuffer += chunk;
+      const idx = stdoutLineBuffer.lastIndexOf("\n");
+      const complete = idx >= 0 ? stdoutLineBuffer.slice(0, idx) : "";
+      if (idx >= 0) stdoutLineBuffer = stdoutLineBuffer.slice(idx + 1);
+      const lines = complete.split("\n").filter(Boolean);
+      for (const line of lines) {
+        if (flowName && uuid) appendRunLogLine(workspaceRoot, flowName, uuid, "codex-stdout-raw", line);
+        try {
+          const event = JSON.parse(line);
+          const result = handleCodexEvent(event, { emitNatural, emitStatus, onToolCall: options.onToolCall });
+          if (result.hadError) hadError = true;
+          if (!result.handled) writeStdout(`[codex-stdout] event: ${codexEventKind(event)}\n`);
+        } catch (_) {
+          writeStdout(`[codex-stdout] (非 JSON) ${line.slice(0, 500)}${line.length > 500 ? "..." : ""}\n`);
+        }
+      }
+    });
+
+    child.on("error", (err) => {
+      child.stdout?.removeAllListeners();
+      child.stderr?.removeAllListeners();
+      child.removeAllListeners();
+      reject(new Error(`Codex CLI failed to start: ${err.message}. Ensure '${codexCmd}' is in PATH and run 'codex login'.`));
+    });
+
+    child.on("close", (code) => {
+      if (stdoutLineBuffer.trim() && flowName && uuid) {
+        appendRunLogLine(workspaceRoot, flowName, uuid, "codex-stdout-raw", stdoutLineBuffer.trim());
+      }
+      child.stdout.removeAllListeners();
+      if (!useStderrInherit) child.stderr.removeAllListeners();
+      child.removeAllListeners();
+      const tail = mdStreamer.finish();
+      if (tail) writeStdout(tail);
+      if (coloredPrefix && stderrLineBuffer) {
+        writeWithPrefix(process.stderr, stderrLineBuffer.endsWith("\n") ? stderrLineBuffer : stderrLineBuffer + "\n", coloredPrefix);
+      }
+      const finalMessage = fs.existsSync(outputLastMessagePath)
+        ? fs.readFileSync(outputLastMessagePath, "utf-8").trim()
+        : assistantTextChunks.join("").trim();
+      if (code !== 0) {
+        const stderr = Buffer.concat(stderrChunks).toString("utf-8");
+        const stderrTail = stderr ? stderr.trim().slice(-1200) : "";
+        const err = new Error(codexFailureMessage(code, stderrTail, { flowName, uuid }));
+        err.codexStderrTail = stderrTail;
+        reject(err);
+        return;
+      }
+      if (hadError) {
+        reject(new Error(finalMessage || "Codex reported error."));
+        return;
+      }
+      writeAgentTextArtifacts(absResultPath, absRunDir, instanceId, finalMessage || assistantTextChunks.join(""));
+      resolve();
+    });
+  });
+}
+
 const COMPOSER_STATUS_MAX = 200;
 
 /**
@@ -1263,3 +1695,160 @@ export function runClaudeCodeAgentWithPrompt(cliWorkspace, promptText, options =
 
   return { child, finished };
 }
+
+/**
+ * Codex CLI：纯文本 prompt，供 Composer / UI 流式使用；不写 process stdout/stderr。
+ * @returns {{ child: import('child_process').ChildProcess, finished: Promise<void> }}
+ */
+export function runCodexAgentWithPrompt(cliWorkspace, promptText, options = {}) {
+  const onStreamEvent = typeof options.onStreamEvent === "function" ? options.onStreamEvent : null;
+  const ws = path.resolve(cliWorkspace);
+  const model = cleanModel(options.model, "CODEX_MODEL");
+  const codexCmd = process.env.CODEX_CMD || "codex";
+  const tmpDir = path.join(ws, ".workspace", "agentflow", "tmp");
+  fs.mkdirSync(tmpDir, { recursive: true });
+  const outputLastMessagePath = path.join(tmpDir, `codex-last-message-${process.pid}-${Date.now()}.txt`);
+  const args = buildCodexExecArgs({
+    workspace: ws,
+    model,
+    outputLastMessagePath,
+    promptText,
+    configArgs: options.codexConfigArgs,
+  });
+
+  const useStderrInherit =
+    process.env.AGENTFLOW_CODEX_STDERR_INHERIT === "1" ||
+    process.env.AGENTFLOW_CODEX_STDERR_INHERIT === "true";
+  const child = spawn(codexCmd, args, {
+    cwd: ws,
+    stdio: ["ignore", "pipe", useStderrInherit ? "inherit" : "pipe"],
+    shell: false,
+    env: childEnv(options),
+  });
+
+  let hadError = false;
+  let emittedNatural = false;
+  const STDERR_CAP_BYTES = 1024 * 1024;
+  const stderrChunks = [];
+  let stderrTotalBytes = 0;
+  let stderrComposerBuffer = "";
+
+  const emit = (payload) => {
+    try {
+      onStreamEvent?.(payload);
+    } catch (_) {}
+  };
+
+  if (!useStderrInherit) {
+    child.stderr.on("data", (chunk) => {
+      const s = typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf-8");
+      const len = buf.length;
+      while (stderrChunks.length > 0 && stderrTotalBytes + len > STDERR_CAP_BYTES) {
+        const drop = stderrChunks.shift();
+        stderrTotalBytes -= Buffer.isBuffer(drop) ? drop.length : Buffer.byteLength(drop, "utf-8");
+      }
+      stderrChunks.push(buf);
+      stderrTotalBytes += len;
+      stderrComposerBuffer += s;
+      let idx;
+      while ((idx = stderrComposerBuffer.indexOf("\n")) !== -1) {
+        const line = stderrComposerBuffer.slice(0, idx);
+        stderrComposerBuffer = stderrComposerBuffer.slice(idx + 1);
+        if (line.trim()) {
+          emit({ type: "raw", source: "codex", stream: "stderr", eventType: "line", text: rawTraceText(line) });
+          emit({ type: "status", line: `[stderr] ${truncateComposerLine(line)}` });
+        }
+      }
+    });
+  }
+
+  const stdoutWidth = 80;
+  const mdStreamer = createMarkdownStreamer({
+    render: (md) => renderMarkdown(md, { width: stdoutWidth }),
+    spacing: "single",
+  });
+
+  function emitNatural(kind, text) {
+    emittedNatural = true;
+    emit({ type: "natural", kind, text });
+    mdStreamer.push(text);
+    emit({ type: "status", line: kind === "thinking" ? t("runner.thinking") : t("runner.generating_reply") });
+  }
+
+  function emitStatus(line) {
+    if (line) emit({ type: "status", line: truncateComposerLine(line) });
+  }
+
+  child.stdout.setEncoding("utf-8");
+  let stdoutLineBuffer = "";
+  child.stdout.on("data", (chunk) => {
+    stdoutLineBuffer += chunk;
+    const idx = stdoutLineBuffer.lastIndexOf("\n");
+    const complete = idx >= 0 ? stdoutLineBuffer.slice(0, idx) : "";
+    if (idx >= 0) stdoutLineBuffer = stdoutLineBuffer.slice(idx + 1);
+    const lines = complete.split("\n").filter(Boolean);
+    for (const line of lines) {
+      try {
+        const event = JSON.parse(line);
+        emit({ type: "raw", source: "codex", stream: "stdout", eventType: codexEventKind(event), text: rawTraceText(event) });
+        const result = handleCodexEvent(event, { emitNatural, emitStatus, onToolCall: options.onToolCall });
+        if (result.hadError) hadError = true;
+        if (!result.handled) emit({ type: "status", line: `${t("runner.event_label")}: ${codexEventKind(event)}` });
+      } catch (_) {
+        emit({ type: "raw", source: "codex", stream: "stdout", eventType: "line", text: rawTraceText(line) });
+        emit({ type: "status", line: truncateComposerLine(line) });
+      }
+    }
+  });
+
+  const finished = new Promise((resolve, reject) => {
+    child.on("error", (err) => {
+      child.stdout?.removeAllListeners();
+      child.stderr?.removeAllListeners();
+      child.removeAllListeners();
+      reject(new Error(`Codex CLI failed to start: ${err.message}. Ensure '${codexCmd}' is in PATH and run 'codex login'.`));
+    });
+
+    child.on("close", (code) => {
+      if (stdoutLineBuffer.trim()) {
+        emit({ type: "raw", source: "codex", stream: "stdout", eventType: "tail", text: rawTraceText(stdoutLineBuffer.trim()) });
+      }
+      child.stdout.removeAllListeners();
+      if (!useStderrInherit) child.stderr.removeAllListeners();
+      child.removeAllListeners();
+      mdStreamer.finish();
+      if (!useStderrInherit && stderrComposerBuffer.trim()) {
+        const rest = stderrComposerBuffer.trim();
+        emit({ type: "raw", source: "codex", stream: "stderr", eventType: "tail", text: rawTraceText(rest) });
+        emit({ type: "status", line: `[stderr] ${truncateComposerLine(rest)}` });
+      }
+      const finalMessage = fs.existsSync(outputLastMessagePath) ? fs.readFileSync(outputLastMessagePath, "utf-8").trim() : "";
+      if (code !== 0) {
+        const stderr = Buffer.concat(stderrChunks).toString("utf-8");
+        const stderrTail = stderr ? stderr.trim().slice(-1200) : "";
+        const err = new Error(codexFailureMessage(code, stderrTail));
+        err.codexStderrTail = stderrTail;
+        emit({ type: "status", line: truncateComposerLine(err.message) });
+        reject(err);
+        return;
+      }
+      if (hadError) {
+        const msg = finalMessage || "Codex reported error.";
+        emit({ type: "status", line: truncateComposerLine(msg) });
+        reject(new Error(msg));
+        return;
+      }
+      if (finalMessage && !emittedNatural) {
+        emit({ type: "natural", kind: "result", text: finalMessage });
+      }
+      emit({ type: "status", line: t("runner.completed") });
+      try {
+        if (fs.existsSync(outputLastMessagePath)) fs.unlinkSync(outputLastMessagePath);
+      } catch (_) {}
+      resolve();
+    });
+  });
+
+  return { child, finished };
+}

package/bin/lib/auth.mjs

@@ -78,6 +78,12 @@ function parseCookies(header) {
   return out;
 }
 
+function bearerTokenFromAuthHeader(header) {
+  const raw = String(header || "").trim();
+  const m = raw.match(/^Bearer\s+(.+)$/i);
+  return m ? m[1].trim() : "";
+}
+
 export function readAuthUsers() {
   return readJsonObject(usersPath());
 }
@@ -240,8 +246,12 @@ export function buildClearSessionCookie() {
   return `${SESSION_COOKIE}=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0`;
 }
 
+export function getSessionTokenFromRequest(req) {
+  return parseCookies(req.headers.cookie || "")[SESSION_COOKIE] || bearerTokenFromAuthHeader(req.headers.authorization);
+}
+
 export function getAuthUserFromRequest(req) {
-  const token = parseCookies(req.headers.cookie || "")[SESSION_COOKIE];
+  const token = getSessionTokenFromRequest(req);
   if (!token) return null;
   const sessions = readJsonObject(sessionsPath());
   const key = hashToken(token);

package/bin/lib/catalog-flows.mjs

@@ -296,6 +296,8 @@ export function listNodesJson(workspaceRoot, flowId, flowSource, opts = {}) {
       inputs: manifest.input,
       outputs: manifest.output,
       source: manifest.source || "marketplace",
+      ownerUserId: manifest.ownerUserId || manifest.createdBy || "",
+      createdBy: manifest.createdBy || manifest.ownerUserId || "",
       packageDir: manifest.packageDir,
       runtime: manifest.runtime,
     });