@fieldwangai/agentflow 0.1.29 → 0.1.31

package/bin/lib/user-env.mjs

@@ -0,0 +1,83 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+import { getAgentflowUserEnvAbs, sanitizeAgentflowUserId } from "./paths.mjs";
+
+function normalizeEnvKey(key) {
+  return String(key || "").trim();
+}
+
+function isValidEnvKey(key) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key);
+}
+
+function readJsonObject(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return {};
+    const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    return data && typeof data === "object" && !Array.isArray(data) ? data : {};
+  } catch {
+    return {};
+  }
+}
+
+function getFromConfig(config, keyStr) {
+  if (!config || typeof config !== "object" || !keyStr) return undefined;
+  const parts = String(keyStr).trim().split(".");
+  let cur = config;
+  for (const p of parts) {
+    if (cur == null || typeof cur !== "object") return undefined;
+    cur = cur[p];
+  }
+  return cur != null ? String(cur) : undefined;
+}
+
+export function normalizeUserEnvRows(rawRows) {
+  const rows = Array.isArray(rawRows) ? rawRows : [];
+  const byKey = new Map();
+  for (const item of rows) {
+    if (!item || typeof item !== "object") continue;
+    const key = normalizeEnvKey(item.key);
+    if (!key || !isValidEnvKey(key)) continue;
+    byKey.set(key, String(item.value ?? ""));
+  }
+  return Array.from(byKey.entries())
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([key, value]) => ({ key, value }));
+}
+
+export function readUserEnvRows(userId) {
+  const data = readJsonObject(getAgentflowUserEnvAbs(userId));
+  return normalizeUserEnvRows(Array.isArray(data.env) ? data.env : []);
+}
+
+export function readUserEnvObject(userId) {
+  const out = {};
+  for (const row of readUserEnvRows(userId)) {
+    out[row.key] = row.value;
+  }
+  return out;
+}
+
+export function writeUserEnvRows(userId, rows) {
+  const normalized = normalizeUserEnvRows(rows);
+  const safeUserId = sanitizeAgentflowUserId(userId);
+  const filePath = getAgentflowUserEnvAbs(safeUserId);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify({ version: 1, env: normalized }, null, 2) + "\n", "utf-8");
+  return normalized;
+}
+
+export function resolveUserEnvValue(key, userId) {
+  const keyStr = normalizeEnvKey(key);
+  if (!keyStr) return "";
+  const userEnv = readUserEnvObject(userId);
+  if (Object.prototype.hasOwnProperty.call(userEnv, keyStr)) return String(userEnv[keyStr] ?? "");
+  const processValue = process.env[keyStr];
+  if (processValue != null && processValue !== "") return String(processValue);
+  const configPath = path.join(os.homedir(), ".cursor", "config.json");
+  const fromConfig = getFromConfig(readJsonObject(configPath), keyStr);
+  return fromConfig !== undefined ? fromConfig : "";
+}
+

package/bin/lib/workspace-tree.mjs

@@ -221,13 +221,14 @@ function readFilesRecursive(dir, baseDir, maxDepth = 2, currentDepth = 0) {
   }
 }
 
