@fieldwangai/agentflow 0.1.68 → 0.1.70

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/apply.mjs

@@ -24,6 +24,7 @@ import { printEntryAndFlowFiles, printNodeStatusTable, runValidateFlowAndExitIfI
 import { clearApplyActiveLock, writeApplyActiveLock } from "./run-apply-active-lock.mjs";
 import { ensureReference, findFlowNameByUuid, getFlowDir, getRunDir } from "./workspace.mjs";
 import { readMergedEnvObject } from "./user-env.mjs";
+import { appendRunLedgerEvent } from "./run-ledger.mjs";
 
 const PARALLEL_PREFIX_COLORS = [
   (s) => chalk.cyan(s),
@@ -72,6 +73,31 @@ export async function apply(workspaceRoot, flowName, uuidArg, dryRun, agentModel
   // 提前 ensure：apply-start 携带原始 run 起始时间，UI 计时器可按「这个 uuid 从头到现在的总时长」显示，
   // 避免每次 resume 仅从 totalExecutedMs 累加看起来像从 resume 才开始计时。
   const priorRunStartTime = ensureRunStartTime(workspaceRoot, flowName, uuid);
+  let runStartTime = priorRunStartTime;
+  let totalExecutedMs = priorTotalExecutedMs;
+  const writeRunLedger = !dryRun;
+  let runLedgerFinished = false;
+  const runLedgerBase = {
+    kind: "pipeline",
+    runId: uuid,
+    userId: String(process.env.AGENTFLOW_USER_ID || ""),
+    username: String(process.env.AGENTFLOW_USER_ID || ""),
+    flowId: flowName,
+    flowSource: "user",
+    at: priorRunStartTime,
+  };
+  if (writeRunLedger) appendRunLedgerEvent({ ...runLedgerBase, type: "run_started" });
+  const finishRunLedger = (status) => {
+    if (!writeRunLedger || runLedgerFinished) return;
+    runLedgerFinished = true;
+    appendRunLedgerEvent({
+      ...runLedgerBase,
+      type: "run_finished",
+      endedAt: Date.now(),
+      durationMs: totalExecutedMs,
+      status,
+    });
+  };
   emitEvent(workspaceRoot, flowName, uuid, {
     event: "apply-start",
     flowName,
@@ -85,8 +111,6 @@ export async function apply(workspaceRoot, flowName, uuidArg, dryRun, agentModel
   writeApplyActiveLock(workspaceRoot, flowName, uuid);
 
   try {
-  let runStartTime = priorRunStartTime;
-  let totalExecutedMs = priorTotalExecutedMs;
   let round = 0;
   while (round < MAX_LOOP_ROUNDS) {
     round++;
@@ -100,6 +124,7 @@ export async function apply(workspaceRoot, flowName, uuidArg, dryRun, agentModel
     if (readyNodes.length === 0) {
       if (allDone) {
         saveTotalExecutedMs(workspaceRoot, flowName, uuid, totalExecutedMs);
+        finishRunLedger("success");
         const totalElapsed = formatDuration(totalExecutedMs);
         emitEvent(workspaceRoot, flowName, uuid, {
           event: "apply-done",
@@ -163,6 +188,7 @@ export async function apply(workspaceRoot, flowName, uuidArg, dryRun, agentModel
             if (options.length === 0) {
               log.info(chalk.yellow(`节点 ${pendId} 未配置任何选项（output 槽位），无法选择。请先在编辑器中添加 output 槽位。`));
               log.info(chalk.bold.yellow("→ " + t("flow.resume_hint") + " ") + resumeExample);
+              finishRunLedger("interrupted");
               return;
             }
 
@@ -177,6 +203,7 @@ export async function apply(workspaceRoot, flowName, uuidArg, dryRun, agentModel
               }
               process.stderr.write(chalk.bold.cyan("━━━━━━━━━━━━━━━━━━━━━━━━━\n"));
               log.info(chalk.bold.yellow("→ " + t("flow.resume_hint") + " ") + resumeExample);
+              finishRunLedger("interrupted");
               return;
             }
 
@@ -209,6 +236,7 @@ export async function apply(workspaceRoot, flowName, uuidArg, dryRun, agentModel
                 if (trimmed === "q") {
                   rl.close();
                   log.info(chalk.yellow("用户取消，流程暂停。") + chalk.dim(` 恢复命令: ${resumeExample}`));
+                  finishRunLedger("interrupted");
                   return;
                 }
                 const idx = parseInt(trimmed, 10);
@@ -250,6 +278,7 @@ export async function apply(workspaceRoot, flowName, uuidArg, dryRun, agentModel
                 }
                 process.stderr.write(chalk.bold.cyan("━━━━━━━━━━━━━━━━━━━━━━━━━\n"));
                 log.info(chalk.bold.yellow("→ " + t("flow.resume_hint") + " ") + resumeExample);
+                finishRunLedger("interrupted");
                 return;
               }
 
@@ -380,6 +409,7 @@ ${currentContent}
                 } else if (answer.trim().toLowerCase() === "q") {
                   rl.close();
                   log.info(chalk.yellow("用户取消，流程暂停。") + chalk.dim(` 恢复命令: ${resumeExample}`));
+                  finishRunLedger("interrupted");
                   return;
                 }
               }
@@ -393,6 +423,7 @@ ${currentContent}
         }
 
         log.info(chalk.bold.yellow("→ " + t("flow.resume_hint") + " ") + resumeExample);
+        finishRunLedger("interrupted");
         return;
       }
       const endNodeIds = Array.isArray(parseOut.nodes)
@@ -401,6 +432,7 @@ ${currentContent}
       const endReached = endNodeIds.some((id) => instanceStatus[id] === "success");
       if (endReached) {
         saveTotalExecutedMs(workspaceRoot, flowName, uuid, totalExecutedMs);
+        finishRunLedger("success");
         const totalElapsed = formatDuration(totalExecutedMs);
         emitEvent(workspaceRoot, flowName, uuid, {
           event: "apply-done",
@@ -763,6 +795,7 @@ ${currentContent}
   maxErr.uuid = uuid;
   throw maxErr;
   } finally {
+    finishRunLedger("failed");
     clearApplyActiveLock(workspaceRoot, flowName, uuid);
   }
 }

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");
 }
 

package/bin/lib/run-ledger.mjs

@@ -0,0 +1,96 @@
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+
+import { getAgentflowDataRoot } from "./paths.mjs";
+
+function localDayKey(timeMs) {
+  const d = new Date(Number(timeMs) || Date.now());
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+
+function safeSegment(value, fallback = "run") {
+  return String(value || fallback)
+    .trim()
+    .replace(/[^a-zA-Z0-9._-]+/g, "_")
+    .replace(/^_+|_+$/g, "")
+    .slice(0, 120) || fallback;
+}
+
+export function runLedgerId(prefix = "run") {
+  return `${safeSegment(prefix, "run")}-${Date.now().toString(36)}-${crypto.randomBytes(4).toString("hex")}`;
+}
+
+export function runLedgerDir() {
+  return path.join(getAgentflowDataRoot(), "admin", "run-ledger");
+}
+
+export function runLedgerPath(timeMs = Date.now()) {
+  return path.join(runLedgerDir(), `${localDayKey(timeMs)}.jsonl`);
+}
+
+export function appendRunLedgerEvent(event = {}) {
+  try {
+    const item = {
+      version: 1,
+      type: String(event.type || ""),
+      kind: String(event.kind || ""),
+      runId: String(event.runId || runLedgerId()),
+      userId: String(event.userId || ""),
+      username: String(event.username || event.userId || ""),
+      flowId: String(event.flowId || ""),
+      flowSource: String(event.flowSource || "user"),
+      runNodeId: String(event.runNodeId || ""),
+      at: Number(event.at || event.startedAt || Date.now()),
+      endedAt: event.endedAt == null ? null : Number(event.endedAt),
+      durationMs: Math.max(0, Number(event.durationMs || 0)),
+      status: event.status ? String(event.status || "") : "",
+    };
+    if (!item.type || !item.kind || !item.runId || !item.flowId) return;
+    const filePath = runLedgerPath(item.at);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.appendFileSync(filePath, JSON.stringify(item) + "\n", "utf-8");
+  } catch {
+    // Usage telemetry must never affect the run itself.
+  }
+}
+
+function readJsonlObjects(filePath) {
+  if (!fs.existsSync(filePath)) return [];
+  try {
+    const out = [];
+    const lines = fs.readFileSync(filePath, "utf-8").split(/\r?\n/);
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const parsed = JSON.parse(line);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) out.push(parsed);
+      } catch {
+        /* ignore malformed line */
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+
+export function readRunLedgerEvents(options = {}) {
+  const dir = runLedgerDir();
+  if (!fs.existsSync(dir)) return [];
+  try {
+    const sinceMs = Number(options?.sinceMs || 0);
+    const sinceKey = Number.isFinite(sinceMs) && sinceMs > 0 ? localDayKey(sinceMs) : "";
+    const files = fs.readdirSync(dir, { withFileTypes: true })
+      .filter((entry) => entry.isFile() && /^\d{4}-\d{2}-\d{2}\.jsonl$/.test(entry.name))
+      .filter((entry) => !sinceKey || entry.name.slice(0, 10) >= sinceKey)
+      .map((entry) => path.join(dir, entry.name))
+      .sort();
+    return files.flatMap((filePath) => readJsonlObjects(filePath));
+  } catch {
+    return [];
+  }
+}