@fieldwangai/agentflow 0.1.162 → 0.1.164

package/bin/lib/flow-dsl/codegen.mjs

@@ -84,7 +84,7 @@ export function generateFlowSource(ir, opts = {}) {
     taken.add(name);
     return name;
   };
-  const flowApiRoots = ["agent", "control", "display", "file", "flow", "provide", "tool", "workspace"];
+  const flowApiRoots = ["agent", "context", "control", "display", "file", "flow", "provide", "tool", "workspace"];
   const flowApiBinding = new Map(flowApiRoots.map((root) => [root, uniqueName(root, `${root}Api`)]));
   const apiCall = (name) => {
     const [root, ...tail] = String(name || "").split(".");
@@ -210,6 +210,13 @@ export function generateFlowSource(ir, opts = {}) {
   const pinValue = (id, name, value) => {
     const text = String(value);
     if (slotTypeOf(id, name) === "bool" && (text === "true" || text === "false")) return text;
+    if (slotTypeOf(id, name) === "json") {
+      try {
+        return JSON.stringify(JSON.parse(text), null, 2);
+      } catch {
+        // Keep invalid draft values round-trippable; lint/runtime will report the bad JSON.
+      }
+    }
     return textArg(id, name, text);
   };
 
@@ -228,7 +235,21 @@ export function generateFlowSource(ir, opts = {}) {
       const key = isIdentifier(name) ? name : JSON.stringify(name);
       if (wired.has(name)) {
         const x = wired.get(name);
-        lines.push(`${key}: ${outVar.get(`${x.from}|${x.fromSlot}`) || `${x.from}.${x.fromSlot}`}`);
+        const sourceDefinitionId = N[x.from]?.definitionId;
+        const bundleAlias = node.definitionId === "context_bundle"
+          ? ({ knowledgeContext: "knowledge", skillsContext: "skills", workspaceContext: "workspace", mcpContext: "mcp" }[name] || "")
+          : "";
+        const contextResourceOutput = {
+          context_knowledge: "knowledgeContext",
+          context_skills: "skillsContext",
+          context_workspace: "workspaceContext",
+        }[sourceDefinitionId] || "";
+        const directContextBundle = name === "context" && sourceDefinitionId === "context_bundle" && x.fromSlot === "context";
+        const renderedKey = bundleAlias || key;
+        const renderedValue = directContextBundle || (bundleAlias && contextResourceOutput === name && x.fromSlot === name)
+          ? x.from
+          : (outVar.get(`${x.from}|${x.fromSlot}`) || `${x.from}.${x.fromSlot}`);
+        lines.push(`${renderedKey}: ${renderedValue}`);
         continue;
       }
       if (node.inputs[name] !== undefined) {

package/bin/lib/flow-dsl/lint.mjs

@@ -60,6 +60,16 @@ function declaredSlotType(node, kind, name) {
   return "";
 }
 
+function parseJsonInput(node, name) {
+  const raw = String(node?.inputs?.[name] || "").trim();
+  if (!raw) return { value: null, error: "为空" };
+  try {
+    return { value: JSON.parse(raw), error: "" };
+  } catch (error) {
+    return { value: null, error: error.message };
+  }
+}
+
 function walk(node, visit) {
   if (!node || typeof node !== "object") return;
   if (node.type) visit(node);
@@ -179,6 +189,29 @@ export function lintFlowDir(flowDir, opts = {}) {
     if (definitionId === "control_subflow_call" && !subflows[node.attrs?.subflowId]) {
       errors.push(`${id}: 引用的子流程 ${node.attrs?.subflowId || "(empty)"} 不存在`);
     }
+    if (definitionId === "context_knowledge") {
+      const parsed = parseJsonInput(node, "workspaceIds");
+      if (parsed.error) errors.push(`${id}: context.knowledge workspaceIds 必须是 JSON 数组（${parsed.error}）`);
+      else if (!Array.isArray(parsed.value) || parsed.value.length === 0) errors.push(`${id}: context.knowledge 至少选择一个 Workspace ID`);
+      else if (parsed.value.some((value) => typeof value !== "string" || !String(value).trim())) errors.push(`${id}: context.knowledge workspaceIds 只能包含非空字符串 ID`);
+    }
+    if (definitionId === "context_skills") {
+      const parsed = parseJsonInput(node, "skills");
+      if (parsed.error) errors.push(`${id}: context.skills skills 必须是 JSON 数组（${parsed.error}）`);
+      else if (!Array.isArray(parsed.value) || parsed.value.length === 0) errors.push(`${id}: context.skills 至少声明一个 skill`);
+    }
+    if (definitionId === "context_workspace") {
+      const workspaceId = String(node.inputs?.workspaceId || "current").trim();
+      const access = String(node.inputs?.access || "read-write").trim().toLowerCase();
+      if (!workspaceId) errors.push(`${id}: context.workspace workspaceId 不能为空`);
+      if (!["read-only", "read-write"].includes(access)) errors.push(`${id}: context.workspace access 只能是 read-only 或 read-write`);
+    }
+    if (definitionId === "context_bundle") {
+      const incoming = ir.edges.filter((edge) => edge.split("|")[2] === id && edge.split("|")[3] !== "prev");
+      if (!incoming.length) errors.push(`${id}: context.bundle 至少连接一个 Context 资源`);
+      const literal = Object.entries(node.inputs || {}).filter(([, value]) => String(value || "").trim());
+      if (literal.length) errors.push(`${id}: context.bundle 只能连接资源节点，不能内嵌 Context 正文`);
+    }
     if (definitionId === "control_while") {
       const conditionId = String(node.attrs?.conditionSubflowId || "");
       const bodyId = String(node.attrs?.bodySubflowId || "");
@@ -206,9 +239,11 @@ export function lintFlowDir(flowDir, opts = {}) {
         }
         if (body && !body.outputs?.state) errors.push(`${id}: Body 子流程 ${bodyId} 缺少输出 state`);
         for (const [contract, name, expected] of [
+          [condition?.inputs, "context", "context"],
           [condition?.inputs, "state", "json"],
           [condition?.inputs, "iteration", "text"],
           [condition?.outputs, "decision", "text"],
+          [body?.inputs, "context", "context"],
           [body?.inputs, "state", "json"],
           [body?.inputs, "iteration", "text"],
           [body?.inputs, "idempotencyKey", "text"],
@@ -241,6 +276,15 @@ export function lintFlowDir(flowDir, opts = {}) {
       for (const slot of node.extraIn) if (!defIn.has(slot)) errors.push(`${id}[${definitionId}]: 不存在的输入槽 "${slot}"`);
       for (const slot of node.extraOut) if (!defOut.has(slot)) errors.push(`${id}[${definitionId}]: 不存在的输出槽 "${slot}"`);
     }
+    if (definitionId === "agent_subAgent") {
+      const incomingNames = new Set(ir.edges
+        .map((edge) => edge.split("|"))
+        .filter((parts) => parts[2] === id)
+        .map((parts) => parts[3]));
+      if (incomingNames.has("context") && ["knowledgeContext", "skillsContext", "workspaceContext", "mcpContext"].some((name) => incomingNames.has(name))) {
+        warnings.push(`${id}: 已连接 context Bundle，不要再重复连接旧 Context 文本引脚`);
+      }
+    }
   }
 
   const inputSeen = new Map();

package/bin/lib/flow-dsl/parser.mjs

@@ -101,6 +101,39 @@ export function parseFlowSource(source, opts = {}) {
     return null;
   }
 
+  /** Read a JSON-compatible literal without evaluating user code. */
+  function staticJsonOf(node) {
+    if (!node) return { ok: false, value: null };
+    if (node.type === "Literal") return { ok: true, value: node.value };
+    if (node.type === "UnaryExpression" && (node.operator === "-" || node.operator === "+")
+      && node.argument.type === "Literal" && typeof node.argument.value === "number") {
+      return { ok: true, value: node.operator === "-" ? -node.argument.value : node.argument.value };
+    }
+    if (node.type === "TemplateLiteral" && node.expressions.length === 0) {
+      return { ok: true, value: node.quasis[0].value.cooked };
+    }
+    if (node.type === "ArrayExpression") {
+      const value = [];
+      for (const item of node.elements) {
+        const parsed = staticJsonOf(item);
+        if (!parsed.ok) return { ok: false, value: null };
+        value.push(parsed.value);
+      }
+      return { ok: true, value };
+    }
+    if (node.type === "ObjectExpression") {
+      const value = {};
+      for (const prop of node.properties) {
+        if (prop.type !== "Property" || prop.computed || prop.kind !== "init") return { ok: false, value: null };
+        const parsed = staticJsonOf(prop.value);
+        if (!parsed.ok) return { ok: false, value: null };
+        value[String(prop.key.name ?? prop.key.value ?? "")] = parsed.value;
+      }
+      return { ok: true, value };
+    }
+    return { ok: false, value: null };
+  }
+
   // import 绑定 -> 代码节点包
   const packageOf = new Map();
   for (const stmt of ast.body) {
@@ -196,6 +229,8 @@ export function parseFlowSource(source, opts = {}) {
     const def = definitionOf(definitionId);
     const defInputs = new Set(def.input.map((s) => s.name));
     const defOutputs = new Set(def.output.map((s) => s.name));
+    const inputType = new Map(def.input.map((s) => [s.name, String(s.type || "text")]));
+    const outputType = new Map(def.output.map((s) => [s.name, String(s.type || "text")]));
     const node = nodes[id];
     if (!obj || obj.type !== "ObjectExpression") return;
     for (const prop of obj.properties) {
@@ -207,9 +242,32 @@ export function parseFlowSource(source, opts = {}) {
         unresolvedAt(prop, `${id}: 引脚名不能是动态表达式`);
         continue;
       }
-      const key = prop.key.name ?? prop.key.value;
+      const rawKey = prop.key.name ?? prop.key.value;
+      const key = definitionId === "context_bundle"
+        ? ({ knowledge: "knowledgeContext", skills: "skillsContext", workspace: "workspaceContext", mcp: "mcpContext" }[rawKey] || rawKey)
+        : rawKey;
       const isCustom = !STD_SLOTS.has(key) && !defInputs.has(key);
 
+      // Context resources are values, not control nodes. A bundle accepts the resource variable
+      // directly (`{ knowledge }`), and consumers accept the bundle directly (`{ context: ctx }`).
+      if (prop.value.type === "Identifier" && nodes[prop.value.name]) {
+        const sourceDefinitionId = nodes[prop.value.name].definitionId;
+        const contextOutput = {
+          context_knowledge: "knowledgeContext",
+          context_skills: "skillsContext",
+          context_workspace: "workspaceContext",
+          context_bundle: "context",
+        }[sourceDefinitionId];
+        if (contextOutput && (
+          (definitionId === "context_bundle" && key === contextOutput)
+          || (key === "context" && sourceDefinitionId === "context_bundle")
+        )) {
+          edges.push(`${prop.value.name}|${contextOutput}|${id}|${key}`);
+          if (isCustom) node.extraIn.push(key);
+          continue;
+        }
+      }
+
       const member = memberPath(prop.value);
       if (member) {
         edges.push(`${member[0]}|${member[1]}|${id}|${key}`);
@@ -228,6 +286,15 @@ export function parseFlowSource(source, opts = {}) {
         continue;
       }
       const text = stringOf(prop.value);
+      if (text === null && (inputType.get(key) === "json" || outputType.get(key) === "json")) {
+        const parsed = staticJsonOf(prop.value);
+        if (parsed.ok) {
+          if (defOutputs.has(key) && !defInputs.has(key)) node.outputs[key] = JSON.stringify(parsed.value);
+          else node.inputs[key] = JSON.stringify(parsed.value);
+          if (isCustom) node.extraIn.push(key);
+          continue;
+        }
+      }
       if (text === null) {
         unresolvedAt(prop, `${id}.${key}: 引脚值既不是上游引用也不是字面量`);
         continue;

package/bin/lib/marketplace-usage.mjs

@@ -0,0 +1,218 @@
+import fs from "fs";
+import path from "path";
+
+import { MARKETPLACE_PACKAGES_DIR } from "./paths.mjs";
+
+const USAGE_DIRNAME = "usage";
+const FLOW_ORIGIN_FILENAME = ".agentflow-marketplace-origin.json";
+
+function usageRoot(workspaceRoot) {
+  return path.join(path.resolve(workspaceRoot), path.dirname(MARKETPLACE_PACKAGES_DIR), USAGE_DIRNAME);
+}
+
+function dayKey(timeMs) {
+  const date = new Date(Number(timeMs) || Date.now());
+  return [
+    date.getFullYear(),
+    String(date.getMonth() + 1).padStart(2, "0"),
+    String(date.getDate()).padStart(2, "0"),
+  ].join("-");
+}
+
+function safeText(value, max = 240) {
+  return String(value || "").trim().slice(0, max);
+}
+
+export function normalizeMarketplaceVisibility(value, fallback = "public") {
+  const normalized = safeText(value, 20).toLowerCase();
+  if (normalized === "private") return "private";
+  if (normalized === "public") return "public";
+  return fallback === "private" ? "private" : "public";
+}
+
+export function marketplaceResourceKey(kind, id, version) {
+  return `${safeText(kind, 32)}:${safeText(id)}@${safeText(version, 80)}`;
+}
+
+export function appendMarketplaceUsageEvent(workspaceRoot, event = {}) {
+  try {
+    const kind = safeText(event.kind, 32);
+    const id = safeText(event.id);
+    const version = safeText(event.version, 80);
+    const action = safeText(event.action, 32);
+    const actorUserId = safeText(event.actorUserId || event.userId, 160);
+    const at = Number(event.at || Date.now());
+    const eventId = safeText(
+      event.eventId || `${action}:${kind}:${id}@${version}:${actorUserId}:${at}`,
+      500,
+    );
+    if (!kind || !id || !version || !["install", "use"].includes(action) || !eventId) return false;
+    const record = {
+      version: 1,
+      eventId,
+      kind,
+      id,
+      resourceVersion: version,
+      action,
+      actorUserId,
+      runId: safeText(event.runId, 240),
+      at: Number.isFinite(at) && at > 0 ? at : Date.now(),
+    };
+    const filePath = path.join(usageRoot(workspaceRoot), `${dayKey(record.at)}.jsonl`);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.appendFileSync(filePath, `${JSON.stringify(record)}\n`, "utf-8");
+    return true;
+  } catch {
+    // Marketplace telemetry must never break publishing, installing, or running.
+    return false;
+  }
+}
+
+function readUsageEvents(workspaceRoot) {
+  const dir = usageRoot(workspaceRoot);
+  if (!fs.existsSync(dir)) return [];
+  const events = [];
+  try {
+    const files = fs.readdirSync(dir, { withFileTypes: true })
+      .filter((entry) => entry.isFile() && /^\d{4}-\d{2}-\d{2}\.jsonl$/.test(entry.name))
+      .map((entry) => path.join(dir, entry.name))
+      .sort();
+    for (const filePath of files) {
+      for (const line of fs.readFileSync(filePath, "utf-8").split(/\r?\n/)) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) events.push(parsed);
+        } catch {
+          // Ignore individual malformed telemetry records.
+        }
+      }
+    }
+  } catch {
+    return [];
+  }
+  return events;
+}
+
+export function marketplaceUsageStats(workspaceRoot) {
+  const byResource = new Map();
+  const seenEvents = new Set();
+  for (const event of readUsageEvents(workspaceRoot)) {
+    const eventId = safeText(event.eventId, 500);
+    if (!eventId || seenEvents.has(eventId)) continue;
+    seenEvents.add(eventId);
+    const key = marketplaceResourceKey(event.kind, event.id, event.resourceVersion);
+    if (!byResource.has(key)) {
+      byResource.set(key, {
+        useCount: 0,
+        installCount: 0,
+        uniqueUserCount: 0,
+        lastUsedAt: "",
+        _users: new Set(),
+        _actors: new Map(),
+      });
+    }
+    const stats = byResource.get(key);
+    const actorUserId = safeText(event.actorUserId, 160);
+    if (actorUserId) stats._users.add(actorUserId);
+    if (actorUserId && !stats._actors.has(actorUserId)) stats._actors.set(actorUserId, { useCount: 0, installCount: 0 });
+    if (event.action === "use") {
+      stats.useCount += 1;
+      if (actorUserId) stats._actors.get(actorUserId).useCount += 1;
+      const atIso = new Date(Number(event.at) || 0).toISOString();
+      if (!stats.lastUsedAt || atIso > stats.lastUsedAt) stats.lastUsedAt = atIso;
+    } else if (event.action === "install") {
+      stats.installCount += 1;
+      if (actorUserId) stats._actors.get(actorUserId).installCount += 1;
+    }
+  }
+  for (const stats of byResource.values()) {
+    stats.uniqueUserCount = stats._users.size;
+  }
+  return byResource;
+}
+
+export function marketplaceStatsFor(statsByResource, kind, id, version, ownerUserId = "") {
+  const stats = statsByResource.get(marketplaceResourceKey(kind, id, version));
+  if (!stats) return {
+    useCount: 0,
+    installCount: 0,
+    uniqueUserCount: 0,
+    lastUsedAt: "",
+  };
+  const owner = safeText(ownerUserId, 160);
+  const ownerStats = owner ? stats._actors.get(owner) : null;
+  return {
+    useCount: Math.max(0, stats.useCount - Number(ownerStats?.useCount || 0)),
+    installCount: Math.max(0, stats.installCount - Number(ownerStats?.installCount || 0)),
+    uniqueUserCount: Math.max(0, stats.uniqueUserCount - (owner && stats._users.has(owner) ? 1 : 0)),
+    lastUsedAt: stats.lastUsedAt,
+  };
+}
+
+export function marketplaceFlowOriginPath(flowDir) {
+  return path.join(path.resolve(flowDir), FLOW_ORIGIN_FILENAME);
+}
+
+export function writeMarketplaceFlowOrigin(flowDir, origin = {}) {
+  const value = {
+    kind: "flow",
+    id: safeText(origin.id),
+    version: safeText(origin.version, 80),
+    installedAt: safeText(origin.installedAt || new Date().toISOString(), 80),
+  };
+  if (!value.id || !value.version) throw new Error("Invalid marketplace flow origin");
+  fs.writeFileSync(marketplaceFlowOriginPath(flowDir), `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+  return value;
+}
+
+export function readMarketplaceFlowOrigin(flowDir) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(marketplaceFlowOriginPath(flowDir), "utf-8"));
+    if (parsed?.kind !== "flow" || !parsed.id || !parsed.version) return null;
+    return { kind: "flow", id: String(parsed.id), version: String(parsed.version) };
+  } catch {
+    return null;
+  }
+}
+
+function parseMarketplaceNodeRef(instance = {}) {
+  const ref = safeText(instance.marketplaceRef || instance.definitionId, 500);
+  if (!ref.startsWith("marketplace:")) return null;
+  const spec = ref.slice("marketplace:".length);
+  const at = spec.lastIndexOf("@");
+  if (at <= 0 || at === spec.length - 1) return null;
+  return { kind: "node", id: spec.slice(0, at), version: spec.slice(at + 1) };
+}
+
+export function marketplaceResourcesForRun(flowDir, graph, executedNodeIds = []) {
+  const resources = new Map();
+  const flowOrigin = readMarketplaceFlowOrigin(flowDir);
+  if (flowOrigin) resources.set(marketplaceResourceKey(flowOrigin.kind, flowOrigin.id, flowOrigin.version), flowOrigin);
+  const ids = Array.isArray(executedNodeIds) && executedNodeIds.length
+    ? executedNodeIds.map((id) => String(id))
+    : Object.keys(graph?.instances || {});
+  for (const nodeId of ids) {
+    const ref = parseMarketplaceNodeRef(graph?.instances?.[nodeId]);
+    if (ref) resources.set(marketplaceResourceKey(ref.kind, ref.id, ref.version), ref);
+  }
+  return [...resources.values()];
+}
+
+export function recordMarketplaceRunUsage(workspaceRoot, resources = [], run = {}) {
+  if (String(run.status || "") !== "success") return;
+  if (!String(workspaceRoot || "").trim() || !Array.isArray(resources) || resources.length === 0) return;
+  const runId = safeText(run.runId, 240);
+  const actorUserId = safeText(run.userId || run.actorUserId, 160);
+  if (!runId) return;
+  for (const resource of resources) {
+    appendMarketplaceUsageEvent(workspaceRoot, {
+      ...resource,
+      action: "use",
+      actorUserId,
+      runId,
+      at: run.endedAt || Date.now(),
+      eventId: `use:${resource.kind}:${resource.id}@${resource.version}:${runId}`,
+    });
+  }
+}