@fieldwangai/agentflow 0.1.67 → 0.1.69

package/bin/lib/admin-storage-config.mjs

@@ -0,0 +1,93 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+import {
+  AGENTFLOW_HOME_CONFIG_PATH,
+  expandAgentflowHomePath,
+  getAgentflowDataRoot,
+  getAgentflowDataRootOverride,
+  writeAgentflowDataRootOverride,
+} from "./paths.mjs";
+
+function defaultAgentflowDataRoot() {
+  return path.join(os.homedir(), "agentflow");
+}
+
+function pathInside(parent, candidate) {
+  const base = path.resolve(parent);
+  const target = path.resolve(candidate);
+  return target === base || target.startsWith(base + path.sep);
+}
+
+function normalizeDataRoot(raw) {
+  const dataRoot = expandAgentflowHomePath(raw);
+  if (dataRoot && !path.isAbsolute(dataRoot)) {
+    throw new Error("dataRoot must be an absolute path");
+  }
+  return dataRoot;
+}
+
+function copyEntry(src, dest) {
+  const stat = fs.lstatSync(src);
+  if (stat.isSymbolicLink()) {
+    if (!fs.existsSync(dest)) fs.symlinkSync(fs.readlinkSync(src), dest);
+    return;
+  }
+  if (stat.isDirectory()) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const name of fs.readdirSync(src)) {
+      copyEntry(path.join(src, name), path.join(dest, name));
+    }
+    return;
+  }
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+}
+
+function migrateDataRoot(oldRoot, newRoot) {
+  const from = path.resolve(oldRoot);
+  const to = path.resolve(newRoot);
+  if (from === to) return { migrated: false, copied: false };
+  if (pathInside(from, to)) {
+    throw new Error("dataRoot target cannot be inside the current data root");
+  }
+  if (pathInside(to, from)) {
+    throw new Error("dataRoot target cannot be a parent of the current data root");
+  }
+  fs.mkdirSync(to, { recursive: true });
+  if (!fs.existsSync(from)) return { migrated: true, copied: false };
+  for (const name of fs.readdirSync(from)) {
+    copyEntry(path.join(from, name), path.join(to, name));
+  }
+  return { migrated: true, copied: true };
+}
+
+export function readAdminStorageConfig() {
+  const envDataRoot = normalizeDataRoot(process.env.AGENTFLOW_HOME || "");
+  const configuredDataRoot = getAgentflowDataRootOverride();
+  return {
+    version: 1,
+    dataRoot: getAgentflowDataRoot(),
+    configuredDataRoot,
+    defaultDataRoot: defaultAgentflowDataRoot(),
+    envDataRoot,
+    envLocked: Boolean(envDataRoot),
+    configPath: AGENTFLOW_HOME_CONFIG_PATH,
+  };
+}
+
+export function writeAdminStorageConfig(config = {}) {
+  const current = readAdminStorageConfig();
+  if (current.envLocked) {
+    throw new Error("AGENTFLOW_HOME is set; update the environment variable instead of Admin Settings");
+  }
+  const nextRoot = normalizeDataRoot(config.dataRoot ?? "");
+  if (!nextRoot) throw new Error("dataRoot is required");
+  const migration = migrateDataRoot(current.dataRoot, nextRoot);
+  writeAgentflowDataRootOverride(nextRoot);
+  return {
+    ...readAdminStorageConfig(),
+    migration,
+  };
+}

package/bin/lib/marketplace.mjs

@@ -708,6 +708,47 @@ function buildPackagedRuntimeFromScript(command, destDir, opts = {}) {
   };
 }
 
