@fieldwangai/agentflow 0.1.31 → 0.1.32

package/bin/lib/catalog-flows.mjs

@@ -656,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/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/ui-server.mjs

@@ -74,7 +74,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";
+import { deleteMarketplaceNodePackage, installFlowDependency, listMarketplacePackages, publishNodeFromInstance } from "./marketplace.mjs";
 import {
   authSetupRequired,
   buildClearSessionCookie,
@@ -2280,13 +2280,29 @@ export function startUiServer({
 
     if (req.method === "GET" && url.pathname === "/api/marketplace/nodes") {
       try {
-        json(res, 200, listMarketplacePackages(root));
+        json(res, 200, listMarketplacePackages(root, userCtx));
       } catch (e) {
         json(res, 500, { error: (e && e.message) || String(e) });
       }
       return;
     }
 
+    if (req.method === "DELETE" && url.pathname === "/api/marketplace/node") {
+      const id = url.searchParams.get("id") || "";
+      const version = url.searchParams.get("version") || "";
+      if (!id || !version) {
+        json(res, 400, { ok: false, error: "Missing marketplace node id or version" });
+        return;
+      }
+      try {
+        const result = deleteMarketplaceNodePackage(root, id, version, userCtx);
+        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/install-node") {
       let payload;
       try {