@fieldwangai/agentflow 0.1.26 → 0.1.27

package/bin/lib/scheduler.mjs

@@ -12,9 +12,12 @@ import {
 import { getRunDir, PACKAGE_ROOT } from "./paths.mjs";
 import { isApplyProcessAlive } from "./run-apply-active-lock.mjs";
 import { log } from "./log.mjs";
+import { writeResult } from "../pipeline/write-result.mjs";
 
 const DEFAULT_POLL_MS = 30_000;
 const RUN_CONFIG_FILENAME = "run-config.json";
+const WAIT_STATE_FILENAME = "wait-state.json";
+const WAIT_STATES_FILENAME = "wait-states.json";
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -108,6 +111,104 @@ function getLatestRunUuidForFlow(workspaceRoot, flowId) {
   }
 }
 
+function listRunDirsForFlow(flow) {
+  const flowDir = flow.path || "";
+  const runRoot = flowDir ? path.join(flowDir, "runBuild") : "";
+  if (!runRoot || !fs.existsSync(runRoot)) return [];
+  try {
+    return fs.readdirSync(runRoot, { withFileTypes: true })
+      .filter((e) => e.isDirectory() && /^\d{14}$/.test(e.name))
+      .map((e) => ({ uuid: e.name, runDir: path.join(runRoot, e.name) }));
+  } catch {
+    return [];
+  }
+}
+
+function readJsonObject(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    const state = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    return state && typeof state === "object" ? state : null;
+  } catch {
+    return null;
+  }
+}
+
+function waitStateKey(state) {
+  return String((state && (state.id || state.instanceId)) || "");
+}
+
+function persistedWaitState(state) {
+  const {
+    waitPath: _waitPath,
+    legacyPath: _legacyPath,
+    registryPath: _registryPath,
+    runDir: _runDir,
+    ...persisted
+  } = state && typeof state === "object" ? state : {};
+  return persisted;
+}
+
+function readWaitStates(runDir) {
+  const legacyPath = path.join(runDir, WAIT_STATE_FILENAME);
+  const registryPath = path.join(runDir, WAIT_STATES_FILENAME);
+  const states = [];
+  const seen = new Set();
+  const registry = readJsonObject(registryPath);
+  if (registry && Array.isArray(registry.waits)) {
+    for (const raw of registry.waits) {
+      if (!raw || typeof raw !== "object") continue;
+      const state = { ...raw, runDir, legacyPath, registryPath };
+      const key = waitStateKey(state);
+      if (!key || seen.has(key)) continue;
+      seen.add(key);
+      states.push(state);
+    }
+  }
+  const legacy = readJsonObject(legacyPath);
+  if (legacy) {
+    const state = { ...legacy, runDir, waitPath: legacyPath, legacyPath, registryPath: fs.existsSync(registryPath) ? registryPath : null };
+    const key = waitStateKey(state);
+    if (key && !seen.has(key)) states.push(state);
+  }
+  return states;
+}
+
+function writeWaitState(waitState, patch = {}) {
+  const next = {
+    ...(waitState && typeof waitState === "object" ? waitState : {}),
+    ...(patch && typeof patch === "object" ? patch : {}),
+    updatedAt: new Date().toISOString(),
+  };
+  const runDir = next.runDir || (next.waitPath ? path.dirname(next.waitPath) : "");
+  if (!runDir) return;
+
+  const legacyPath = next.legacyPath || next.waitPath || path.join(runDir, WAIT_STATE_FILENAME);
+  const registryPath = next.registryPath || path.join(runDir, WAIT_STATES_FILENAME);
+  const persisted = persistedWaitState(next);
+  const key = waitStateKey(persisted);
+
+  const registry = readJsonObject(registryPath);
+  if (registry && Array.isArray(registry.waits)) {
+    const waits = registry.waits.filter((w) => waitStateKey(w) !== key);
+    waits.push(persisted);
+    fs.writeFileSync(registryPath, JSON.stringify({ ...registry, updatedAt: new Date().toISOString(), waits }, null, 2) + "\n", "utf-8");
+  }
+  fs.writeFileSync(legacyPath, JSON.stringify(persisted, null, 2) + "\n", "utf-8");
+}
+
+function readNodeResultStatus(runDir, instanceId) {
+  const resultPath = path.join(runDir, "intermediate", instanceId, `${instanceId}.result.md`);
+  if (!fs.existsSync(resultPath)) return null;
+  try {
+    const raw = fs.readFileSync(resultPath, "utf-8");
+    const m = raw.match(/^\s*status:\s*["']?([^"'\s]+)["']?/m);
+    return m ? m[1] : null;
+  } catch {
+    return null;
+  }
+}
+
 function isFlowCurrentlyRunning(workspaceRoot, flowId, state) {
   const candidates = [];
   if (state && typeof state.lastRunUuid === "string") candidates.push(state.lastRunUuid);
@@ -206,6 +307,110 @@ function startScheduledRun(workspaceRoot, flow, schedule, state) {
   return child;
 }
 
+function startWaitingRunResume(workspaceRoot, flow, waitState) {
+  const agentflowBin = path.join(PACKAGE_ROOT, "bin", "agentflow.mjs");
+  const uuid = String(waitState.uuid || "");
+  const instanceId = String(waitState.instanceId || "");
+  const args = [
+    agentflowBin,
+    "resume",
+    flow.id,
+    uuid,
+    instanceId,
+    "--machine-readable",
+    "--workspace-root",
+    path.resolve(workspaceRoot),
+    "--force",
+  ];
+  const child = spawn(process.execPath, args, {
+    cwd: path.resolve(workspaceRoot),
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env, FORCE_COLOR: "0" },
+    detached: true,
+  });
+  child.stdout.on("data", () => {});
+  child.stderr.on("data", (chunk) => {
+    const text = chunk.toString("utf8").trim();
+    if (text) log.debug(`[scheduler] resume ${flow.id}/${uuid}: ${text.slice(0, 1000)}`);
+  });
+  child.on("exit", (code, signal) => {
+    const runDir = waitState.runDir || (waitState.waitPath ? path.dirname(waitState.waitPath) : "");
+    if (!runDir) return;
+    const latest = readWaitStates(runDir).find((s) => waitStateKey(s) === waitStateKey(waitState));
+    if (!latest || latest.wakeAt !== waitState.wakeAt || latest.instanceId !== waitState.instanceId) return;
+    writeWaitState(latest, {
+      status: code === 0 ? "resumed" : "waiting",
+      lastResumeExitCode: code,
+      lastResumeExitSignal: signal || "",
+      lastResumeFinishedAt: new Date().toISOString(),
+      ...(code === 0 ? {} : { lastError: `resume exited with code ${code}${signal ? ` signal ${signal}` : ""}` }),
+    });
+  });
+  child.unref();
+  return child;
+}
+
+function countActiveWaitsForFlow(flow) {
+  let count = 0;
+  for (const run of listRunDirsForFlow(flow)) {
+    for (const waitState of readWaitStates(run.runDir)) {
+      if (waitState && (waitState.status === "waiting" || waitState.status === "resuming")) count += 1;
+    }
+  }
+  return count;
+}
+
+function hasNodeBranchEdge(runDir, instanceId, branchName) {
+  const flowJsonPath = path.join(runDir, "intermediate", "flow.json");
+  const flow = readJsonObject(flowJsonPath);
+  if (!flow || !Array.isArray(flow.edges)) return false;
+  const outputSlotTypes = flow.outputSlotTypes && flow.outputSlotTypes[instanceId];
+  if (!outputSlotTypes || typeof outputSlotTypes !== "object") return false;
+  const idx = Object.keys(outputSlotTypes).indexOf(branchName);
+  if (idx < 0) return false;
+  const sourceHandle = `output-${idx}`;
+  return flow.edges.some((e) => e && e.source === instanceId && (e.sourceHandle || "output-0") === sourceHandle);
+}
+
+export function cancelScheduledRun(workspaceRoot, flowId, uuid) {
+  const flow = listFlowsJson(workspaceRoot).find((f) => f.id === flowId && !f.archived && f.source !== "builtin");
+  if (!flow) return { ok: false, error: `flow not found: ${flowId}` };
+  const runDir = getRunDir(workspaceRoot, flow.id, uuid);
+  if (!fs.existsSync(runDir)) return { ok: false, error: `run not found: ${flowId}/${uuid}` };
+  const cancelledAt = new Date().toISOString();
+  fs.writeFileSync(path.join(runDir, "cancelled.json"), JSON.stringify({ cancelled: true, cancelledAt }, null, 2) + "\n", "utf-8");
+  let updated = 0;
+  let propagated = 0;
+  let resumePid = null;
+  for (const waitState of readWaitStates(runDir)) {
+    if (waitState.status !== "waiting" && waitState.status !== "resuming") continue;
+    const instanceId = String(waitState.instanceId || "");
+    const canPropagate =
+      waitState.reason === "control_interval_loop" &&
+      instanceId &&
+      hasNodeBranchEdge(runDir, instanceId, "cancelled") &&
+      !resumePid;
+    if (canPropagate) {
+      writeResult(
+        workspaceRoot,
+        flow.id,
+        uuid,
+        instanceId,
+        { status: "success", message: "已取消", branch: "cancelled" },
+        { execId: Number(waitState.execId) || undefined, preserveBody: false },
+      );
+      const child = startWaitingRunResume(workspaceRoot, flow, { ...waitState, uuid, runDir, branch: "cancelled" });
+      resumePid = child.pid || null;
+      writeWaitState(waitState, { status: "resuming", branch: "cancelled", cancelledAt, resumePid, resumeStartedAt: cancelledAt });
+      propagated += 1;
+    } else {
+      writeWaitState(waitState, { status: "cancelled", cancelledAt });
+    }
+    updated += 1;
+  }
+  return { ok: true, flowId, uuid, cancelledAt, updatedWaits: updated, propagatedWaits: propagated, resumePid };
+}
+
 export function listScheduleStatuses(workspaceRoot) {
   const rows = [];
   for (const flow of listFlowsJson(workspaceRoot)) {
@@ -232,6 +437,7 @@ export function listScheduleStatuses(workspaceRoot) {
         ? "workspace flow is shadowed by a user flow with the same id"
         : state.lastError || "",
       running: isFlowCurrentlyRunning(workspaceRoot, flow.id, state),
+      waiting: countActiveWaitsForFlow(flow),
     });
   }
   rows.sort((a, b) => {
@@ -251,6 +457,46 @@ export async function startScheduler(workspaceRoot, opts = {}) {
     for (const flow of listFlowsJson(workspaceRoot)) {
       if (flow.archived || flow.source === "builtin") continue;
       const flowSource = flow.source || "user";
+      let resumedWaitingRun = false;
+      for (const run of listRunDirsForFlow(flow)) {
+        if (resumedWaitingRun) break;
+        for (const waitState of readWaitStates(run.runDir)) {
+          if (!waitState || !waitState.wakeAt || !waitState.instanceId) continue;
+          if (waitState.status === "resuming" && !isFlowCurrentlyRunning(workspaceRoot, flow.id, { lastRunUuid: run.uuid })) {
+            const nodeStatus = readNodeResultStatus(run.runDir, String(waitState.instanceId));
+            writeWaitState(waitState, {
+              status: nodeStatus === "pending" ? "waiting" : "resumed",
+              reconciledAt: new Date().toISOString(),
+            });
+            continue;
+          }
+          if (waitState.status !== "waiting") continue;
+          if (Date.parse(waitState.wakeAt) > now) continue;
+          if (isFlowCurrentlyRunning(workspaceRoot, flow.id, { lastRunUuid: run.uuid })) continue;
+          const nextState = {
+            ...waitState,
+            status: "resuming",
+            resumePid: null,
+            resumeStartedAt: new Date().toISOString(),
+          };
+          try {
+            const child = startWaitingRunResume(workspaceRoot, flow, { ...waitState, uuid: run.uuid, runDir: run.runDir });
+            nextState.resumePid = child.pid || null;
+            writeWaitState(waitState, nextState);
+            resumedWaitingRun = true;
+            log.info(`[scheduler] resume ${flow.id}/${run.uuid} at ${waitState.instanceId}; pid=${child.pid || "?"}`);
+            break;
+          } catch (e) {
+            writeWaitState(waitState, {
+              status: "waiting",
+              lastError: e && e.message ? e.message : String(e),
+              lastErrorAt: new Date().toISOString(),
+            });
+            log.info(`[scheduler] resume failed ${flow.id}/${run.uuid}: ${e && e.message ? e.message : String(e)}`);
+          }
+        }
+      }
+
       const scheduleRes = readFlowSchedule(workspaceRoot, flow.id, flowSource);
       if (!scheduleRes.success) {
         log.debug(`[scheduler] ${flow.id}: ${scheduleRes.error}`);

package/bin/lib/ui-server.mjs

@@ -64,6 +64,7 @@ import {
 import { runNodeScript } from "./pipeline-scripts.mjs";
 import { readFlowSchedule, writeFlowSchedule } from "./schedule-config.mjs";
 import { listScheduleStatuses } from "./scheduler.mjs";
+import { installFlowDependency, listMarketplacePackages, publishNodeFromInstance } from "./marketplace.mjs";
 
 const MIME = {
   ".html": "text/html; charset=utf-8",
@@ -885,6 +886,77 @@ export function startUiServer({
       return;
     }
 
+    if (req.method === "GET" && url.pathname === "/api/marketplace/nodes") {
+      try {
+        json(res, 200, listMarketplacePackages(root));
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/marketplace/install-node") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      const flowId = payload?.flowId;
+      const flowSource = payload?.flowSource || "user";
+      const flowArchived = payload?.archived === true;
+      const nodeSpec = payload?.nodeSpec || payload?.definitionId || payload?.id;
+      if (!flowId) {
+        json(res, 400, { error: "Missing flowId" });
+        return;
+      }
+      if (!nodeSpec) {
+        json(res, 400, { error: "Missing nodeSpec" });
+        return;
+      }
+      if (flowArchived || !isValidFlowSourceWrite(flowSource)) {
+        json(res, 400, { error: "Cannot install marketplace nodes into builtin or archived flow" });
+        return;
+      }
+      try {
+        const resolved = resolveFlowDirForWrite(root, flowId, flowSource);
+        if (resolved.error || !resolved.flowDir) {
+          json(res, 400, { error: resolved.error || "Could not resolve flow directory" });
+          return;
+        }
+        const result = installFlowDependency(root, resolved.flowDir, nodeSpec);
+        json(res, result.ok ? 200 : 400, result);
+      } catch (e) {
+        json(res, 500, { ok: false, error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/marketplace/publish-node-from-instance") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      try {
+        const flowId = payload?.flowId;
+        const flowSource = payload?.flowSource || "user";
+        let flowDir = "";
+        if (flowId && isValidFlowSourceWrite(flowSource)) {
+          const resolved = resolveFlowDirForWrite(root, flowId, flowSource);
+          if (!resolved.error && resolved.flowDir) flowDir = resolved.flowDir;
+        }
+        const result = publishNodeFromInstance(root, payload || {}, { flowDir });
+        json(res, result.ok ? 200 : 400, result);
+      } catch (e) {
+        json(res, 500, { ok: false, error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "GET" && url.pathname === "/api/flow") {
       const flowId = url.searchParams.get("flowId");
       const flowSource = url.searchParams.get("flowSource") || "user";

package/bin/pipeline/build-node-prompt.mjs

@@ -11,6 +11,7 @@ import { fileURLToPath } from "url";
 
 import { getRunDir, PIPELINES_DIR } from "../lib/paths.mjs";
 import { getFlowDir } from "../lib/workspace.mjs";
+import { isMarketplaceDefinitionId, resolveMarketplaceNodePackage } from "../lib/marketplace.mjs";
 import { loadFlowDefinition } from "./parse-flow.mjs";
 import { getResolvedValues, getOutputPathForSlot } from "./get-resolved-values.mjs";
 import { loadExecId } from "./get-exec-id.mjs";
@@ -22,7 +23,8 @@ function shellQuote(s) {
 }
 
 function resolvePlaceholder(k, resolvedInputs, resolvedOutputs, opts) {
-  const { instanceId, currentExecId, runDir } = opts;
+  const { instanceId, currentExecId, runDir, extra = {} } = opts;
+  if (Object.prototype.hasOwnProperty.call(extra, k)) return extra[k];
   const execId = currentExecId ?? 1;
   const toAbs = (rel) => (runDir && rel ? path.join(runDir, rel) : rel);
   if (k.startsWith("input.")) {
@@ -76,6 +78,39 @@ function resolveScriptCommand(
   });
 }
 
+function marketplaceRuntimeCommand(marketplaceNode, resolvedInputs, resolvedOutputs, opts) {
+  if (!marketplaceNode || !marketplaceNode.runtime) return "";
+  const runtime = marketplaceNode.runtime;
+  const packageDir = marketplaceNode.packageDir;
+  const entry = runtime.entry ? path.join(packageDir, String(runtime.entry)) : "";
+  const language = String(runtime.language || "").trim();
+  const runner =
+    language === "python"
+      ? "python3"
+      : language === "bash"
+        ? "bash"
+        : language === "nodejs" || entry
+          ? "node"
+          : "";
+  const args = Array.isArray(runtime.args) ? runtime.args.map((x) => String(x)).join(" ") : "";
+  const command = runtime.command
+    ? String(runtime.command)
+    : entry
+      ? [runner, "${entry}", args].filter(Boolean).join(" ")
+      : "";
+  if (!command) return "";
+  return resolveScriptCommand(command, resolvedInputs, resolvedOutputs, {
+    ...opts,
+    extra: {
+      ...(opts.extra || {}),
+      entry,
+      packageDir,
+      workspaceRoot: opts.workspaceRoot || "",
+      runDir: opts.runDir || "",
+    },
+  });
+}
+
 /**
  * 执行占位符替换，组装 prompt 并写入 intermediate 文件（文件名带 _execId）。
  * @param {number} [execId] - 本轮 execId，缺省则从 memory 读取
@@ -105,6 +140,10 @@ export function buildNodePrompt(workspaceRoot, flowName, uuid, instanceId, execI
 
   const flowData = loadFlowDefinition(flowDir);
   const inst = flowData?.instances?.[instanceId];
+  const marketplaceNode =
+    inst?.definitionId && isMarketplaceDefinitionId(inst.definitionId)
+      ? resolveMarketplaceNodePackage(workspaceRoot, flowDir, inst.definitionId, flowData)
+      : null;
   const instanceBody =
     inst?.body != null
       ? String(inst.body || "").trim()
@@ -115,7 +154,7 @@ export function buildNodePrompt(workspaceRoot, flowName, uuid, instanceId, execI
       : "";
 
   const { resolvedInputs = {}, resolvedOutputs = {}, systemPrompt = "" } = data;
-  const resolveOpts = { instanceId, currentExecId: e, runDir };
+  const resolveOpts = { instanceId, currentExecId: e, runDir, workspaceRoot };
   const taskBody = resolvePlaceholdersInText(
     instanceBody,
     resolvedInputs,
@@ -125,6 +164,8 @@ export function buildNodePrompt(workspaceRoot, flowName, uuid, instanceId, execI
 
   const resolvedScript = instanceScript
     ? resolveScriptCommand(instanceScript, resolvedInputs, resolvedOutputs, resolveOpts)
+    : marketplaceNode
+      ? marketplaceRuntimeCommand(marketplaceNode, resolvedInputs, resolvedOutputs, resolveOpts)
     : "";
 
   const content = `## 节点上下文

package/bin/pipeline/get-ready-nodes.mjs

@@ -248,7 +248,7 @@ function main() {
     for (const id of pendingInstances) {
       if (instanceStatus[id] !== "success") continue;
       nextPending.delete(id);
-      if (nodeDefinitions[id] === "control_if" || nodeDefinitions[id] === "tool_user_ask") {
+      if (nodeDefinitions[id] === "control_if" || nodeDefinitions[id] === "tool_user_ask" || nodeDefinitions[id] === "control_interval_loop") {
         const predLatestE = latestResultExecId(execIdMap[id] ?? 1);
         const resultPath = predLatestE
           ? path.join(intermediateDir, id, intermediateResultBasename(id, predLatestE))
@@ -309,7 +309,7 @@ function main() {
     /** 判断 predecessor P 对 target N 是否算「就绪」：普通节点看 status；control_if / tool_user_ask 看 branch 与出边 sourceHandle */
     const isPredecessorReadyFor = (predSource, predDefId, targetId) => {
       if (instanceStatus[predSource] !== "success") return false;
-      if (predDefId !== "control_if" && predDefId !== "tool_user_ask") return true;
+      if (predDefId !== "control_if" && predDefId !== "tool_user_ask" && predDefId !== "control_interval_loop") return true;
       const inEdges = inEdgesByTarget[targetId] || [];
       const edge = inEdges.find((ie) => ie.source === predSource);
       if (!edge) return true;

package/bin/pipeline/get-resolved-values.mjs

@@ -10,6 +10,7 @@ import fs from "fs";
 import path from "path";
 
 import { getRunDir, LEGACY_NODES_DIR, PIPELINES_DIR, PROJECT_NODES_DIR } from "../lib/paths.mjs";
+import { isMarketplaceDefinitionId, resolveMarketplaceNodePackage } from "../lib/marketplace.mjs";
 import { getFlowDir } from "../lib/workspace.mjs";
 import { fileURLToPath } from "url";
 
@@ -102,6 +103,11 @@ function extractDescriptionFromFrontmatter(frontmatter) {
 }
 
 function readNodeDescription(workspaceRoot, flowDir, definitionId) {
+  if (isMarketplaceDefinitionId(definitionId)) {
+    const flowData = loadFlowDefinition(flowDir);
+    const resolved = resolveMarketplaceNodePackage(workspaceRoot, flowDir, definitionId, flowData);
+    if (resolved?.description) return resolved.description;
+  }
   const fileName = definitionId.endsWith(".md") ? definitionId : `${definitionId}.md`;
   const flowNodesPath = path.join(flowDir, "nodes", fileName);
   const projectNodesNew = path.join(workspaceRoot, PROJECT_NODES_DIR, fileName);

package/bin/pipeline/parse-flow.mjs

@@ -14,6 +14,7 @@ import yaml from "js-yaml";
 
 import { getRunDir, LEGACY_NODES_DIR, PIPELINES_DIR, PROJECT_NODES_DIR } from "../lib/paths.mjs";
 import { getFlowDir } from "../lib/workspace.mjs";
+import { isMarketplaceDefinitionId, resolveMarketplaceNodePackage, writeFlowMarketplaceLock } from "../lib/marketplace.mjs";
 import { loadAllExecIds, latestResultExecId, intermediateResultBasename, intermediateDirForNode, outputDirForNode } from "./get-exec-id.mjs";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -39,6 +40,7 @@ function loadFlowDefinition(flowDir) {
       instances: data.instances && typeof data.instances === "object" ? data.instances : {},
       edges,
       ui: data.ui && typeof data.ui === "object" ? data.ui : {},
+      dependencies: data.dependencies && typeof data.dependencies === "object" ? data.dependencies : {},
     };
   } catch {
     return null;
@@ -48,6 +50,7 @@ function loadFlowDefinition(flowDir) {
 /** 由 definitionId 前缀推导 type */
 function definitionIdToType(definitionId) {
   const id = (definitionId || "").toLowerCase();
+  if (id.startsWith("marketplace:")) return "agent";
   if (id.startsWith("control_")) return "control";
   if (id.startsWith("agent_")) return "agent";
   if (id.startsWith("provide_")) return "provide";
@@ -62,8 +65,14 @@ function definitionIdToType(definitionId) {
  * @param {string} definitionName - 实例中引用的定义名（如 user_confirm_scope）
  * @returns {{ definitionId: string, definitionName: string }}
  */
-function resolveDefinitionIdFromNodeClass(flowDir, definitionName) {
-  const workspaceRoot = path.resolve(flowDir, "..", "..", "..", "..");
+function resolveDefinitionIdFromNodeClass(flowDir, definitionName, workspaceRoot, flowData) {
+  if (isMarketplaceDefinitionId(definitionName)) {
+    const resolved = resolveMarketplaceNodePackage(workspaceRoot, flowDir, definitionName, flowData);
+    return {
+      definitionId: resolved?.resolvedDefinitionId || definitionName,
+      definitionName,
+    };
+  }
   const fileName = definitionName.endsWith(".md") ? definitionName : `${definitionName}.md`;
   const flowNodesPath = path.join(flowDir, "nodes", fileName);
   const projectNodesNew = path.join(workspaceRoot, PROJECT_NODES_DIR, fileName);
@@ -85,7 +94,7 @@ function resolveDefinitionIdFromNodeClass(flowDir, definitionName) {
 }
 
 /** 从 loadFlowDefinition 结果得到 nodes 和 edges（与 readFlowMd 输出形状一致） */
-function readFlowFromYaml(flowDir) {
+function readFlowFromYaml(flowDir, workspaceRoot = path.resolve(flowDir, "..", "..", "..", "..")) {
   const def = loadFlowDefinition(flowDir);
   if (!def) return { nodes: [], edges: [] };
   const instances = def.instances;
@@ -98,7 +107,7 @@ function readFlowFromYaml(flowDir) {
   const nodes = Array.from(nodeIds).map((id) => {
     const inst = instances[id] || {};
     const definitionName = inst.definitionId ?? id;
-    const { definitionId } = resolveDefinitionIdFromNodeClass(flowDir, definitionName);
+    const { definitionId } = resolveDefinitionIdFromNodeClass(flowDir, definitionName, workspaceRoot, def);
     const type = definitionIdToType(definitionId);
     const label = inst.label != null ? String(inst.label) : id;
     const role =
@@ -613,7 +622,8 @@ function main() {
     process.exit(1);
   }
   try {
-    const { nodes, edges } = readFlowFromYaml(flowDir);
+    writeFlowMarketplaceLock(workspaceRoot || path.resolve(flowDir, "..", "..", "..", ".."), flowDir, flowData);
+    const { nodes, edges } = readFlowFromYaml(flowDir, workspaceRoot || path.resolve(flowDir, "..", "..", "..", ".."));
     const { order: topoOrder, hasCycle } = topoSort(nodes, edges);
     const order = hasCycle ? nodes.map((n) => n.id) : topoOrder;
     const cycleNodes = hasCycle ? Array.from(findCycleNodes(nodes, edges)) : [];