@fieldwangai/agentflow 0.1.147 → 0.1.153

package/README.md

@@ -24,6 +24,13 @@
 
 ![Running Status](docs/running.png)
 
+### Terminology
+
+In this repository, an executable node graph is called a **Flow** (also
+shown as a Pipeline in the editor) and is stored in `flow.yaml`. A product
+requirement **Workflow** is a separate TAPD-backed record addressed as
+`tapd:<id>`; it is not created, archived, or updated by the Flow editor.
+
 ## The Problem
 
 Coding agents like Cursor, Claude Code, and Codex are great — until the task gets long.
@@ -61,6 +68,11 @@ agentflow ui
 # Generate and open a single-file static preview using the platform canvas (no local server)
 agentflow flow preview ./my-flow/flow.yaml
 
+# Upload a Workspace graph to a server-side temporary preview project
+node skills/agentflow-cli/scripts/agentflow-cli.mjs workspace-preview \
+  --file .workspace/agentflow/pipelines/my-flow/workspace.graph.json \
+  --ttl-seconds 7200
+
 # Or run a flow directly
 agentflow apply <FlowName>
 ```

package/README.zh-CN.md

@@ -24,6 +24,12 @@
 
 ![Running Status](docs/running.png)
 
+### 术语边界
+
+本仓库中的可执行节点图称为 **Flow**（编辑器中也显示为流水线），以
+`flow.yaml` 保存。产品需求 **Workflow** 是另一套由 TAPD 驱动、使用
+`tapd:<id>` 标识的需求实体；它不由 Flow 编辑器创建、归档或修改。
+
 ## 解决什么问题
 
 Cursor、Claude Code、Codex 这些 Coding Agent 很好用——直到任务变长。

package/bin/lib/catalog-flows.mjs

@@ -21,6 +21,8 @@ import {
 } from "./admin-builtin-pipelines.mjs";
 import { Table } from "./table.mjs";
 import { listMarketplaceNodes, parseMarketplaceDefinitionId, resolveMarketplaceNodePackage } from "./marketplace.mjs";
+import { isWorkspacePreviewDir } from "./workspace-preview.mjs";
+import { LEGACY_FLOW_NODE_IDS } from "./legacy-flow-execution.mjs";
 
 /** 从指定目录收集含 flow.yaml 的子目录名。 */
 export function collectPipelineNamesFromDir(dirPath) {
@@ -29,6 +31,7 @@ export function collectPipelineNamesFromDir(dirPath) {
   return entries
     .filter((e) => e.isDirectory())
     .filter((e) => fs.existsSync(path.join(dirPath, e.name, "flow.yaml")))
+    .filter((e) => !isWorkspacePreviewDir(path.join(dirPath, e.name)))
     .map((e) => e.name);
 }
 
@@ -259,6 +262,7 @@ export function listNodesJson(workspaceRoot, flowId, flowSource, opts = {}) {
     const files = fs.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".md"));
     for (const e of files) {
       const id = e.name.replace(/\.mdx?$/i, "").replace(/\.markdown$/i, "");
+      if (LEGACY_FLOW_NODE_IDS.has(id)) continue;
       let type = "agent";
       if (/^control/i.test(id)) type = "control";
       else if (/^provide/i.test(id)) type = "provide";

package/bin/lib/flow-write.mjs

@@ -247,6 +247,44 @@ export function archiveFlowPipeline(workspaceRoot, flowId, flowSource, opts = {}
   return { success: true };
 }
 
+/**
+ * 将归档流水线目录恢复到活动目录（仅 user / workspace）。
+ * @param {string} workspaceRoot
+ * @param {string} flowId
+ * @param {FlowWriteSource} flowSource
+ * @returns {{ success: true } | { success: false, error: string }}
+ */
+export function restoreArchivedFlowPipeline(workspaceRoot, flowId, flowSource, opts = {}) {
+  if (flowSource !== "user" && flowSource !== "workspace") {
+    return { success: false, error: "仅支持恢复用户目录或工作区流水线" };
+  }
+  if (!flowId || typeof flowId !== "string" || /[/\\.]/.test(flowId) || flowId === "..") {
+    return { success: false, error: "invalid flowId" };
+  }
+  const archivedRes = resolveArchivedFlowDirForWrite(workspaceRoot, flowId, flowSource, opts);
+  if (archivedRes.error || !archivedRes.flowDir) {
+    return { success: false, error: archivedRes.error || "无法解析归档路径" };
+  }
+  const fromDir = archivedRes.flowDir;
+  if (!fs.existsSync(path.join(fromDir, FLOW_YAML_FILENAME))) {
+    return { success: false, error: "找不到归档流水线" };
+  }
+  const activeRes = resolveFlowDirForWrite(workspaceRoot, flowId, flowSource, opts);
+  if (activeRes.error || !activeRes.flowDir) {
+    return { success: false, error: activeRes.error || "无法解析活动路径" };
+  }
+  if (fs.existsSync(activeRes.flowDir)) {
+    return { success: false, error: "活动目录已存在同名流水线" };
+  }
+  try {
+    fs.mkdirSync(path.dirname(activeRes.flowDir), { recursive: true });
+    fs.renameSync(fromDir, activeRes.flowDir);
+    return { success: true };
+  } catch (e) {
+    return { success: false, error: (e && e.message) || String(e) };
+  }
+}
+
 /**
  * 在用户目录与工作区之间移动整个流水线目录（含 nodes 等）。
  * @param {string} workspaceRoot

package/bin/lib/help.mjs

@@ -26,7 +26,7 @@ AgentFlow CLI — 使用 Cursor / OpenCode / Claude Code / Codex CLI 流式输
   agentflow marketplace list [--json]         查看 workspace 本地节点市场
   agentflow marketplace publish-node <dir>    发布本地节点包到 workspace market
   agentflow marketplace install-node <FlowName> <nodeSpec>  将 market 节点依赖写入 flow
-  agentflow apply <FlowName> [uuid]            或 agentflow apply <uuid>（由 uuid 反查 pipeline）
+  agentflow apply <FlowName> [uuid]            已下线；请改用 Workspace Run
   agentflow validate <FlowName> [uuid]        校验流程；终端下输出易读结果，--json 或管道时输出 JSON；传 uuid 时写入 runDir/intermediate/validation.json
   agentflow resume <FlowName> <uuid> [instanceId]  将 pending 与 failed 节点标为已确认并继续 apply
   agentflow replay [flowName] <uuid> <instanceId>
@@ -97,7 +97,7 @@ Usage:
   agentflow marketplace list [--json]         Show workspace local marketplace packages
   agentflow marketplace publish-node <dir>    Publish a local node package to the workspace market
   agentflow marketplace install-node <FlowName> <nodeSpec>  Add a marketplace node dependency to a flow
-  agentflow apply <FlowName> [uuid]            Or agentflow apply <uuid> (resolve pipeline from uuid)
+  agentflow apply <FlowName> [uuid]            Retired; use Workspace Run instead
   agentflow validate <FlowName> [uuid]        Validate flow; readable output in terminal, JSON with --json or pipe; writes to runDir/intermediate/validation.json when uuid provided
   agentflow resume <FlowName> <uuid> [instanceId]  Mark pending and failed nodes as acknowledged and continue apply
   agentflow replay [flowName] <uuid> <instanceId>

package/bin/lib/legacy-flow-execution.mjs

@@ -0,0 +1,6 @@
+export const LEGACY_FLOW_EXECUTION_DISABLED = true;
+
+export const LEGACY_FLOW_EXECUTION_MESSAGE =
+  "Legacy Start/End Pipeline execution has been retired. Use the Workspace graph with Run or Scheduled Run.";
+
+export const LEGACY_FLOW_NODE_IDS = new Set(["control_start", "control_end"]);

package/bin/lib/main.mjs

@@ -36,6 +36,7 @@ import { cancelScheduledRun, listScheduleStatuses, startScheduler } from "./sche
 import { installFlowDependency, listMarketplacePackages, publishNodePackage } from "./marketplace.mjs";
 import { startMcpServer } from "./mcp-server.mjs";
 import { writeStaticFlowPreview } from "./flow-static-preview.mjs";
+import { LEGACY_FLOW_EXECUTION_DISABLED, LEGACY_FLOW_EXECUTION_MESSAGE } from "./legacy-flow-execution.mjs";
 
 async function readStdin() {
   const chunks = [];
@@ -553,6 +554,7 @@ export async function main() {
   if (sub === "list") {
     listPipelines(workspaceRoot);
   } else if (sub === "apply") {
+    if (LEGACY_FLOW_EXECUTION_DISABLED) throw new Error(LEGACY_FLOW_EXECUTION_MESSAGE);
     const aiMode = argv[0] === "-ai" || argv[0] === "--ai";
     if (aiMode) {
       argv.shift();
@@ -584,12 +586,14 @@ export async function main() {
     }
     await apply(workspaceRoot, flowName, uuidArg, dryRun, agentModel, force, parallel, cliInputs);
   } else if (sub === "resume") {
+    if (LEGACY_FLOW_EXECUTION_DISABLED) throw new Error(LEGACY_FLOW_EXECUTION_MESSAGE);
     const flowName = shift();
     const uuidArg = shift();
     if (!flowName || !uuidArg) throw new Error("Usage: agentflow resume <FlowName> <uuid> [instanceId]");
     const instanceIdOpt = argv.length > 0 && !argv[0].startsWith("--") ? shift() : undefined;
     await resume(workspaceRoot, flowName, uuidArg, instanceIdOpt, agentModel, force, parallel);
   } else if (sub === "replay") {
+    if (LEGACY_FLOW_EXECUTION_DISABLED) throw new Error(LEGACY_FLOW_EXECUTION_MESSAGE);
     const a = shift(),
       b = shift(),
       c = shift();

package/bin/lib/ui-server.mjs

@@ -30,6 +30,7 @@ import {
   deleteFlowPipeline,
   moveFlowDirectory,
   resolveFlowDirForWrite,
+  restoreArchivedFlowPipeline,
   validateUserPipelineId,
   writeFlowYaml,
 } from "./flow-write.mjs";
@@ -73,6 +74,16 @@ import {
   writePipelineTree,
 } from "./flow-import.mjs";
 import { getWorkspaceTree, getPipelineFiles } from "./workspace-tree.mjs";
+import {
+  DEFAULT_WORKSPACE_PREVIEW_TTL_MS,
+  createWorkspacePreviewId,
+  listExpiredWorkspacePreviews,
+  normalizeWorkspacePreviewTtlMs,
+  readWorkspacePreviewMetadata,
+  workspacePreviewFlowDir,
+  writeWorkspacePreviewMetadata,
+} from "./workspace-preview.mjs";
+import { LEGACY_FLOW_EXECUTION_DISABLED, LEGACY_FLOW_EXECUTION_MESSAGE } from "./legacy-flow-execution.mjs";
 import {
   createComposerSession,
   logComposerEvent,
@@ -8236,6 +8247,23 @@ function isValidFlowSourceWrite(s) {
   return s === "user" || s === "workspace";
 }
 
+function cleanupExpiredWorkspacePreviews() {
+  const roots = new Set(listAgentflowUserIds().map((id) => getUserPipelinesRoot(id)));
+  roots.add(getUserPipelinesRoot(""));
+  let removed = 0;
+  for (const pipelinesRoot of roots) {
+    for (const item of listExpiredWorkspacePreviews(pipelinesRoot)) {
+      try {
+        fs.rmSync(item.flowDir, { recursive: true, force: true });
+        removed += 1;
+      } catch (e) {
+        log.debug(`[workspace-preview] cleanup failed: ${(e && e.message) || String(e)}`);
+      }
+    }
+  }
+  return removed;
+}
+
 /** Composer 打开的画布通过 SSE 订阅；POST /api/flow-editor-sync 向对应 flow 推送刷新 */
 const flowEditorSyncSubscribers = new Map();
 /** 每次 broadcastFlowEditorSync 时递增，供轮询端点 /api/flow-editor-sync-poll 使用 */
@@ -13577,6 +13605,16 @@ export function startUiServer({
       isAdmin: Boolean(authUser.isAdmin),
       adminOwnerId: String(url.searchParams.get("adminOwnerId") || "").trim(),
     } : {};
+    const legacyFlowManagementPath = new Set([
+      "/api/flow/run-config",
+      "/api/flow/schedule",
+      "/api/flow/schedules",
+      "/api/flow/schedule/disable",
+    ]);
+    if (LEGACY_FLOW_EXECUTION_DISABLED && legacyFlowManagementPath.has(url.pathname)) {
+      json(res, 410, { error: LEGACY_FLOW_EXECUTION_MESSAGE, code: "legacy_flow_execution_disabled" });
+      return;
+    }
     if (req.method === "GET" && url.pathname.startsWith("/w/")) {
       const parts = url.pathname.split("/").filter(Boolean);
       if (parts.length !== 2) {
@@ -17367,6 +17405,77 @@ export function startUiServer({
       return;
     }
 
+    if (req.method === "POST" && url.pathname === "/api/workspace/preview") {
+      if (!authUser?.userId) {
+        json(res, 401, { error: "Authentication required" });
+        return;
+      }
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req, 4 * 1024 * 1024));
+      } catch {
+        json(res, 400, { error: "Invalid JSON" });
+        return;
+      }
+      const graph = payload?.graph;
+      if (!graph || typeof graph !== "object" || Array.isArray(graph)) {
+        json(res, 400, { error: "graph must be an object" });
+        return;
+      }
+      const instances = graph.instances && typeof graph.instances === "object" && !Array.isArray(graph.instances)
+        ? graph.instances
+        : {};
+      if (Object.values(instances).some((item) => String(item?.definitionId || "") === "workspace_scheduled_run")) {
+        json(res, 400, { error: "Temporary Workspace preview cannot contain scheduled-run nodes" });
+        return;
+      }
+      const rawRequestedId = String(payload.previewId || "").trim();
+      const flowId = rawRequestedId || createWorkspacePreviewId();
+      const flowDir = workspacePreviewFlowDir(flowId, authUser.userId);
+      if (!flowDir) {
+        json(res, 400, { error: "Invalid previewId" });
+        return;
+      }
+      const existing = readWorkspacePreviewMetadata(flowDir);
+      if (existing && existing.ownerId !== authUser.userId) {
+        json(res, 403, { error: "Preview ownership denied" });
+        return;
+      }
+      if (rawRequestedId && !existing && fs.existsSync(flowDir)) {
+        json(res, 409, { error: "Preview project already exists but is not a preview" });
+        return;
+      }
+      const now = Date.now();
+      const ttlInput = payload.ttlMs != null
+        ? Number(payload.ttlMs)
+        : payload.ttlSeconds != null
+          ? Number(payload.ttlSeconds) * 1000
+          : DEFAULT_WORKSPACE_PREVIEW_TTL_MS;
+      const ttlMs = normalizeWorkspacePreviewTtlMs(ttlInput);
+      const metadata = {
+        version: 1,
+        flowId,
+        ownerId: authUser.userId,
+        title: String(payload.title || "Workspace Preview").trim().slice(0, 200),
+        createdAt: existing?.createdAt || new Date(now).toISOString(),
+        updatedAt: new Date(now).toISOString(),
+        expiresAt: new Date(now + ttlMs).toISOString(),
+      };
+      try {
+        fs.mkdirSync(flowDir, { recursive: true });
+        fs.writeFileSync(path.join(flowDir, "flow.yaml"), "instances: {}\nedges: []\n", "utf8");
+        fs.writeFileSync(path.join(flowDir, "workspace.graph.json"), `${JSON.stringify(graph, null, 2)}\n`, "utf8");
+        writeWorkspacePreviewMetadata(flowDir, metadata);
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+        return;
+      }
+      const baseUrl = `${url.protocol}//${url.host}`;
+      const workspaceUrl = `${baseUrl}/workspace?flowId=${encodeURIComponent(flowId)}&flowSource=user`;
+      json(res, 200, { ok: true, flowId, flowSource: "user", preview: true, expiresAt: metadata.expiresAt, url: workspaceUrl });
+      return;
+    }
+
     if (req.method === "GET" && url.pathname === "/api/workspace/graph") {
       try {
         const scoped = resolveWorkspaceScopeRoot(root, {
@@ -20121,6 +20230,46 @@ finishedAt: "${new Date().toISOString()}"
       return;
     }
 
+    if (req.method === "POST" && url.pathname === "/api/flow/restore") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      const flowId = typeof payload.flowId === "string" ? payload.flowId.trim() : "";
+      const flowSource = payload.flowSource || "user";
+      if (!flowId) {
+        json(res, 400, { error: "Missing or invalid flowId" });
+        return;
+      }
+      if (flowSource !== "user" && flowSource !== "workspace") {
+        json(res, 400, { error: "仅支持恢复用户目录或工作区流水线" });
+        return;
+      }
+      const collaborationDenied = workspaceFlowCollaborationGuard(flowId, flowSource, true, userCtx, "owner");
+      if (collaborationDenied) {
+        json(res, collaborationDenied.status, { error: collaborationDenied.error });
+        return;
+      }
+      const result = restoreArchivedFlowPipeline(root, flowId, flowSource, userCtx);
+      if (!result.success) {
+        json(res, 400, { error: result.error || "恢复失败" });
+        return;
+      }
+      updateWorkspaceCollaborationFlow({
+        previousFlowId: flowId,
+        previousArchived: true,
+        flowSource,
+        ownerId: userCtx.userId,
+        flowId,
+        archived: false,
+      });
+      json(res, 200, { success: true, flowId, flowSource, archived: false });
+      return;
+    }
+
     if (req.method === "POST" && url.pathname === "/api/flow/delete") {
       let payload;
       try {
@@ -20442,6 +20591,10 @@ finishedAt: "${new Date().toISOString()}"
     }
 
     if (req.method === "POST" && url.pathname === "/api/flow/run") {
+      if (LEGACY_FLOW_EXECUTION_DISABLED) {
+        json(res, 410, { error: LEGACY_FLOW_EXECUTION_MESSAGE, code: "legacy_flow_execution_disabled" });
+        return;
+      }
       let payload;
       try {
         payload = JSON.parse(await readBody(req));
@@ -21170,6 +21323,22 @@ finishedAt: "${new Date().toISOString()}"
     }, 1000).unref?.();
   }
 
+  const workspacePreviewCleanupTimer = setInterval(() => {
+    try {
+      const removed = cleanupExpiredWorkspacePreviews();
+      if (removed > 0) log.debug(`[workspace-preview] removed ${removed} expired preview project(s)`);
+    } catch (e) {
+      log.debug(`[workspace-preview] cleanup poll failed: ${(e && e.message) || String(e)}`);
+    }
+  }, 60_000);
+  try {
+    workspacePreviewCleanupTimer.unref?.();
+  } catch (_) {}
+  server.on("close", () => clearInterval(workspacePreviewCleanupTimer));
+  try {
+    cleanupExpiredWorkspacePreviews();
+  } catch (_) {}
+
   return new Promise((resolve, reject) => {
     server.once("error", reject);
     server.listen(port, host, () => {

package/bin/lib/workspace-preview.mjs

@@ -0,0 +1,74 @@
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+import { getUserPipelinesRoot } from "./paths.mjs";
+
+export const WORKSPACE_PREVIEW_METADATA_FILENAME = ".agentflow-workspace-preview.json";
+export const DEFAULT_WORKSPACE_PREVIEW_TTL_MS = 2 * 60 * 60 * 1000;
+export const MAX_WORKSPACE_PREVIEW_TTL_MS = 24 * 60 * 60 * 1000;
+
+function safePreviewId(value = "") {
+  const raw = String(value || "").trim();
+  return /^preview_[a-z0-9_-]{8,100}$/i.test(raw) ? raw : "";
+}
+
+export function workspacePreviewMetadataPath(flowDir) {
+  return path.join(flowDir, WORKSPACE_PREVIEW_METADATA_FILENAME);
+}
+
+export function readWorkspacePreviewMetadata(flowDir) {
+  try {
+    const filePath = workspacePreviewMetadataPath(flowDir);
+    if (!fs.existsSync(filePath)) return null;
+    const value = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+    const flowId = safePreviewId(value.flowId);
+    const ownerId = String(value.ownerId || "").trim();
+    const expiresAt = String(value.expiresAt || "").trim();
+    if (!flowId || !ownerId || !Number.isFinite(Date.parse(expiresAt))) return null;
+    return { ...value, flowId, ownerId, expiresAt };
+  } catch {
+    return null;
+  }
+}
+
+export function isWorkspacePreviewDir(flowDir) {
+  return Boolean(readWorkspacePreviewMetadata(flowDir));
+}
+
+export function workspacePreviewFlowDir(flowId, userId = "") {
+  const safeId = safePreviewId(flowId);
+  if (!safeId) return "";
+  return path.join(getUserPipelinesRoot(userId), safeId);
+}
+
+export function createWorkspacePreviewId() {
+  return `preview_${crypto.randomBytes(10).toString("hex")}`;
+}
+
+export function normalizeWorkspacePreviewTtlMs(value) {
+  const requested = Number(value);
+  if (!Number.isFinite(requested) || requested <= 0) return DEFAULT_WORKSPACE_PREVIEW_TTL_MS;
+  return Math.min(MAX_WORKSPACE_PREVIEW_TTL_MS, Math.max(60_000, Math.round(requested)));
+}
+
+export function writeWorkspacePreviewMetadata(flowDir, metadata) {
+  const filePath = workspacePreviewMetadataPath(flowDir);
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tempPath, `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
+  fs.renameSync(tempPath, filePath);
+}
+
+export function listExpiredWorkspacePreviews(userPipelinesRoot, now = Date.now()) {
+  if (!fs.existsSync(userPipelinesRoot)) return [];
+  const expired = [];
+  for (const entry of fs.readdirSync(userPipelinesRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const flowDir = path.join(userPipelinesRoot, entry.name);
+    const metadata = readWorkspacePreviewMetadata(flowDir);
+    if (!metadata) continue;
+    if (Date.parse(metadata.expiresAt) <= now) expired.push({ flowDir, metadata });
+  }
+  return expired;
+}
+