+function safePackageRefPath(raw) {
+  const text = String(raw || "").trim().replace(/^["']|["']$/g, "").replace(/\\/g, "/");
+  if (!text || path.isAbsolute(text) || text.includes("\n") || text.includes("\r")) return "";
+  const normalized = path.posix.normalize(text).replace(/^\/+/, "");
+  if (!normalized || normalized === "." || normalized.startsWith("../") || normalized.includes("/../")) return "";
+  return normalized;
+}
+
+function packageNodeReferenceFiles(destDir, opts = {}) {
+  const flowDir = opts.flowDir ? path.resolve(opts.flowDir) : "";
+  const packagedFiles = [];
+  const result = {};
+  const copyRef = (rawRef, targetRel, key) => {
+    const clean = safePackageRefPath(rawRef);
+    if (!clean || !flowDir) return "";
+    const source = path.resolve(flowDir, ...clean.split("/"));
+    if (!isInsideDir(source, flowDir) || !fs.existsSync(source) || !fs.statSync(source).isFile()) return "";
+    const rel = targetRel.replace(/\\/g, "/");
+    const abs = path.join(destDir, rel);
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.copyFileSync(source, abs);
+    packagedFiles.push({ from: source, to: rel, role: key });
+    result[key] = rel;
+    return rel;
+  };
+  const scriptRef = copyRef(opts.scriptRef, `scripts/${path.basename(safePackageRefPath(opts.scriptRef) || "script.mjs")}`, "scriptRef");
+  const implementationRef = copyRef(opts.implementationRef, "implementation.md", "implementationRef");
+  let scriptRuntime = null;
+  if (scriptRef) {
+    const abs = path.join(destDir, scriptRef);
+    scriptRuntime = {
+      type: "tool_nodejs",
+      language: scriptLanguageFor("", scriptRef),
+      entry: scriptRef,
+      args: [],
+    };
+    if (!fs.existsSync(abs)) scriptRuntime = null;
+  }
+  return { ...result, packagedFiles, scriptRuntime };
+}
+
 export function publishNodeFromInstance(workspaceRoot, payload = {}, options = {}) {
   const label = String(payload.label || payload.instanceId || "node").trim();
   const id = safePackageId(payload.id || payload.packageId || label);
@@ -732,6 +773,9 @@ export function publishNodeFromInstance(workspaceRoot, payload = {}, options = {
     ...(slot.showOnNode != null ? { showOnNode: Boolean(slot.showOnNode) } : {}),
   }));
   const script = String(payload.script || "").trim();
+  const scriptRef = String(payload.scriptRef || "").trim();
+  const implementationRef = String(payload.implementationRef || "").trim();
+  const implementationMode = String(payload.implementationMode || "").trim();
   const body = String(payload.body || "").trim();
   const description = String(payload.description || body || `Published from node ${label}`).trim();
   const dest = path.join(workspacePackageRoot(workspaceRoot), "nodes", id, version);
@@ -744,13 +788,18 @@ export function publishNodeFromInstance(workspaceRoot, payload = {}, options = {
   fs.mkdirSync(path.dirname(dest), { recursive: true });
   fs.rmSync(dest, { recursive: true, force: true });
   fs.mkdirSync(dest, { recursive: true });
+  const packagedRefs = packageNodeReferenceFiles(dest, {
+    flowDir: options.flowDir || payload.flowDir,
+    scriptRef,
+    implementationRef,
+  });
   const packagedScript = script
     ? buildPackagedRuntimeFromScript(script, dest, {
         flowDir: options.flowDir || payload.flowDir,
         workspaceRoot,
       })
     : null;
-  const runtime = packagedScript?.runtime || (
+  const runtime = packagedScript?.runtime || packagedRefs.scriptRuntime || (
     script
       ? {
           type: "tool_nodejs",
@@ -775,7 +824,10 @@ export function publishNodeFromInstance(workspaceRoot, payload = {}, options = {
     createdAt: existingManifest?.createdAt || now,
     updatedAt: now,
   };
-  if (packagedScript?.packagedFiles?.length) manifest.packagedFiles = packagedScript.packagedFiles;
+  if (packagedRefs.implementationRef) manifest.implementationRef = packagedRefs.implementationRef;
+  if (implementationMode) manifest.implementationMode = implementationMode;
+  const packagedFiles = [...(packagedScript?.packagedFiles || []), ...(packagedRefs.packagedFiles || [])];
+  if (packagedFiles.length) manifest.packagedFiles = packagedFiles;
   fs.writeFileSync(path.join(dest, NODE_MANIFEST), yaml.dump(manifest, { lineWidth: -1 }), "utf-8");
   fs.writeFileSync(
     path.join(dest, "README.md"),
@@ -791,7 +843,7 @@ export function publishNodeFromInstance(workspaceRoot, payload = {}, options = {
     definitionId: `marketplace:${id}@${version}`,
     baseDefinitionId: manifest.baseDefinitionId,
     marketplaceDefinitionId: `marketplace:${id}@${version}`,
-    packagedFiles: packagedScript?.packagedFiles || [],
+    packagedFiles,
   };
 }
 

package/bin/lib/paths.mjs

@@ -20,17 +20,55 @@ export const PACKAGE_AGENTS_DIR = path.join(PACKAGE_ROOT, "agents");
 export const PACKAGE_AGENTS_JSON = path.join(PACKAGE_AGENTS_DIR, "agents.json");
 
 /**
- * 用户级 AgentFlow 数据根目录：`AGENTFLOW_HOME` 或 `~/agentflow`。
+ * 用户级 AgentFlow 数据根目录：`AGENTFLOW_HOME`、`~/.agentflow/config.json:dataRoot` 或 `~/agentflow`。
  * 与项目根 workspaceRoot 分离；run、pipelines、agents 等均落盘于此。
  */
+export const AGENTFLOW_CONFIG_DIR = path.join(os.homedir(), ".agentflow");
+export const AGENTFLOW_HOME_CONFIG_PATH = path.join(AGENTFLOW_CONFIG_DIR, "config.json");
+
+export function expandAgentflowHomePath(rawPath) {
+  let raw = String(rawPath || "").trim();
+  if (!raw) return "";
+  if (raw === "~") raw = os.homedir();
+  else if (raw.startsWith("~/")) raw = path.join(os.homedir(), raw.slice(2));
+  return path.resolve(raw);
+}
+
+function readAgentflowHomeConfig() {
+  try {
+    if (!fs.existsSync(AGENTFLOW_HOME_CONFIG_PATH)) return {};
+    const parsed = JSON.parse(fs.readFileSync(AGENTFLOW_HOME_CONFIG_PATH, "utf-8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+export function getAgentflowDataRootOverride() {
+  const config = readAgentflowHomeConfig();
+  return expandAgentflowHomePath(config.dataRoot || "");
+}
+
+export function writeAgentflowDataRootOverride(dataRoot) {
+  const nextRoot = expandAgentflowHomePath(dataRoot);
+  if (nextRoot && !path.isAbsolute(nextRoot)) {
+    throw new Error("dataRoot must be an absolute path");
+  }
+  const current = readAgentflowHomeConfig();
+  const next = { ...current, dataRoot: nextRoot };
+  if (!nextRoot) delete next.dataRoot;
+  fs.mkdirSync(path.dirname(AGENTFLOW_HOME_CONFIG_PATH), { recursive: true });
+  fs.writeFileSync(AGENTFLOW_HOME_CONFIG_PATH, JSON.stringify(next, null, 2) + "\n", "utf-8");
+  return nextRoot;
+}
+
 export function getAgentflowDataRoot() {
   const env = process.env.AGENTFLOW_HOME;
   if (env != null && String(env).trim() !== "") {
-    let raw = String(env).trim();
-    if (raw === "~") raw = os.homedir();
-    else if (raw.startsWith("~/")) raw = path.join(os.homedir(), raw.slice(2));
-    return path.resolve(raw);
+    return expandAgentflowHomePath(env);
   }
+  const configured = getAgentflowDataRootOverride();
+  if (configured) return configured;
   return path.join(os.homedir(), "agentflow");
 }