-export function getPipelineFiles(workspaceRoot, flowId, flowSource, archived = false) {
+export function getPipelineFiles(workspaceRoot, flowId, flowSource, archived = false, opts = {}) {
   const root = path.resolve(workspaceRoot);
   let pipelineDir = null;
+  const userPipelinesRoot = getUserPipelinesRoot(opts.userId);
 
   if (archived) {
     if (flowSource === "user") {
-      pipelineDir = path.join(getUserPipelinesRoot(), ARCHIVED_PIPELINES_DIR_NAME, flowId);
+      pipelineDir = path.join(userPipelinesRoot, ARCHIVED_PIPELINES_DIR_NAME, flowId);
     } else if (flowSource === "workspace") {
       pipelineDir = path.join(root, PIPELINES_DIR, ARCHIVED_PIPELINES_DIR_NAME, flowId);
       if (!fs.existsSync(pipelineDir)) {
@@ -239,7 +240,7 @@ export function getPipelineFiles(workspaceRoot, flowId, flowSource, archived = f
     if (flowSource === "builtin") {
       pipelineDir = path.join(PACKAGE_BUILTIN_PIPELINES_DIR, flowId);
     } else if (flowSource === "user") {
-      pipelineDir = path.join(getUserPipelinesRoot(), flowId);
+      pipelineDir = path.join(userPipelinesRoot, flowId);
       if (!fs.existsSync(pipelineDir)) {
         const alt = path.join(root, PIPELINES_DIR, flowId);
         if (fs.existsSync(alt)) pipelineDir = alt;

package/bin/lib/workspace.mjs

@@ -9,6 +9,7 @@ import {
   getReferenceRootAbs,
   getWorkspaceRunBuildRoot,
   getUserPipelinesRoot,
+  resolveUniqueUserPipelineDir,
   ARCHIVED_PIPELINES_DIR_NAME,
 } from "./paths.mjs";
 
@@ -23,7 +24,7 @@ export { getRunDir } from "./paths.mjs";
  * - legacyUserRoot: ~/agentflow/runBuild/<name>/<uuid>
  * 后两者仅作为向下兼容读取；新写入只走 user/workspace。
  */
-export function listAllRunDirs(workspaceRoot) {
+export function listAllRunDirs(workspaceRoot, opts = {}) {
   const root = path.resolve(workspaceRoot);
   const out = [];
   const seen = new Set();
@@ -62,7 +63,7 @@ export function listAllRunDirs(workspaceRoot) {
   };
 
   // 新位置（优先）
-  scanPipelinesDir(getUserPipelinesRoot(), "user");
+  scanPipelinesDir(getUserPipelinesRoot(opts.userId), "user");
   scanPipelinesDir(path.join(root, PIPELINES_DIR), "workspace");
 
   // 旧位置（兼容读）
@@ -138,25 +139,22 @@ export function listRunsWithLogs(workspaceRoot) {
   return list;
 }
 
-/** 解析 flow 目录：~/agentflow/pipelines → .workspace/agentflow/pipelines → .cursor/agentflow/pipelines（旧）→ builtin/pipelines */
-export function getFlowDir(workspaceRoot, flowName) {
+/** 解析活跃 flow 目录：user → workspace → legacy workspace → builtin。归档 flow 必须走显式 archived resolver。 */
+export function getFlowDir(workspaceRoot, flowName, opts = {}) {
   const root = path.resolve(workspaceRoot);
   const hasFlow = (dir) => fs.existsSync(dir) && fs.existsSync(path.join(dir, "flow.yaml"));
 
   // user pipelines
-  const userRoot = getUserPipelinesRoot();
+  const userRoot = getUserPipelinesRoot(opts.userId);
   const userFlowDir = path.join(userRoot, flowName);
   if (hasFlow(userFlowDir)) return userFlowDir;
-  // user archived
-  const userArchivedDir = path.join(userRoot, ARCHIVED_PIPELINES_DIR_NAME, flowName);
-  if (hasFlow(userArchivedDir)) return userArchivedDir;
+
+  const inferredUserFlowDir = resolveUniqueUserPipelineDir(flowName);
+  if (inferredUserFlowDir) return inferredUserFlowDir;
 
   // workspace pipelines
   const wsFlowDir = path.join(root, PIPELINES_DIR, flowName);
   if (hasFlow(wsFlowDir)) return wsFlowDir;
-  // workspace archived
-  const wsArchivedDir = path.join(root, PIPELINES_DIR, ARCHIVED_PIPELINES_DIR_NAME, flowName);
-  if (hasFlow(wsArchivedDir)) return wsArchivedDir;
 
   // legacy
   const legacyFlowDir = path.join(root, LEGACY_PIPELINES_DIR, flowName);

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

@@ -16,6 +16,7 @@ import { loadFlowDefinition } from "./parse-flow.mjs";
 import { getResolvedValues, getOutputPathForSlot } from "./get-resolved-values.mjs";
 import { loadExecId } from "./get-exec-id.mjs";
 import { intermediatePromptBasename, intermediateDirForNode } from "./get-exec-id.mjs";
+import { normalizeSkillsContext, normalizeWorkspaceContext, renderSkillsContextForPrompt } from "../lib/runtime-context.mjs";
 
 function shellQuote(s) {
   if (s == null) return "''";
@@ -116,7 +117,7 @@ function marketplaceRuntimeCommand(marketplaceNode, resolvedInputs, resolvedOutp
  * @param {number} [execId] - 本轮 execId，缺省则从 memory 读取
  * @returns {{ ok: boolean, promptPath?: string, nodeContext?: string, taskBody?: string, error?: string }}
  */
-export function buildNodePrompt(workspaceRoot, flowName, uuid, instanceId, execId) {
+export function buildNodePrompt(workspaceRoot, flowName, uuid, instanceId, execId, opts = {}) {
   const runDir = getRunDir(workspaceRoot, flowName, uuid);
   const flowJsonPath = path.join(runDir, "intermediate", "flow.json");
   let flowDir = getFlowDir(workspaceRoot, flowName) || path.join(workspaceRoot, PIPELINES_DIR, flowName);
@@ -154,7 +155,26 @@ export function buildNodePrompt(workspaceRoot, flowName, uuid, instanceId, execI
       : "";
 
   const { resolvedInputs = {}, resolvedOutputs = {}, systemPrompt = "" } = data;
-  const resolveOpts = { instanceId, currentExecId: e, runDir, workspaceRoot };
+  const workspaceContext = normalizeWorkspaceContext(opts.workspaceContext || resolvedInputs.workspaceContext, workspaceRoot, flowName, { flowDir });
+  const skillsContext = normalizeSkillsContext(opts.skillsContext || resolvedInputs.skillsContext);
+  if (workspaceContext?.workspaceRoot) {
+    resolvedInputs.workspaceRoot = workspaceContext.workspaceRoot;
+    resolvedInputs.cwd = workspaceContext.cwd || workspaceContext.workspaceRoot;
+    resolvedInputs.pipelineWorkspace = workspaceContext.pipelineWorkspace || path.resolve(workspaceRoot);
+  }
+  const resolveOpts = {
+    instanceId,
+    currentExecId: e,
+    runDir,
+    workspaceRoot: workspaceContext?.workspaceRoot || workspaceRoot,
+    extra: {
+      workspaceRoot: workspaceContext?.workspaceRoot || path.resolve(workspaceRoot),
+      cwd: workspaceContext?.cwd || workspaceContext?.workspaceRoot || path.resolve(workspaceRoot),
+      pipelineWorkspace: workspaceContext?.pipelineWorkspace || path.resolve(workspaceRoot),
+      flowDir: path.resolve(flowDir),
+      runDir,
+    },
+  };
   const taskBody = resolvePlaceholdersInText(
     instanceBody,
     resolvedInputs,
@@ -168,9 +188,12 @@ export function buildNodePrompt(workspaceRoot, flowName, uuid, instanceId, execI
       ? marketplaceRuntimeCommand(marketplaceNode, resolvedInputs, resolvedOutputs, resolveOpts)
     : "";
 
+  const skillsPrompt = renderSkillsContextForPrompt(skillsContext);
+  const contextBlocks = [systemPrompt || "(无)", skillsPrompt].filter((x) => x && String(x).trim());
+
   const content = `## 节点上下文
 
-${systemPrompt || "(无)"}
+${contextBlocks.join("\n\n")}
 
 ## 执行任务
 
@@ -191,9 +214,11 @@ ${taskBody || "(无)"}
   return {
     ok: true,
     promptPath: relativePath.replace(/\\/g, "/"),
-    nodeContext: systemPrompt || "",
+    nodeContext: contextBlocks.join("\n\n") || "",
     taskBody: taskBody || "",
     script: resolvedScript || "",
+    workspaceContext,
+    skillsContext,
   };
 }
 

package/bin/pipeline/get-env.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
- * apply -ai get-env：按 key 从系统环境变量与 ~/.cursor/config.json 读取 value。
- * 优先级：先查 process.env[key]，若无则查 ~/.cursor/config.json（支持点号路径如 openai.apiKey）。
+ * apply -ai get-env：按 key 从用户私有 env、系统环境变量与 ~/.cursor/config.json 读取 value。
+ * 优先级：先查当前 AGENTFLOW_USER_ID 的私有 env，再查 process.env[key]，最后查 ~/.cursor/config.json（支持点号路径如 openai.apiKey）。
  *
  * 用法（apply 步骤，由 CLI 调用）：
  *   agentflow apply -ai get-env <workspaceRoot> <flowName> <uuid> <instanceId> <execId> <key>
@@ -15,39 +15,15 @@
 
 import fs from "fs";
 import path from "path";
-import os from "os";
 
 import { getRunDir } from "../lib/paths.mjs";
+import { resolveUserEnvValue } from "../lib/user-env.mjs";
 import { writeResult } from "./write-result.mjs";
 import { outputDirForNode, outputNodeBasename } from "./get-exec-id.mjs";
 
-function getFromConfig(config, keyStr) {
-  if (!config || typeof config !== "object" || !keyStr) return undefined;
-  const parts = String(keyStr).trim().split(".");
-  let cur = config;
-  for (const p of parts) {
-    if (cur == null || typeof cur !== "object") return undefined;
-    cur = cur[p];
-  }
-  return cur != null ? String(cur) : undefined;
-}
-
 function resolveValue(keyStr) {
-  let value = "";
-  if (!keyStr) return value;
-  value = process.env[keyStr] ?? "";
-  if (value === "") {
-    const configPath = path.join(os.homedir(), ".cursor", "config.json");
-    if (fs.existsSync(configPath)) {
-      try {
-        const raw = fs.readFileSync(configPath, "utf-8");
-        const config = JSON.parse(raw);
-        const fromConfig = getFromConfig(config, keyStr);
-        if (fromConfig !== undefined) value = fromConfig;
-      } catch (_) {}
-    }
-  }
-  return value;
+  if (!keyStr) return "";
+  return resolveUserEnvValue(keyStr, process.env.AGENTFLOW_USER_ID || "");
 }
 
 function main() {

package/bin/pipeline/get-exec-id.mjs

@@ -53,8 +53,8 @@ export function loadExecId(workspaceRoot, flowName, uuid, instanceId) {
 /**
  * 从 memory 读取所有 order 中节点的 execId。
  */
-export function loadAllExecIds(workspaceRoot, flowName, uuid, order) {
-  const runDir = getRunDir(workspaceRoot, flowName, uuid);
+export function loadAllExecIds(workspaceRoot, flowName, uuid, order, opts = {}) {
+  const runDir = getRunDir(workspaceRoot, flowName, uuid, opts);
   const memoryPath = path.join(runDir, MEMORY_FILENAME);
   const map = fs.existsSync(memoryPath)
     ? parseMemory(fs.readFileSync(memoryPath, "utf-8"))

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

@@ -233,6 +233,7 @@ export function getResolvedValues(workspaceRoot, flowName, uuid, instanceId) {
     // 运行时常量放在后面，确保不会被 input 槽位的空值覆盖
     const runtimeConstants = {
       workspaceRoot: path.resolve(workspaceRoot),
+      pipelineWorkspace: path.resolve(workspaceRoot),
       flowName,
       runDir: runDirRel,
       flowDir: path.resolve(flowDir),