@fieldwangai/agentflow 0.1.159 → 0.1.162

package/bin/lib/ui-server.mjs

@@ -52,6 +52,7 @@ import { packageResolverFor, scanAvailableNodePackages } from "./flow-dsl/packag
 import { runStartupStorageMigrations } from "./startup-storage-migrations.mjs";
 import { getPipelineFiles } from "./workspace-tree.mjs";
 import { listExpiredWorkspacePreviews } from "./workspace-preview.mjs";
+import { listExpiredWorkspaceDrafts } from "./workspace-draft.mjs";
 import { LEGACY_FLOW_EXECUTION_DISABLED, LEGACY_FLOW_EXECUTION_MESSAGE } from "./legacy-flow-execution.mjs";
 import {
   listRecentComposerSessions,
@@ -71,7 +72,11 @@ import {
   authSetupRequired,
   buildClearSessionCookie,
   buildSessionCookie,
+  createCliAuthorization,
+  decideCliAuthorization,
+  exchangeCliAuthorization,
   getAuthUserFromRequest,
+  getCliAuthorization,
   getSessionTokenFromRequest,
   isAuthUserAllowed,
   listAuthUsers,
@@ -80,8 +85,13 @@ import {
   readAuthUsers,
   readUserAllowlist,
   resetAuthUserPassword,
+  revokeSessionToken,
   writeUserAllowlist,
 } from "./auth.mjs";
+import {
+  renderCliAuthorizationPage,
+  renderCliAuthorizationResult,
+} from "./cli-auth-page.mjs";
 import { readGlobalEnvRows, readUserEnvRows, writeGlobalEnvRows, writeUserEnvRows } from "./user-env.mjs";
 import {
   readAdminBuiltinPipelineConfig,
@@ -167,7 +177,7 @@ import {
   writeDisplayShares,
   writeWorkspaceGraph,
 } from "./workspace-server.mjs";
-import { handleWorkspaceRoutes } from "./workspace-routes.mjs";
+import { handleWorkspaceRoutes, workspaceGraphWithScheduleMode } from "./workspace-routes.mjs";
 
 const MIME = {
   ".html": "text/html; charset=utf-8",
@@ -206,10 +216,8 @@ const BUILTIN_SKILL_COLLECTIONS = [
     id: "pipeline",
     name: "Pipeline",
     defaultKeys: [
-      "agentflow-flow-add-instances",
-      "agentflow-flow-edit-node-fields",
+      "agentflow-flow-dsl",
       "agentflow-flow-recipes",
-      "agentflow-flow-sync-ui",
       "agentflow-node-reference",
       "agentflow-placeholder-reference",
       "agentflow-runtime-reference",
@@ -219,7 +227,7 @@ const BUILTIN_SKILL_COLLECTIONS = [
     id: "workspace",
     name: "Workspace",
     defaultKeys: [
-      "agentflow-workspace-graph",
+      "agentflow-flow-dsl",
       "agentflow-workspace-markdown",
       "agentflow-workspace-mermaid",
       "agentflow-workspace-ascii",
@@ -233,7 +241,18 @@ const BUILTIN_SKILL_COLLECTIONS = [
     ],
     legacyDefaultKeys: [
       [
-        "agentflow-workspace-graph",
+        "agentflow-workspace-markdown",
+        "agentflow-workspace-mermaid",
+        "agentflow-workspace-ascii",
+        "agentflow-workspace-chart",
+        "agentflow-workspace-table",
+        "agentflow-workspace-html",
+        "agentflow-workspace-image",
+        "agentflow-node-reference",
+        "agentflow-placeholder-reference",
+        "agentflow-runtime-reference",
+      ],
+      [
         "agentflow-workspace-markdown",
         "agentflow-workspace-mermaid",
         "agentflow-workspace-ascii",
@@ -244,7 +263,6 @@ const BUILTIN_SKILL_COLLECTIONS = [
         "agentflow-runtime-reference",
       ],
       [
-        "agentflow-workspace-graph",
         "agentflow-workspace-markdown",
         "agentflow-workspace-mermaid",
         "agentflow-workspace-ascii",
@@ -1450,6 +1468,25 @@ function serverPublicBaseUrl(req, host, port, payload = null) {
   return configuredPublicBaseUrl(payload) || requestPublicBaseUrl(req) || normalizePublicBaseUrl(`http://${host}:${port}`);
 }
 
+function html(res, status, content, headers = {}) {
+  const body = String(content || "");
+  res.writeHead(status, {
+    "Content-Type": "text/html; charset=utf-8",
+    "Content-Length": Buffer.byteLength(body),
+    "Cache-Control": "no-store, max-age=0",
+    "Content-Security-Policy": "default-src 'none'; style-src 'unsafe-inline'; form-action 'self'; base-uri 'none'; frame-ancestors 'none'",
+    "X-Content-Type-Options": "nosniff",
+    "Referrer-Policy": "no-referrer",
+    ...headers,
+  });
+  res.end(body);
+}
+
+async function readUrlEncodedBody(req) {
+  const body = await readBody(req);
+  return new URLSearchParams(String(body || ""));
+}
+
 function publicDisplayPayloadFromShare(root, share) {
   const scoped = resolveWorkspaceScopeRoot(root, {
     flowId: share.flowId || "",
@@ -1684,7 +1721,7 @@ function bufferLooksLikeZip(buf) {
 
 /**
  * @param {import('http').IncomingMessage} req
- * @returns {Promise<{ targetSpace: string, flowIdField: string, file: Buffer, filename: string, gotFile: boolean }>}
+ * @returns {Promise<{ targetSpace: string, flowIdField: string, scheduleMode: string, file: Buffer, filename: string, gotFile: boolean }>}
  */
 function parseFlowsImportForm(req) {
   return new Promise((resolve, reject) => {
@@ -1694,6 +1731,7 @@ function parseFlowsImportForm(req) {
     });
     let targetSpace = "user";
     let flowIdField = "";
+    let scheduleMode = "disabled";
     /** @type {Buffer[]} */
     const chunks = [];
     let filename = "";
@@ -1706,6 +1744,9 @@ function parseFlowsImportForm(req) {
       if (name === "flowId" && typeof val === "string") {
         flowIdField = val;
       }
+      if (name === "scheduleMode" && typeof val === "string") {
+        scheduleMode = val.trim().toLowerCase();
+      }
     });
 
     bb.on("file", (name, file, info) => {
@@ -1725,6 +1766,7 @@ function parseFlowsImportForm(req) {
       resolve({
         targetSpace,
         flowIdField: flowIdField.trim(),
+        scheduleMode,
         file: Buffer.concat(chunks),
         filename,
         gotFile,
@@ -1748,12 +1790,16 @@ function cleanupExpiredWorkspacePreviews(workspaceRoot = "") {
   }
   let removed = 0;
   for (const pipelinesRoot of roots) {
-    for (const item of listExpiredWorkspacePreviews(pipelinesRoot)) {
+    const expired = [
+      ...listExpiredWorkspacePreviews(pipelinesRoot),
+      ...listExpiredWorkspaceDrafts(pipelinesRoot),
+    ];
+    for (const item of expired) {
       try {
         fs.rmSync(item.flowDir, { recursive: true, force: true });
         removed += 1;
       } catch (e) {
-        log.debug(`[workspace-preview] cleanup failed: ${(e && e.message) || String(e)}`);
+        log.debug(`[workspace-temporary] cleanup failed: ${(e && e.message) || String(e)}`);
       }
     }
   }
@@ -2013,12 +2059,12 @@ function buildComposerPromptWithFlowContext(p) {
     `- flowSource：${p.flowSource}`,
     ...builtinExtra,
     `- 当前关联的节点实例 ID（顺序：画布选中优先，再输入框 @提及）：${idsLine}`,
-    "- 像普通 agent 请求一样处理用户说明：可能只是问问题，也可能要求编辑文件。不要因为存在 flowId 就默认修改 flow.yaml。",
+    "- 像普通 agent 请求一样处理用户说明：可能只是问问题，也可能要求编辑文件。不要因为存在 flowId 就默认修改流程。",
     "- 按需使用当前环境可用的 skills；如果用户点名某个 skill，遵循该 skill 的 SKILL.md。",
     "- 如果你判断需要编辑 AgentFlow 流程，可按需读取这些本地 skills：",
-    "  - `skills/agentflow-flow-add-instances/SKILL.md`：新增实例、边和布局",
-    "  - `skills/agentflow-flow-edit-node-fields/SKILL.md`：只改已有节点字段",
-    "  - `skills/agentflow-flow-sync-ui/SKILL.md`：保存 flow.yaml 后刷新画布",
+    "  - `skills/agentflow-flow-dsl/SKILL.md`：新建或修改 workspace.flow.js、节点、字段、连线、子流程与受控循环",
+    "  - `skills/agentflow-node-dsl/SKILL.md`：仅在需要确定性自定义代码节点时使用",
+    "  - `skills/agentflow-author-flow/SKILL.md`：需要 Draft、试运行、动态修改、发布或定时时使用完整生命周期",
     "- 如果只是回答问题，不要修改文件。",
     "",
     ...(p.selectedSkillBlock ? [p.selectedSkillBlock, ""] : []),
@@ -2091,6 +2137,132 @@ export function startUiServer({
       return;
     }
 
+    if (url.pathname === "/api/auth/cli/device" && req.method === "POST") {
+      let payload = {};
+      try {
+        const raw = await readBody(req);
+        payload = raw ? JSON.parse(raw) : {};
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      const authorization = createCliAuthorization({
+        publicBaseUrl: serverPublicBaseUrl(req, host, uiPort),
+        clientName: payload?.clientName,
+      });
+      json(res, 201, {
+        requestId: authorization.requestId,
+        deviceCode: authorization.deviceCode,
+        userCode: authorization.userCode,
+        verificationUrl: authorization.verificationUrl,
+        expiresAt: authorization.expiresAt,
+        pollInterval: authorization.pollInterval,
+      });
+      return;
+    }
+
+    if (url.pathname === "/api/auth/cli/token" && req.method === "POST") {
+      let payload = {};
+      try {
+        const raw = await readBody(req);
+        payload = raw ? JSON.parse(raw) : {};
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      const result = exchangeCliAuthorization(payload?.deviceCode);
+      if (!result.ok) {
+        json(res, result.status || 400, {
+          error: result.error,
+          code: result.code || "invalid_request",
+          authorization: result.authorization || undefined,
+        });
+        return;
+      }
+      json(res, 200, result);
+      return;
+    }
+
+    if (url.pathname === "/api/auth/cli/revoke" && req.method === "POST") {
+      const token = getSessionTokenFromRequest(req);
+      if (!token || !getAuthUserFromRequest(req)) {
+        json(res, 401, { error: "Unauthorized" });
+        return;
+      }
+      revokeSessionToken(token);
+      json(res, 200, { ok: true });
+      return;
+    }
+
+    if (url.pathname === "/cli/authorize" && req.method === "GET") {
+      const requestId = String(url.searchParams.get("request") || "").trim();
+      const user = getAuthUserFromRequest(req);
+      const result = getCliAuthorization(requestId, { includeApprovalNonce: Boolean(user) });
+      if (result.ok && result.authorization.status !== "pending") {
+        html(res, 200, renderCliAuthorizationResult({
+          approved: result.authorization.status === "approved",
+          clientName: result.authorization.clientName,
+        }));
+        return;
+      }
+      html(res, result.ok ? 200 : result.status || 404, renderCliAuthorizationPage({
+        authorization: result.authorization || null,
+        approvalNonce: result.approvalNonce || "",
+        user,
+        error: result.ok ? "" : result.error,
+      }));
+      return;
+    }
+
+    if (url.pathname === "/cli/authorize/login" && req.method === "POST") {
+      const form = await readUrlEncodedBody(req);
+      const requestId = String(form.get("request") || "").trim();
+      const pending = getCliAuthorization(requestId);
+      if (!pending.ok) {
+        html(res, pending.status || 404, renderCliAuthorizationPage({ error: pending.error }));
+        return;
+      }
+      const result = loginOrCreateUser(form.get("username"), form.get("password"));
+      if (!result.ok) {
+        html(res, result.forbidden ? 403 : 401, renderCliAuthorizationPage({
+          authorization: pending.authorization,
+          error: result.error || "Login failed",
+        }));
+        return;
+      }
+      res.writeHead(303, {
+        Location: `/cli/authorize?request=${encodeURIComponent(requestId)}`,
+        "Set-Cookie": buildSessionCookie(result.token),
+        "Cache-Control": "no-store, max-age=0",
+      });
+      res.end();
+      return;
+    }
+
+    if (url.pathname === "/cli/authorize/decision" && req.method === "POST") {
+      const user = getAuthUserFromRequest(req);
+      if (!user) {
+        html(res, 401, renderCliAuthorizationResult({ error: "登录状态已失效，请重新打开授权链接。" }));
+        return;
+      }
+      const form = await readUrlEncodedBody(req);
+      const requestId = String(form.get("request") || "").trim();
+      const current = getCliAuthorization(requestId);
+      const approved = form.get("decision") === "approve";
+      const result = decideCliAuthorization({
+        requestId,
+        approvalNonce: form.get("approvalNonce"),
+        userId: user.userId,
+        approved,
+      });
+      html(res, result.ok ? 200 : result.status || 400, renderCliAuthorizationResult({
+        approved,
+        clientName: current.authorization?.clientName,
+        error: result.ok ? "" : result.error,
+      }));
+      return;
+    }
+
     if (url.pathname === "/api/app-version" && req.method === "GET") {
       res.setHeader("Cache-Control", "no-store, max-age=0");
       json(res, 200, {
@@ -2706,6 +2878,10 @@ export function startUiServer({
       }
       const flowId = idCheck.flowId;
       const targetSpace = parsed.targetSpace === "workspace" ? "workspace" : "user";
+      if (!["enabled", "disabled", "preserve"].includes(parsed.scheduleMode)) {
+        json(res, 400, { error: "scheduleMode must be enabled, disabled, or preserve" });
+        return;
+      }
       const existing = listFlowsJson(root, {
         ...userCtx,
         includeWorkspaceFlows: targetSpace === "workspace",
@@ -2747,10 +2923,37 @@ export function startUiServer({
         json(res, 400, { error: w.error });
         return;
       }
-      if (targetSpace === "workspace") {
-        ensureWorkspaceCollaboration({ flowId, userId: userCtx.userId });
+      const targetDir = targetSpace === "workspace"
+        ? path.join(path.resolve(root), PIPELINES_DIR, flowId)
+        : path.join(getUserPipelinesRoot(userCtx.userId), flowId);
+      let collaborationCreated = false;
+      try {
+        if (targetSpace === "workspace") {
+          ensureWorkspaceCollaboration({ flowId, userId: userCtx.userId });
+          collaborationCreated = true;
+        }
+        const scoped = resolveWorkspaceScopeRoot(root, { flowId, flowSource: targetSpace }, userCtx);
+        if (scoped.error) throw new Error(scoped.error);
+        const importedGraph = readWorkspaceGraph(scoped.root, root).graph;
+        const graph = workspaceGraphWithScheduleMode(importedGraph, parsed.scheduleMode);
+        if (graph !== importedGraph) writeWorkspaceGraph(scoped.root, graph, root);
+        const persisted = readWorkspaceGraph(scoped.root, root).graph;
+        const workspaceSchedules = syncWorkspaceSchedulesForGraph(root, scoped, persisted, authUser, userCtx);
+        json(res, 200, {
+          success: true,
+          flowId,
+          flowSource: targetSpace,
+          scheduleMode: parsed.scheduleMode,
+          workspaceSchedules,
+        });
+      } catch (e) {
+        try { fs.rmSync(targetDir, { recursive: true, force: true }); } catch (_) {}
+        if (collaborationCreated) deleteWorkspaceCollaborationForFlow(flowId, false);
+        json(res, 500, {
+          error: `Flow publication rolled back: ${(e && e.message) || String(e)}`,
+          rolledBack: true,
+        });
       }
-      json(res, 200, { success: true, flowId, flowSource: targetSpace });
       return;
     }
 

package/bin/lib/workspace-draft.mjs

@@ -0,0 +1,74 @@
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+
+import { getUserPipelinesRoot } from "./paths.mjs";
+
+export const WORKSPACE_DRAFT_METADATA_FILENAME = ".agentflow-workspace-draft.json";
+export const DEFAULT_WORKSPACE_DRAFT_TTL_MS = 2 * 60 * 60 * 1000;
+export const MAX_WORKSPACE_DRAFT_TTL_MS = 24 * 60 * 60 * 1000;
+
+export function safeWorkspaceDraftId(value = "") {
+  const raw = String(value || "").trim();
+  return /^draft_[a-z0-9_-]{8,100}$/i.test(raw) ? raw : "";
+}
+
+export function createWorkspaceDraftId() {
+  return `draft_${crypto.randomBytes(10).toString("hex")}`;
+}
+
+export function workspaceDraftFlowDir(draftId, userId = "") {
+  const safeId = safeWorkspaceDraftId(draftId);
+  if (!safeId) return "";
+  return path.join(getUserPipelinesRoot(userId), safeId);
+}
+
+export function workspaceDraftMetadataPath(flowDir) {
+  return path.join(flowDir, WORKSPACE_DRAFT_METADATA_FILENAME);
+}
+
+export function readWorkspaceDraftMetadata(flowDir) {
+  try {
+    const filePath = workspaceDraftMetadataPath(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 = safeWorkspaceDraftId(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 isWorkspaceDraftDir(flowDir) {
+  return Boolean(readWorkspaceDraftMetadata(flowDir));
+}
+
+export function normalizeWorkspaceDraftTtlMs(value) {
+  const requested = Number(value);
+  if (!Number.isFinite(requested) || requested <= 0) return DEFAULT_WORKSPACE_DRAFT_TTL_MS;
+  return Math.min(MAX_WORKSPACE_DRAFT_TTL_MS, Math.max(60_000, Math.round(requested)));
+}
+
+export function writeWorkspaceDraftMetadata(flowDir, metadata) {
+  const filePath = workspaceDraftMetadataPath(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 listExpiredWorkspaceDrafts(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 = readWorkspaceDraftMetadata(flowDir);
+    if (!metadata) continue;
+    if (Date.parse(metadata.expiresAt) <= now) expired.push({ flowDir, metadata });
+  }
+  return expired;
+}

package/bin/lib/workspace-flow-store.mjs

@@ -108,7 +108,7 @@ function readTextOrNull(file) {
 }
 
 export function emptyDesignGraph() {
-  return { version: 1, instances: {}, edges: [], ui: { nodePositions: {} } };
+  return { version: 1, instances: {}, edges: [], subflows: {}, ui: { nodePositions: {} } };
 }
 
 function normalizeDesignShape(raw) {
@@ -120,6 +120,10 @@ function normalizeDesignShape(raw) {
         ? graph.instances
         : {},
     edges: Array.isArray(graph.edges) ? graph.edges : [],
+    subflows:
+      graph.subflows && typeof graph.subflows === "object" && !Array.isArray(graph.subflows)
+        ? graph.subflows
+        : {},
     ui: graph.ui && typeof graph.ui === "object" ? graph.ui : { nodePositions: {} },
   };
 }
@@ -226,7 +230,12 @@ export function designFingerprint(graph) {
     .filter((e) => e && design.instances[e.source] && design.instances[e.target])
     .map((e) => `${e.source}|${asText(e.sourceHandle)}|${e.target}|${asText(e.targetHandle)}`)
     .sort();
-  return stableStringify({ instances, edges: [...new Set(edges)], ui: normalizeUi(design.ui) });
+  return stableStringify({
+    instances,
+    edges: [...new Set(edges)],
+    subflows: design.subflows,
+    ui: normalizeUi(design.ui),
+  });
 }
 
 // ── 读 ──────────────────────────────────────────────────────────────────────

package/bin/lib/workspace-graph-merge.mjs

@@ -34,6 +34,9 @@ function normalizedGraph(graph) {
     version: Number(source.version) || 1,
     instances: isPlainObject(source.instances) ? clone(source.instances) : {},
     edges: Array.isArray(source.edges) ? clone(source.edges) : [],
+    // Subflows are first-class design metadata. Dropping them here makes every
+    // revision-aware canvas save silently erase call contracts and entry roots.
+    subflows: isPlainObject(source.subflows) ? clone(source.subflows) : {},
     ui: isPlainObject(source.ui) ? clone(source.ui) : { nodePositions: {} },
   };
 }