@fieldwangai/agentflow 0.1.30 → 0.1.32

package/bin/lib/agent-runners.mjs

@@ -9,6 +9,8 @@ import { normalizeCursorModelForCli } from "./model-config.mjs";
 import { appendRunLogLine } from "./run-events.mjs";
 import { writeWithPrefix } from "./terminal.mjs";
 import { t } from "./i18n.mjs";
+import { readUserEnvObject } from "./user-env.mjs";
+import { outputNodeBasename } from "../pipeline/get-exec-id.mjs";
 
 function shouldPassCursorModelArg(model) {
   const text = String(model || "").trim();
@@ -17,7 +19,19 @@ function shouldPassCursorModelArg(model) {
 
 function childEnv(options = {}, extra = {}) {
   const optEnv = options && options.env && typeof options.env === "object" ? options.env : {};
-  return { ...process.env, ...optEnv, ...extra };
+  const userId = optEnv.AGENTFLOW_USER_ID || process.env.AGENTFLOW_USER_ID || "";
+  return { ...process.env, ...readUserEnvObject(userId), ...optEnv, ...extra };
+}
+
+function writeAgentTextArtifacts(absResultPath, absRunDir, instanceId, text) {
+  const body = String(text ?? "").trim();
+  if (!body) return;
+  fs.mkdirSync(path.dirname(absResultPath), { recursive: true });
+  fs.writeFileSync(absResultPath, body + "\n", "utf-8");
+  if (!instanceId) return;
+  const slotPath = path.join(absRunDir, "output", instanceId, outputNodeBasename(instanceId, 1, "result"));
+  fs.mkdirSync(path.dirname(slotPath), { recursive: true });
+  fs.writeFileSync(slotPath, body + "\n", "utf-8");
 }
 
 /**
@@ -102,6 +116,7 @@ export function runCursorAgentForNode(
 
     let lastResult = null;
     let hadError = false;
+    const assistantTextChunks = [];
     const STDERR_CAP_BYTES = 1024 * 1024;
     const stderrChunks = [];
     let stderrTotalBytes = 0;
@@ -186,6 +201,7 @@ export function runCursorAgentForNode(
               .join("");
             if (text) {
               text = text.replace(/\\n/g, "\n").replace(/\\t/g, "\t");
+              assistantTextChunks.push(text);
               const out = mdStreamer.push(text);
               if (out) writeStdout(out);
             }
@@ -280,6 +296,7 @@ export function runCursorAgentForNode(
         reject(new Error(lastResult?.result || "Agent reported error."));
         return;
       }
+      writeAgentTextArtifacts(absResultPath, absRunDir, instanceId, assistantTextChunks.join("") || lastResult?.result || "");
       resolve();
     });
   });
@@ -364,6 +381,7 @@ export function runOpenCodeAgentForNode(
 
     let stdoutLogBuf = "";
     let stderrLogBuf = "";
+    let stdoutCaptured = "";
 
     function drainLogBuf(buf, tag) {
       let idx;
@@ -390,7 +408,9 @@ export function runOpenCodeAgentForNode(
     child.stdout.on("data", (chunk) => {
       if (coloredPrefix) writeWithPrefix(process.stdout, chunk, coloredPrefix, agentContentColor);
       else process.stdout.write(agentContentColor(chunk));
-      stdoutLogBuf += String(chunk).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+      const normalizedChunk = String(chunk).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+      stdoutCaptured += normalizedChunk;
+      stdoutLogBuf += normalizedChunk;
       stdoutLogBuf = drainLogBuf(stdoutLogBuf, "opencode-stdout");
     });
 
@@ -422,6 +442,7 @@ export function runOpenCodeAgentForNode(
         reject(new Error(`OpenCode CLI exited ${code}.`));
         return;
       }
+      writeAgentTextArtifacts(absResultPath, absRunDir, instanceId, stripAnsi(stdoutCaptured));
       resolve();
     });
   });
@@ -520,6 +541,7 @@ export function runClaudeCodeAgentForNode(
     let lastResult = null;
     let hadError = false;
     let sessionId = null;
+    const assistantTextChunks = [];
     const STDERR_CAP_BYTES = 1024 * 1024;
     const stderrChunks = [];
     let stderrTotalBytes = 0;
@@ -596,6 +618,7 @@ export function runClaudeCodeAgentForNode(
               if (!block || typeof block !== "object") continue;
               if (block.type === "text" && block.text) {
                 const text = normalizeStreamTextChunk(block.text);
+                assistantTextChunks.push(text);
                 const out = mdStreamer.push(text);
                 if (out) writeStdout(out);
               } else if (block.type === "thinking") {
@@ -664,6 +687,7 @@ export function runClaudeCodeAgentForNode(
         reject(new Error(String(msg)));
         return;
       }
+      writeAgentTextArtifacts(absResultPath, absRunDir, instanceId, assistantTextChunks.join("") || lastResult?.result || "");
       resolve();
     });
   });

package/bin/lib/api-runner.mjs

@@ -19,11 +19,23 @@ import { spawnSync } from "child_process";
 
 import { loadAgentPromptWithReplacements, stripYamlFrontmatter } from "./agents-path.mjs";
 import { appendRunLogLine } from "./run-events.mjs";
+import { outputNodeBasename } from "../pipeline/get-exec-id.mjs";
 
 const DEFAULT_OPENAI_BASE = "https://api.openai.com/v1";
 const MAX_TOOL_ROUNDS = parseInt(process.env.AGENTFLOW_API_MAX_ROUNDS ?? "30", 10) || 30;
 const MAX_TOKENS = parseInt(process.env.AGENTFLOW_API_MAX_TOKENS ?? "8192", 10) || 8192;
 
+function writeAgentTextArtifacts(absResultPath, absRunDir, instanceId, text) {
+  const body = String(text ?? "").trim();
+  if (!body || !absResultPath || !absRunDir) return;
+  fs.mkdirSync(path.dirname(absResultPath), { recursive: true });
+  fs.writeFileSync(absResultPath, body + "\n", "utf-8");
+  if (!instanceId) return;
+  const slotPath = path.join(absRunDir, "output", instanceId, outputNodeBasename(instanceId, 1, "result"));
+  fs.mkdirSync(path.dirname(slotPath), { recursive: true });
+  fs.writeFileSync(slotPath, body + "\n", "utf-8");
+}
+
 // ─── 工具定义 ────────────────────────────────────────────────────────────────
 
 const TOOL_DEFS = [
@@ -203,6 +215,7 @@ async function runOpenAiLoop(apiKey, baseUrl, model, systemPrompt, userContent,
     ...(systemPrompt ? [{ role: "system", content: systemPrompt }] : []),
     { role: "user", content: userContent },
   ];
+  let finalText = "";
 
   for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
     log(`[api/openai] round ${round + 1}`);
@@ -218,6 +231,7 @@ async function runOpenAiLoop(apiKey, baseUrl, model, systemPrompt, userContent,
       const txt = typeof msg.content === "string" ? msg.content : "";
       if (txt.trim()) options.onToolCall("assistant", txt.slice(0, 200));
     }
+    if (typeof msg.content === "string" && msg.content.trim()) finalText = msg.content;
 
     if (choice.finish_reason === "stop" || choice.finish_reason === "end_turn" || !msg.tool_calls?.length) {
       log(`[api/openai] finished (${choice.finish_reason ?? "no-tool-calls"})`);
@@ -240,10 +254,12 @@ async function runOpenAiLoop(apiKey, baseUrl, model, systemPrompt, userContent,
     }
     messages.push(...toolResults);
   }
+  return finalText;
 }
 
 async function runAnthropicLoop(apiKey, model, systemPrompt, userContent, workspaceRoot, log, options) {
   const messages = [{ role: "user", content: userContent }];
+  let finalText = "";
 
   for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
     log(`[api/anthropic] round ${round + 1}`);
@@ -256,6 +272,8 @@ async function runAnthropicLoop(apiKey, model, systemPrompt, userContent, worksp
       const textBlock = resp.content?.find((b) => b.type === "text");
       if (textBlock?.text) options.onToolCall("assistant", textBlock.text.slice(0, 200));
     }
+    const textBlock = resp.content?.find((b) => b.type === "text");
+    if (textBlock?.text?.trim()) finalText = textBlock.text;
 
     if (resp.stop_reason === "end_turn" || resp.stop_reason === "stop_sequence") {
       log(`[api/anthropic] finished (${resp.stop_reason})`);
@@ -280,6 +298,7 @@ async function runAnthropicLoop(apiKey, model, systemPrompt, userContent, worksp
     }
     messages.push({ role: "user", content: toolResults });
   }
+  return finalText;
 }
 
 // ─── 公共解析函数 ─────────────────────────────────────────────────────────────
@@ -313,9 +332,11 @@ export function parseApiModel(str) {
  *   uuid       — 用于日志
  *   onToolCall — (subtype: string, name: string) => void  供 spinner 展示
  */
-export async function runApiAgentForNode(workspaceRoot, { promptPath, nodeContext, taskBody, subagent, instanceId }, options = {}) {
+export async function runApiAgentForNode(workspaceRoot, { promptPath, nodeContext, taskBody, intermediatePath, resultPathRel, subagent, instanceId }, options = {}) {
   const absRoot = path.resolve(workspaceRoot);
   const execRoot = path.resolve(options.execWorkspaceRoot || workspaceRoot);
+  const absRunDir = intermediatePath ? path.resolve(workspaceRoot, intermediatePath) : "";
+  const absResultPath = absRunDir && resultPathRel ? path.join(absRunDir, resultPathRel) : "";
   const flowName = options.flowName ?? null;
   const uuid = options.uuid ?? null;
 
@@ -352,12 +373,14 @@ export async function runApiAgentForNode(workspaceRoot, { promptPath, nodeContex
   if (provider === "anthropic") {
     const key = process.env.ANTHROPIC_API_KEY;
     if (!key) throw new Error("[api-runner] ANTHROPIC_API_KEY is required for api:anthropic/* models");
-    await runAnthropicLoop(key, model, systemPrompt, userContent, execRoot, log, options);
+    const finalText = await runAnthropicLoop(key, model, systemPrompt, userContent, execRoot, log, options);
+    writeAgentTextArtifacts(absResultPath, absRunDir, instanceId, finalText);
   } else {
     const key = process.env.OPENAI_API_KEY;
     if (!key) throw new Error("[api-runner] OPENAI_API_KEY is required for api:openai/* models");
     const baseUrl = (process.env.OPENAI_BASE_URL ?? DEFAULT_OPENAI_BASE).trim();
-    await runOpenAiLoop(key, baseUrl, model, systemPrompt, userContent, execRoot, log, options);
+    const finalText = await runOpenAiLoop(key, baseUrl, model, systemPrompt, userContent, execRoot, log, options);
+    writeAgentTextArtifacts(absResultPath, absRunDir, instanceId, finalText);
   }
 
   log(`done instanceId=${instanceId ?? "-"}`);

package/bin/lib/apply.mjs

@@ -23,6 +23,7 @@ import { formatDuration } from "./terminal.mjs";
 import { printEntryAndFlowFiles, printNodeStatusTable, runValidateFlowAndExitIfInvalid } from "./ui-print.mjs";
 import { clearApplyActiveLock, writeApplyActiveLock } from "./run-apply-active-lock.mjs";
 import { ensureReference, findFlowNameByUuid, getFlowDir, getRunDir } from "./workspace.mjs";
+import { readUserEnvObject } from "./user-env.mjs";
 
 const PARALLEL_PREFIX_COLORS = [
   (s) => chalk.cyan(s),
@@ -344,11 +345,11 @@ ${currentContent}
                     fs.mkdirSync(path.dirname(tmpPromptFile), { recursive: true });
                     fs.writeFileSync(tmpPromptFile, fullPrompt, "utf-8");
                     
-                    const result = spawnSync(opencodeCmd, ["--prompt-file", tmpPromptFile, "--print"], {
-                      cwd: workspaceRoot,
-                      env: { ...process.env, OPENCODE_NON_INTERACTIVE: "1" },
-                      stdio: ["ignore", "pipe", "pipe"],
-                    });
+	                    const result = spawnSync(opencodeCmd, ["--prompt-file", tmpPromptFile, "--print"], {
+	                      cwd: workspaceRoot,
+	                      env: { ...process.env, ...readUserEnvObject(process.env.AGENTFLOW_USER_ID || ""), OPENCODE_NON_INTERACTIVE: "1" },
+	                      stdio: ["ignore", "pipe", "pipe"],
+	                    });
                     
                     try { fs.unlinkSync(tmpPromptFile); } catch (_) {}
                     

package/bin/lib/catalog-flows.mjs

@@ -129,7 +129,10 @@ function normalizeFrontmatterSlots(arr) {
     let def = item.default !== undefined && item.default !== null ? item.default : item.value;
     if (def === undefined || def === null) def = "";
     else if (typeof def !== "string") def = String(def);
-    return { type, name, default: def };
+    const slot = { type, name, default: def };
+    if (item.required != null) slot.required = Boolean(item.required);
+    if (item.showOnNode != null) slot.showOnNode = Boolean(item.showOnNode);
+    return slot;
   });
 }
 
@@ -653,16 +656,38 @@ function resolveMarkdownNodeFile(workspaceRoot, nodeId, flowId, flowSource, opts
 
 function readNodeUsage(workspaceRoot, nodeId, opts = {}) {
   const usage = [];
+  const marketSpec = parseMarketplaceDefinitionId(nodeId);
   for (const flow of listFlowsJson(workspaceRoot, opts)) {
     const flowPath = getFlowYamlAbs(workspaceRoot, flow.id, flow.source || "user", { archived: Boolean(flow.archived), userId: opts.userId });
     if (!flowPath.path) continue;
     try {
       const data = yaml.load(fs.readFileSync(flowPath.path, "utf-8"));
       const instances = data && typeof data === "object" ? data.instances : null;
-      if (!instances || typeof instances !== "object") continue;
-      const hits = Object.entries(instances)
-        .filter(([, inst]) => inst && inst.definitionId === nodeId)
-        .map(([instanceId, inst]) => ({ instanceId, label: inst.label || instanceId }));
+      const hits = [];
+      if (marketSpec) {
+        const deps = data && typeof data === "object" && data.dependencies && typeof data.dependencies === "object" ? data.dependencies : {};
+        const nodeDeps = Array.isArray(deps.nodes) ? deps.nodes : [];
+        if (nodeDeps.some((dep) => {
+          const parsed = typeof dep === "string"
+            ? parseMarketplaceDefinitionId(dep.startsWith("marketplace:") ? dep : `marketplace:${dep}`)
+            : dep && typeof dep === "object"
+              ? { id: dep.id, version: dep.version != null ? String(dep.version) : null }
+              : null;
+          return parsed && parsed.id === marketSpec.id && (!parsed.version || !marketSpec.version || parsed.version === marketSpec.version);
+        })) {
+          hits.push({ instanceId: "dependencies.nodes", label: "dependency" });
+        }
+      }
+      if (instances && typeof instances === "object") {
+        hits.push(...Object.entries(instances)
+          .filter(([, inst]) => {
+            if (!inst) return false;
+            if (!marketSpec) return inst.definitionId === nodeId;
+            const parsed = parseMarketplaceDefinitionId(inst.definitionId);
+            return parsed && parsed.id === marketSpec.id && (!parsed.version || !marketSpec.version || parsed.version === marketSpec.version);
+          })
+          .map(([instanceId, inst]) => ({ instanceId, label: inst.label || instanceId })));
+      }
       if (hits.length > 0) {
         usage.push({ flowId: flow.id, flowSource: flow.source || "user", archived: Boolean(flow.archived), instances: hits });
       }

package/bin/lib/composer-agent.mjs

@@ -7,6 +7,7 @@
 import fs from "fs";
 import path from "path";
 import { getAgentflowDataRoot, sanitizeAgentflowUserId } from "./paths.mjs";
+import { readUserEnvObject } from "./user-env.mjs";
 import { resolveCliAndModel } from "./model-config.mjs";
 import { runClaudeCodeAgentWithPrompt, runCursorAgentWithPrompt, runOpenCodeAgentWithPrompt } from "./agent-runners.mjs";
 import { planComposerTasks, hasPlannerApiAvailable, shouldUsePhased, classifyComplexity, classifyTaskComplexity, PHASED_DEFINITIONS } from "./composer-planner.mjs";
@@ -25,7 +26,7 @@ const MAX_SCRIPT_INJECT_BYTES = 30_000;
 
 function agentflowUserEnv(userId) {
   const safe = sanitizeAgentflowUserId(userId);
-  return safe ? { AGENTFLOW_USER_ID: safe } : {};
+  return safe ? { ...readUserEnvObject(safe), AGENTFLOW_USER_ID: safe } : {};
 }
 
 // ─── script 内容注入辅助 ─────────────────────────────────────────────────

package/bin/lib/locales/en.json

@@ -269,6 +269,10 @@
       "displayName": "CD Workspace",
       "description": "Switch downstream execution to another workspace context without changing the pipeline workspace"
     },
+    "control_user_workspace": {
+      "displayName": "User Workspace",
+      "description": "Output a workspace context pointing to the current user's home directory"
+    },
     "control_load_skills": {
       "displayName": "Load Skills",
       "description": "Load SKILL.md files from the current workspace, pipeline workspace, explicit paths, or both"

package/bin/lib/locales/zh.json

@@ -218,8 +218,8 @@
       "description": "AgentFlow 的结束节点，执行完成后流程结束"
     },
     "agent_subAgent": {
-      "displayName": "SubAgent",
-      "description": "利用 SubAgent 执行任务"
+      "displayName": "子 Agent",
+      "description": "利用子 Agent 执行任务"
     },
     "tool_user_ask": {
       "displayName": "用户选择",
@@ -269,6 +269,10 @@
       "displayName": "CD 工作区",
       "description": "切换下游节点的执行工作区上下文，不改变流水线所在工作区"
     },
+    "control_user_workspace": {
+      "displayName": "用户工作区",
+      "description": "输出指向当前用户 Home 目录的工作区上下文"
+    },
     "control_load_skills": {
       "displayName": "加载 Skills",
       "description": "从当前工作区、流水线工作区、显式路径或组合来源加载 SKILL.md"

package/bin/lib/marketplace.mjs

@@ -2,7 +2,13 @@ import fs from "fs";
 import path from "path";
 import yaml from "js-yaml";
 
-import { MARKETPLACE_PACKAGES_DIR } from "./paths.mjs";
+import {
+  ARCHIVED_PIPELINES_DIR_NAME,
+  LEGACY_PIPELINES_DIR,
+  MARKETPLACE_PACKAGES_DIR,
+  PIPELINES_DIR,
+  getUserPipelinesRoot,
+} from "./paths.mjs";
 
 const NODE_MANIFEST = "node.yaml";
 const COLLECTION_MANIFEST = "collection.yaml";
@@ -100,6 +106,99 @@ function listVersionDirs(baseDir) {
     .filter(Boolean);
 }
 
+function isSafePathSegment(value) {
+  const text = String(value || "").trim();
+  return Boolean(text) && !text.includes("\0") && !path.isAbsolute(text) && !text.split(/[\\/]+/).includes("..");
+}
+
+function resolveWorkspaceNodePackageDir(workspaceRoot, id, version) {
+  if (!isSafePathSegment(id) || !isSafePathSegment(version)) return null;
+  const base = path.resolve(workspacePackageRoot(workspaceRoot), "nodes");
+  const target = path.resolve(base, id, version);
+  if (target !== base && !target.startsWith(base + path.sep)) return null;
+  return target;
+}
+
+function collectFlowDirs(rootDir, source, archived = false) {
+  const out = [];
+  if (!fs.existsSync(rootDir)) return out;
+  let entries = [];
+  try {
+    entries = fs.readdirSync(rootDir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name === ARCHIVED_PIPELINES_DIR_NAME) continue;
+    const dir = path.join(rootDir, entry.name);
+    if (!fs.existsSync(path.join(dir, "flow.yaml"))) continue;
+    out.push({ flowId: entry.name, flowSource: source, archived, flowDir: dir });
+  }
+  return out;
+}
+
+function listWritableFlowDirs(workspaceRoot, opts = {}) {
+  const root = path.resolve(workspaceRoot);
+  const userRoot = getUserPipelinesRoot(opts.userId);
+  const wsRoot = path.join(root, PIPELINES_DIR);
+  const legacyRoot = path.join(root, LEGACY_PIPELINES_DIR);
+  return [
+    ...collectFlowDirs(userRoot, "user", false),
+    ...collectFlowDirs(path.join(userRoot, ARCHIVED_PIPELINES_DIR_NAME), "user", true),
+    ...collectFlowDirs(wsRoot, "workspace", false),
+    ...collectFlowDirs(path.join(wsRoot, ARCHIVED_PIPELINES_DIR_NAME), "workspace", true),
+    ...collectFlowDirs(legacyRoot, "workspace", false),
+    ...collectFlowDirs(path.join(legacyRoot, ARCHIVED_PIPELINES_DIR_NAME), "workspace", true),
+  ];
+}
+
+function depMatchesNode(dep, id, version) {
+  if (typeof dep === "string") {
+    const parsed = parseMarketplaceDefinitionId(dep.startsWith("marketplace:") ? dep : `marketplace:${dep}`);
+    return Boolean(parsed && parsed.id === id && (!parsed.version || parsed.version === version));
+  }
+  if (!dep || typeof dep !== "object") return false;
+  return dep.id === id && (dep.version == null || String(dep.version) === version);
+}
+
+function instanceMatchesNode(inst, id, version) {
+  const parsed = parseMarketplaceDefinitionId(inst?.definitionId);
+  return Boolean(parsed && parsed.id === id && (!parsed.version || parsed.version === version));
+}
+
+export function listMarketplaceNodeUsages(workspaceRoot, id, version, opts = {}) {
+  const usages = [];
+  if (!id || !version) return usages;
+  for (const flow of listWritableFlowDirs(workspaceRoot, opts)) {
+    const flowYamlPath = path.join(flow.flowDir, "flow.yaml");
+    const data = readYamlObject(flowYamlPath);
+    if (!data) continue;
+    const hits = [];
+    const deps = data.dependencies && typeof data.dependencies === "object" ? data.dependencies : {};
+    const nodeDeps = Array.isArray(deps.nodes) ? deps.nodes : [];
+    for (const dep of nodeDeps) {
+      if (depMatchesNode(dep, id, version)) {
+        hits.push({ instanceId: "dependencies.nodes", label: "dependency" });
+      }
+    }
+    const instances = data.instances && typeof data.instances === "object" ? data.instances : {};
+    for (const [instanceId, inst] of Object.entries(instances)) {
+      if (instanceMatchesNode(inst, id, version)) {
+        hits.push({ instanceId, label: inst?.label || instanceId });
+      }
+    }
+    if (hits.length > 0) {
+      usages.push({
+        flowId: flow.flowId,
+        flowSource: flow.flowSource,
+        archived: flow.archived,
+        instances: hits,
+      });
+    }
+  }
+  return usages;
+}
+
 function findNodePackageDir(workspaceRoot, id, version) {
   const root = workspacePackageRoot(workspaceRoot);
   const nodeBase = path.join(root, "nodes", id);
@@ -230,7 +329,7 @@ export function listMarketplaceNodes(workspaceRoot, flowData = null) {
   return out.sort((a, b) => a.id.localeCompare(b.id) || a.version.localeCompare(b.version));
 }
 
-export function listMarketplacePackages(workspaceRoot) {
+export function listMarketplacePackages(workspaceRoot, opts = {}) {
   const root = workspacePackageRoot(workspaceRoot);
   const nodes = listMarketplaceNodes(workspaceRoot).map((n) => ({
     id: n.id,
@@ -242,6 +341,7 @@ export function listMarketplacePackages(workspaceRoot) {
     outputs: n.output,
     packagedFiles: Array.isArray(n.packagedFiles) ? n.packagedFiles : [],
     packageDir: n.packageDir,
+    usage: listMarketplaceNodeUsages(workspaceRoot, n.id, n.version, opts),
   }));
   const collections = [];
   const collectionsRoot = path.join(root, "collections");
@@ -265,6 +365,28 @@ export function listMarketplacePackages(workspaceRoot) {
   return { nodes, collections };
 }
 
+export function deleteMarketplaceNodePackage(workspaceRoot, id, version, opts = {}) {
+  const packageDir = resolveWorkspaceNodePackageDir(workspaceRoot, id, version);
+  if (!packageDir) return { ok: false, error: "Invalid marketplace node id or version" };
+  if (!fs.existsSync(path.join(packageDir, NODE_MANIFEST))) {
+    return { ok: false, error: `Marketplace node package not found: ${id}@${version}` };
+  }
+  const usage = listMarketplaceNodeUsages(workspaceRoot, id, version, opts);
+  if (usage.length > 0) {
+    return { ok: false, error: "Marketplace node is still used by flows", usage };
+  }
+  fs.rmSync(packageDir, { recursive: true, force: true });
+  const versionRoot = path.dirname(packageDir);
+  try {
+    if (fs.existsSync(versionRoot) && fs.readdirSync(versionRoot).length === 0) {
+      fs.rmdirSync(versionRoot);
+    }
+  } catch {
+    /* keep non-empty or unreadable parent */
+  }
+  return { ok: true, id, version, packageDir };
+}
+
 export function writeFlowMarketplaceLock(workspaceRoot, flowDir, flowData) {
   if (!flowData || !flowData.instances || typeof flowData.instances !== "object") return null;
   const nodes = {};

package/bin/lib/node-execute.mjs

@@ -404,7 +404,7 @@ export async function executeNode(workspaceRoot, flowName, uuid, instanceId, pre
     if (cli === "api") {
       await runApiAgentForNode(
         workspaceRoot,
-        { promptPath, nodeContext: nodeContext ?? "", taskBody: taskBody ?? "", subagent, instanceId },
+        { promptPath, nodeContext: nodeContext ?? "", taskBody: taskBody ?? "", intermediatePath, resultPathRel: resultPath, subagent, instanceId },
         {
           model,
           onToolCall: options.onToolCall,

package/bin/lib/paths.mjs

@@ -182,6 +182,10 @@ export function getAgentflowUserConfigAbs() {
   return path.join(getAgentflowDataRoot(), "config.json");
 }
 
+export function getAgentflowUserEnvAbs(userId) {
+  return path.join(getAgentflowUserDataRoot(userId), "env.json");
+}
+
 /** CLI / UI 文案用 */
 export const USER_AGENTFLOW_DIR_LABEL = "~/agentflow";
 export const USER_AGENTFLOW_PIPELINES_LABEL = "~/agentflow/pipelines";
@@ -253,6 +257,7 @@ export const LOCAL_ONLY_DEFINITION_IDS = new Set([
   "control_cancelled",
   "control_interval_loop",
   "control_cd_workspace",
+  "control_user_workspace",
   "control_load_skills",
   "control_start",
   "control_end",

package/bin/lib/scheduler.mjs

@@ -12,6 +12,7 @@ import {
 import { getAgentflowUserContexts, getRunDir, PACKAGE_ROOT } from "./paths.mjs";
 import { isApplyProcessAlive } from "./run-apply-active-lock.mjs";
 import { log } from "./log.mjs";
+import { readUserEnvObject } from "./user-env.mjs";
 import { writeResult } from "../pipeline/write-result.mjs";
 
 const DEFAULT_POLL_MS = 30_000;
@@ -252,7 +253,7 @@ function startScheduledRun(workspaceRoot, flow, schedule, state, opts = {}) {
   const child = spawn(process.execPath, args, {
     cwd: path.resolve(workspaceRoot),
     stdio: ["ignore", "pipe", "pipe"],
-    env: { ...process.env, FORCE_COLOR: "0", AGENTFLOW_USER_ID: opts.userId || "" },
+    env: { ...process.env, ...readUserEnvObject(opts.userId), FORCE_COLOR: "0", AGENTFLOW_USER_ID: opts.userId || "" },
     detached: true,
   });
 
@@ -325,7 +326,7 @@ function startWaitingRunResume(workspaceRoot, flow, waitState, opts = {}) {
   const child = spawn(process.execPath, args, {
     cwd: path.resolve(workspaceRoot),
     stdio: ["ignore", "pipe", "pipe"],
-    env: { ...process.env, FORCE_COLOR: "0", AGENTFLOW_USER_ID: opts.userId || "" },
+    env: { ...process.env, ...readUserEnvObject(opts.userId), FORCE_COLOR: "0", AGENTFLOW_USER_ID: opts.userId || "" },
     detached: true,
   });
   child.stdout.on("data", () => {});