@fieldwangai/agentflow 0.1.160 → 0.1.163

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-routes.mjs

@@ -17,26 +17,38 @@ import { buildSkillCompactInjectionBlock, loadResourcesForSkillKeys } from "./co
 import { execFileBuffered } from "./exec-buffered.mjs";
 import { runGit } from "./git-worktree.mjs";
 import {
+  listMarketplaceFlows,
   listMarketplacePackages,
   nodePackageArchive,
+  publishMarketplaceFlow,
   publishNodePackage,
   publishNodePackageArchive,
+  readMarketplaceFlow,
   resolveMarketplaceNodePackage,
+  setMarketplaceVisibility,
 } from "./marketplace.mjs";
+import {
+  appendMarketplaceUsageEvent,
+  marketplaceResourcesForRun,
+  writeMarketplaceFlowOrigin,
+} from "./marketplace-usage.mjs";
 import { NODE_PACKAGE_ENTRY, nodePackageExportsRun, readNodePackageManifest } from "./node-package-manifest.mjs";
 import { inspectNodePackageDirectory } from "./node-package-archive.mjs";
 import { json, readBody } from "./http-util.mjs";
 import { log } from "./log.mjs";
-import { PACKAGE_ROOT, getAgentflowUserDataRoot } from "./paths.mjs";
+import { PACKAGE_ROOT, PIPELINES_DIR, getAgentflowUserDataRoot, getUserPipelinesRoot } from "./paths.mjs";
+import { validateUserPipelineId } from "./flow-write.mjs";
 import { runLedgerId } from "./run-ledger.mjs";
 import { getTeamById, getTeamForUser } from "./teams.mjs";
 import { readMergedEnvObject, runtimeEnvForUser } from "./user-env.mjs";
-import { acceptWorkspaceCollaborationInvite, addWorkspaceCollaborationMember, ensureWorkspaceCollaboration, getWorkspaceCollaborationForProject, listWorkspaceCollaborationsForUser, removeWorkspaceCollaborationMember, removeWorkspaceCollaborationTeamShare, setWorkspaceCollaborationTeamShare, workspaceCollaborationAccess } from "./workspace-collaboration.mjs";
+import { acceptWorkspaceCollaborationInvite, addWorkspaceCollaborationMember, deleteWorkspaceCollaborationForFlow, ensureWorkspaceCollaboration, getWorkspaceCollaborationForProject, listWorkspaceCollaborationsForUser, removeWorkspaceCollaborationMember, removeWorkspaceCollaborationTeamShare, setWorkspaceCollaborationTeamShare, workspaceCollaborationAccess } from "./workspace-collaboration.mjs";
 import { WorkspaceFlowParseError } from "./workspace-flow-store.mjs";
 import { mergeWorkspaceGraphs, workspaceDesignRevision, workspaceRuntimeRevision } from "./workspace-graph-merge.mjs";
 import { DEFAULT_WORKSPACE_PREVIEW_TTL_MS, createWorkspacePreviewId, normalizeWorkspacePreviewTtlMs, readWorkspacePreviewMetadata, workspaceSharedPreviewFlowDir, writeWorkspacePreviewMetadata } from "./workspace-preview.mjs";
+import { DEFAULT_WORKSPACE_DRAFT_TTL_MS, createWorkspaceDraftId, normalizeWorkspaceDraftTtlMs, readWorkspaceDraftMetadata, workspaceDraftFlowDir, writeWorkspaceDraftMetadata } from "./workspace-draft.mjs";
 import { appendWorkspaceRunLogEvent, createWorkspaceRunLogSession, finishWorkspaceRunLogSession, listWorkspaceRunLogs, readWorkspaceRunLogEvents } from "./workspace-run-logs.mjs";
-import { activeWorkspaceRuns, appendWorkspaceRunFinished, appendWorkspaceRunStarted, hydrateWorkspaceGraphForRuntime, isReadonlyBuiltinFlowSource, isTransientAgentNetworkError, isValidFlowSourceRead, isWorkspaceRunAbortError, listWorkspaceScheduleStatusesForFlow, mergeWorkspacePersistentNodeRefs, mergeWorkspaceRunGraph, normalizeWorkspaceEntry, readWorkspaceConversations, readWorkspaceFiles, readWorkspaceGraph, removeWorkspaceDeferredRun, resolveWorkspaceFilePath, resolveWorkspaceScopeRoot, runWorkspaceGraph, sleepMs, syncWorkspaceSchedulesForGraph, upsertWorkspaceDeferredRun, workspaceActiveRunsForScope, workspaceCollaborationEventKey, workspaceCollaborationSequences, workspaceCollaborationSubscribers, workspaceCollaborationSummaryWithUsers, workspaceDeferredRunsForScope, workspaceDesignPath, workspaceDownloadContentDisposition, workspaceFindActiveRunConflict, workspaceGraphAsSource, workspaceOptimizeRunImplementations, workspaceRepoUrlWithCredential, workspaceRunControl, workspaceRunEntryKey, workspaceRunKey, workspaceRunPlan, workspaceRunPlanNodeIds, workspaceRunTouchedNodeIds, workspaceRuntimeNodeLabel, workspaceScopedUserContext, workspaceSearchGuardrailsBlock, workspaceUnwrapOutputEnvelopeForDisplay, workspacesPath, writeWorkspaceConversations, writeWorkspaceGraph } from "./workspace-server.mjs";
+import { activeWorkspaceRuns, appendWorkspaceRunFinished, appendWorkspaceRunStarted, cleanupWorkspaceRunResources, hydrateWorkspaceGraphForRuntime, isReadonlyBuiltinFlowSource, isTransientAgentNetworkError, isValidFlowSourceRead, isWorkspaceRunAbortError, listWorkspaceScheduleStatusesForFlow, mergeWorkspacePersistentNodeRefs, mergeWorkspaceRunGraph, normalizeWorkspaceEntry, normalizeWorkspaceScheduledRunConfig, readWorkspaceConversations, readWorkspaceFiles, readWorkspaceGraph, removeWorkspaceDeferredRun, resolveWorkspaceFilePath, resolveWorkspaceScopeRoot, runWorkspaceGraph, sleepMs, syncWorkspaceSchedulesForGraph, upsertWorkspaceDeferredRun, workspaceActiveRunsForScope, workspaceCollaborationEventKey, workspaceCollaborationSequences, workspaceCollaborationSubscribers, workspaceCollaborationSummaryWithUsers, workspaceDeferredRunsForScope, workspaceDesignPath, workspaceDownloadContentDisposition, workspaceFindActiveRunConflict, workspaceGraphAsSource, workspaceOptimizeRunImplementations, workspaceRepoUrlWithCredential, workspaceRunControl, workspaceRunEntryKey, workspaceRunKey, workspaceRunPlan, workspaceRunPlanNodeIds, workspaceRunTouchedNodeIds, workspaceRuntimeNodeLabel, workspaceScheduleNextRunAt, workspaceScopedUserContext, workspaceSearchGuardrailsBlock, workspaceUnwrapOutputEnvelopeForDisplay, workspacesPath, writeWorkspaceConversations, writeWorkspaceGraph } from "./workspace-server.mjs";
+import { splitWorkspaceGraph, WORKSPACE_STATE_FILENAME } from "./workspace-state.mjs";
 import { getWorkspaceTree } from "./workspace-tree.mjs";
 import busboy from "busboy";
 import crypto from "crypto";
@@ -192,6 +204,29 @@ function commitWorkspaceGraph(workspaceRoot, scoped, graph, userCtx) {
   };
 }
 
+export function workspaceGraphWithScheduleMode(graph, mode = "disabled") {
+  const normalizedMode = String(mode || "disabled").trim().toLowerCase();
+  if (!["enabled", "disabled", "preserve"].includes(normalizedMode)) {
+    throw new Error("scheduleMode must be enabled, disabled, or preserve");
+  }
+  if (normalizedMode === "preserve") return graph;
+  const enabled = normalizedMode === "enabled";
+  const instances = { ...(graph?.instances || {}) };
+  let scheduleCount = 0;
+  for (const [nodeId, instance] of Object.entries(instances)) {
+    if (String(instance?.definitionId || "") !== "workspace_scheduled_run") continue;
+    scheduleCount += 1;
+    const config = normalizeWorkspaceScheduledRunConfig(instance.body || "");
+    const nextConfig = { ...config, enabled };
+    if (enabled) workspaceScheduleNextRunAt(nextConfig, new Date());
+    instances[nodeId] = { ...instance, body: JSON.stringify(nextConfig) };
+  }
+  if (enabled && scheduleCount === 0) {
+    throw new Error("Cannot enable scheduling: the draft has no Scheduled Run node");
+  }
+  return { ...graph, instances };
+}
+
 function missingWorkspaceGraphNodePackages(workspaceRoot, scoped, graph, userCtx) {
   const missing = new Set();
   for (const instance of Object.values(graph?.instances || {})) {
@@ -895,6 +930,11 @@ async function workspaceRoutes(req, res, ctx) {
             inputs: node.inputs,
             outputs: node.outputs,
             ownerUserId: node.ownerUserId || node.createdBy || "",
+            visibility: node.visibility || "public",
+            useCount: Number(node.useCount || 0),
+            installCount: Number(node.installCount || 0),
+            uniqueUserCount: Number(node.uniqueUserCount || 0),
+            lastUsedAt: node.lastUsedAt || "",
             fileList: node.fileList || [],
             fileCount: node.fileCount || 0,
             totalBytes: node.totalBytes || 0,
@@ -954,6 +994,14 @@ async function workspaceRoutes(req, res, ctx) {
           json(res, 404, { error: result.error || "Node package not found" });
           return;
         }
+        appendMarketplaceUsageEvent(root, {
+          kind: "node",
+          id,
+          version,
+          action: "install",
+          actorUserId: userCtx.userId || "",
+          eventId: `install:node:${id}@${version}:${userCtx.userId || "anonymous"}`,
+        });
         res.writeHead(200, {
           "Content-Type": "application/zip",
           "Content-Length": result.archive.length,
@@ -969,6 +1017,158 @@ async function workspaceRoutes(req, res, ctx) {
       return;
     }
 
+    if (req.method === "GET" && url.pathname === "/api/marketplace/resources") {
+      try {
+        const kind = String(url.searchParams.get("kind") || "flow").trim();
+        const marketplaceScope = url.searchParams.get("scope") === "owned" ? "owned" : "all";
+        const queryText = String(url.searchParams.get("q") || "").trim().toLowerCase();
+        const matches = (item) => !queryText || [
+          item.id,
+          item.displayName,
+          item.description,
+          item.ownerUserId,
+          ...(Array.isArray(item.tags) ? item.tags : []),
+        ].filter(Boolean).join("\n").toLowerCase().includes(queryText);
+        if (kind === "node") {
+          const nodes = listMarketplacePackages(root, { ...userCtx, marketplaceScope }).nodes.filter(matches);
+          json(res, 200, { kind, sort: "useCount", order: "desc", items: nodes });
+          return;
+        }
+        if (kind !== "flow") {
+          json(res, 400, { error: "kind must be flow or node" });
+          return;
+        }
+        const flows = listMarketplaceFlows(root, { ...userCtx, marketplaceScope }).flows.filter(matches);
+        json(res, 200, { kind, sort: "useCount", order: "desc", items: flows });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/marketplace/flows/publish") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      try {
+        const flowId = String(payload?.flowId || "").trim();
+        const flowSource = String(payload?.flowSource || "user").trim();
+        const scoped = resolveWorkspaceScopeRoot(root, {
+          flowId,
+          flowSource,
+          archived: payload?.archived === true,
+        }, userCtx);
+        if (scoped.error) {
+          json(res, scoped.status || 400, { error: scoped.error });
+          return;
+        }
+        if (scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource)) {
+          json(res, 400, { error: "Only active editable flows can be published" });
+          return;
+        }
+        const current = readWorkspaceGraph(scoped.root, root).graph;
+        const { design } = splitWorkspaceGraph(current);
+        const graph = workspaceGraphWithScheduleMode(design, "disabled");
+        const result = publishMarketplaceFlow(root, {
+          id: payload?.id || flowId,
+          version: payload?.version || "1.0.0",
+          displayName: payload?.displayName || flowId,
+          description: payload?.description || "",
+          tags: payload?.tags || [],
+          visibility: payload?.visibility || "public",
+          graph,
+        }, userCtx);
+        json(res, result.ok ? (result.alreadyExists ? 200 : 201) : (result.conflict ? 409 : 400), result);
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/marketplace/flows/install") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      const id = String(payload?.id || "").trim();
+      const version = String(payload?.version || "").trim();
+      const idCheck = validateUserPipelineId(String(payload?.flowId || id));
+      if (!id || !version || !idCheck.ok) {
+        json(res, 400, { error: idCheck.error || "Missing marketplace flow id or version" });
+        return;
+      }
+      const flowId = idCheck.flowId;
+      const targetDir = path.join(getUserPipelinesRoot(userCtx.userId), flowId);
+      if (fs.existsSync(targetDir)) {
+        json(res, 409, { error: `已存在同名流水线 ${flowId}` });
+        return;
+      }
+      try {
+        const source = readMarketplaceFlow(root, id, version, { ...userCtx, marketplaceScope: "all" });
+        if (!source.ok) {
+          json(res, 404, { error: source.error || "Marketplace flow not found" });
+          return;
+        }
+        fs.mkdirSync(targetDir, { recursive: true });
+        const graph = workspaceGraphWithScheduleMode(source.graph, "disabled");
+        writeWorkspaceGraph(targetDir, graph, root);
+        writeMarketplaceFlowOrigin(targetDir, { id, version });
+        appendMarketplaceUsageEvent(root, {
+          kind: "flow",
+          id,
+          version,
+          action: "install",
+          actorUserId: userCtx.userId || "",
+          eventId: `install:flow:${id}@${version}:${userCtx.userId || "anonymous"}`,
+        });
+        json(res, 201, {
+          ok: true,
+          id,
+          version,
+          flowId,
+          flowSource: "user",
+          url: `/workspace?flowId=${encodeURIComponent(flowId)}&flowSource=user`,
+        });
+      } catch (e) {
+        try {
+          if (fs.existsSync(targetDir)) fs.rmSync(targetDir, { recursive: true, force: true });
+        } catch {}
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "PATCH" && url.pathname === "/api/marketplace/visibility") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      try {
+        const result = setMarketplaceVisibility(
+          root,
+          String(payload?.kind || ""),
+          String(payload?.id || ""),
+          String(payload?.version || ""),
+          String(payload?.visibility || "public"),
+          userCtx,
+        );
+        json(res, result.ok ? 200 : 400, result);
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "GET" && url.pathname === "/api/workspace-tree") {
       try {
         json(res, 200, getWorkspaceTree(root));
@@ -1309,6 +1509,185 @@ async function workspaceRoutes(req, res, ctx) {
       return;
     }
 
+    if (req.method === "POST" && url.pathname === "/api/workspace/draft") {
+      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 rawRequestedId = String(payload.draftId || "").trim();
+      const flowId = rawRequestedId || createWorkspaceDraftId();
+      const flowDir = workspaceDraftFlowDir(flowId, authUser.userId);
+      if (!flowDir) {
+        json(res, 400, { error: "Invalid draftId" });
+        return;
+      }
+      const existing = readWorkspaceDraftMetadata(flowDir);
+      if (existing && existing.ownerId !== authUser.userId) {
+        json(res, 403, { error: "Draft ownership denied" });
+        return;
+      }
+      if (rawRequestedId && !existing && fs.existsSync(flowDir)) {
+        json(res, 409, { error: "Draft project already exists but is not a draft" });
+        return;
+      }
+      if (existing) {
+        const currentGraph = readWorkspaceGraph(flowDir, root).graph;
+        const currentRevision = workspaceDesignRevision(currentGraph);
+        const baseRevision = String(payload.baseRevision || "").trim();
+        if (!baseRevision) {
+          json(res, 428, {
+            error: "Draft update requires baseRevision",
+            conflict: "missing-base-revision",
+            currentRevision,
+          });
+          return;
+        }
+        if (baseRevision !== currentRevision) {
+          json(res, 409, {
+            error: "Draft 已被更新，请先拉取最新版本后再修改",
+            conflict: "revision-mismatch",
+            expectedRevision: baseRevision,
+            currentRevision,
+          });
+          return;
+        }
+      }
+      const now = Date.now();
+      const ttlInput = payload.ttlMs != null
+        ? Number(payload.ttlMs)
+        : payload.ttlSeconds != null
+          ? Number(payload.ttlSeconds) * 1000
+          : DEFAULT_WORKSPACE_DRAFT_TTL_MS;
+      const ttlMs = normalizeWorkspaceDraftTtlMs(ttlInput);
+      const metadata = {
+        version: 1,
+        flowId,
+        ownerId: authUser.userId,
+        title: String(payload.title || "Workspace Draft").trim().slice(0, 200),
+        createdAt: existing?.createdAt || new Date(now).toISOString(),
+        updatedAt: new Date(now).toISOString(),
+        expiresAt: new Date(now + ttlMs).toISOString(),
+      };
+      const created = !fs.existsSync(flowDir);
+      try {
+        fs.mkdirSync(flowDir, { recursive: true });
+        if (payload.resetRuntime !== false) {
+          const statePath = path.join(flowDir, WORKSPACE_STATE_FILENAME);
+          if (fs.existsSync(statePath)) fs.rmSync(statePath);
+        }
+        const written = writeWorkspaceGraph(flowDir, graph, root);
+        writeWorkspaceDraftMetadata(flowDir, metadata);
+        const persisted = readWorkspaceGraph(flowDir, root).graph;
+        const baseUrl = `${url.protocol}//${url.host}`;
+        json(res, 200, {
+          ok: true,
+          flowId,
+          draftId: flowId,
+          flowSource: "user",
+          draft: true,
+          writable: true,
+          runnable: true,
+          schedulesSuppressed: true,
+          revision: workspaceDesignRevision(persisted),
+          format: written.format,
+          expiresAt: metadata.expiresAt,
+          url: `${baseUrl}/workspace?flowId=${encodeURIComponent(flowId)}&flowSource=user`,
+        });
+      } catch (e) {
+        if (created) {
+          try { fs.rmSync(flowDir, { recursive: true, force: true }); } catch (_) {}
+        }
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/workspace/draft/publish") {
+      if (!authUser?.userId) {
+        json(res, 401, { error: "Authentication required" });
+        return;
+      }
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      const draftId = String(payload.draftId || "").trim();
+      const draftDir = workspaceDraftFlowDir(draftId, authUser.userId);
+      const draftMetadata = draftDir ? readWorkspaceDraftMetadata(draftDir) : null;
+      if (!draftMetadata || draftMetadata.ownerId !== authUser.userId) {
+        json(res, 404, { error: "Workspace draft not found" });
+        return;
+      }
+      const idCheck = validateUserPipelineId(String(payload.flowId || ""));
+      if (!idCheck.ok) {
+        json(res, 400, { error: idCheck.error });
+        return;
+      }
+      const flowId = idCheck.flowId;
+      const requestedTarget = String(payload.targetSpace || "personal").trim().toLowerCase();
+      const flowSource = requestedTarget === "workspace" || requestedTarget === "team" ? "workspace" : "user";
+      const targetDir = flowSource === "workspace"
+        ? path.join(path.resolve(root), PIPELINES_DIR, flowId)
+        : path.join(getUserPipelinesRoot(authUser.userId), flowId);
+      if (fs.existsSync(targetDir)) {
+        json(res, 409, { error: `已存在同名流水线 ${flowId}` });
+        return;
+      }
+      try {
+        const draftGraph = readWorkspaceGraph(draftDir, root).graph;
+        const graph = workspaceGraphWithScheduleMode(draftGraph, payload.scheduleMode || "disabled");
+        fs.mkdirSync(targetDir, { recursive: true });
+        writeWorkspaceGraph(targetDir, graph, root);
+        let collaborationCreated = false;
+        if (flowSource === "workspace") {
+          ensureWorkspaceCollaboration({ flowId, userId: authUser.userId });
+          collaborationCreated = true;
+        }
+        try {
+          const scoped = resolveWorkspaceScopeRoot(root, { flowId, flowSource }, userCtx);
+          if (scoped.error) throw new Error(scoped.error);
+          const persisted = readWorkspaceGraph(scoped.root, root).graph;
+          const workspaceSchedules = syncWorkspaceSchedulesForGraph(root, scoped, persisted, authUser, userCtx);
+          const baseUrl = `${url.protocol}//${url.host}`;
+          json(res, 200, {
+            ok: true,
+            success: true,
+            action: "created",
+            draftId,
+            flowId,
+            flowSource,
+            targetSpace: requestedTarget === "team" ? "team" : flowSource === "user" ? "personal" : "workspace",
+            scheduleMode: String(payload.scheduleMode || "disabled").toLowerCase(),
+            workspaceSchedules,
+            revision: workspaceDesignRevision(persisted),
+            url: `${baseUrl}/workspace?flowId=${encodeURIComponent(flowId)}&flowSource=${encodeURIComponent(flowSource)}`,
+          });
+        } catch (e) {
+          if (collaborationCreated) deleteWorkspaceCollaborationForFlow(flowId, false);
+          throw e;
+        }
+      } catch (e) {
+        try { fs.rmSync(targetDir, { recursive: true, force: true }); } catch (_) {}
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "POST" && url.pathname === "/api/workspace/preview") {
       if (!authUser?.userId) {
         json(res, 401, { error: "Authentication required" });
@@ -1475,6 +1854,7 @@ async function workspaceRoutes(req, res, ctx) {
           flowId: scoped.flowId,
           flowSource: scoped.flowSource,
           archived: scoped.archived,
+          draft: scoped.draft === true,
           writable: !(scoped.archived || isReadonlyBuiltinFlowSource(scoped.flowSource))
             && scoped.adminReadonly !== true
             && collaborationAccess.writable !== false,
@@ -1596,7 +1976,20 @@ async function workspaceRoutes(req, res, ctx) {
         const graph = mergeWorkspacePersistentNodeRefs(nextGraph, currentGraph);
         const committed = commitWorkspaceGraph(root, scoped, graph, userCtx);
         const { path: graphPath, revision, runtimeRevision } = committed;
-        const workspaceSchedules = syncWorkspaceSchedulesForGraph(root, scoped, committed.graph, authUser, userCtx);
+        let workspaceSchedules;
+        try {
+          workspaceSchedules = syncWorkspaceSchedulesForGraph(root, scoped, committed.graph, authUser, userCtx);
+        } catch (scheduleError) {
+          try {
+            const rolledBack = commitWorkspaceGraph(root, scoped, currentStoredGraph, userCtx);
+            syncWorkspaceSchedulesForGraph(root, scoped, rolledBack.graph, authUser, userCtx);
+          } catch (rollbackError) {
+            throw new Error(
+              `Workspace schedule sync failed and graph rollback also failed: ${(scheduleError && scheduleError.message) || String(scheduleError)}; rollback: ${(rollbackError && rollbackError.message) || String(rollbackError)}`,
+            );
+          }
+          throw new Error(`Workspace graph save rolled back: ${(scheduleError && scheduleError.message) || String(scheduleError)}`);
+        }
         broadcastWorkspaceCollaborationEvent(
           userCtx,
           scoped.flowSource,
@@ -1655,6 +2048,80 @@ async function workspaceRoutes(req, res, ctx) {
       return;
     }
 
+    if (req.method === "POST" && url.pathname === "/api/workspace/schedule/config") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      try {
+        const flowId = String(payload.flowId || "").trim();
+        const flowSource = String(payload.flowSource || "user").trim() || "user";
+        const scheduleNodeId = String(payload.scheduleNodeId || "").trim();
+        if (!flowId || !scheduleNodeId) {
+          json(res, 400, { error: "flowId and scheduleNodeId are required" });
+          return;
+        }
+        const scoped = resolveWorkspaceScopeRoot(root, { flowId, flowSource }, userCtx);
+        if (scoped.error) {
+          json(res, scoped.status || 400, { error: scoped.error });
+          return;
+        }
+        if (
+          scoped.archived
+          || isReadonlyBuiltinFlowSource(scoped.flowSource)
+          || scoped.collaborationAccess?.writable === false
+        ) {
+          json(res, 403, { error: "Workspace schedule edit permission denied" });
+          return;
+        }
+        const graph = readWorkspaceGraph(scoped.root, root).graph;
+        const instance = graph.instances?.[scheduleNodeId];
+        if (!instance || String(instance.definitionId || "") !== "workspace_scheduled_run") {
+          json(res, 404, { error: "Workspace schedule node not found" });
+          return;
+        }
+        const current = normalizeWorkspaceScheduledRunConfig(instance.body || "");
+        const config = {
+          ...current,
+          ...(typeof payload.enabled === "boolean" ? { enabled: payload.enabled } : {}),
+          ...(payload.cron != null ? { cron: String(payload.cron).trim() } : {}),
+          ...(payload.timezone != null ? { timezone: String(payload.timezone).trim() } : {}),
+          ...(payload.overlapPolicy != null ? { overlapPolicy: String(payload.overlapPolicy).trim() } : {}),
+        };
+        if (config.overlapPolicy !== "skip") {
+          json(res, 400, { error: "Only overlapPolicy=skip is supported" });
+          return;
+        }
+        if (config.enabled) workspaceScheduleNextRunAt(config, new Date());
+        graph.instances = { ...(graph.instances || {}) };
+        graph.instances[scheduleNodeId] = { ...instance, body: JSON.stringify(config) };
+        const committed = commitWorkspaceGraph(root, scoped, graph, userCtx);
+        const workspaceSchedules = syncWorkspaceSchedulesForGraph(root, scoped, committed.graph, authUser, userCtx);
+        const schedule = workspaceSchedules.find((item) => item.scheduleNodeId === scheduleNodeId) || {
+          flowId,
+          flowSource,
+          scheduleNodeId,
+          ...config,
+          suppressed: scoped.draft === true,
+        };
+        json(res, 200, {
+          ok: true,
+          flowId,
+          flowSource,
+          draft: scoped.draft === true,
+          revision: committed.revision,
+          schedule,
+          workspaceSchedules,
+        });
+      } catch (e) {
+        json(res, 400, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "POST" && url.pathname === "/api/workspace/run/plan") {
       let payload;
       try {
@@ -1865,6 +2332,8 @@ async function workspaceRoutes(req, res, ctx) {
           flowSource: scoped.flowSource || payload.flowSource || "user",
           plannedNodeIds,
           startedAt: Date.now(),
+          workspaceRoot: root,
+          marketplaceResources: marketplaceResourcesForRun(scoped.root, runtimeGraph, plannedNodeIds),
         };
         const runLog = createWorkspaceRunLogSession({
           runId,
@@ -1962,6 +2431,7 @@ async function workspaceRoutes(req, res, ctx) {
               ...runEntry,
               endedAt,
               durationMs: endedAt - runEntry.startedAt,
+              marketplaceResources: marketplaceResourcesForRun(scoped.root, runtimeGraph, result.order || Array.from(touchedIds)),
             }, "success");
             finishWorkspaceRunLogSession(runLog.runId, "success", {
               endedAt,
@@ -2057,6 +2527,7 @@ async function workspaceRoutes(req, res, ctx) {
             ...runEntry,
             endedAt,
             durationMs: endedAt - runEntry.startedAt,
+            marketplaceResources: marketplaceResourcesForRun(scoped.root, runtimeGraph, result.order || Array.from(touchedIds)),
           }, "success");
           finishWorkspaceRunLogSession(runLog.runId, "success", {
             endedAt,
@@ -2281,6 +2752,11 @@ async function workspaceRoutes(req, res, ctx) {
           return;
         }
         removeWorkspaceDeferredRun(deferred.key);
+        const resourceCleanup = cleanupWorkspaceRunResources(scoped.root, deferred.runId, {
+          force: false,
+          status: "stopped",
+          emit: (event) => appendWorkspaceRunLogEvent(deferred.runId, event),
+        });
         const endedAt = Date.now();
         appendWorkspaceRunLogEvent(deferred.runId, {
           type: "stop-completed",
@@ -2309,6 +2785,10 @@ async function workspaceRoutes(req, res, ctx) {
           ok: true,
           stopped: true,
           monitoringOnly: true,
+          resources: {
+            cleaned: resourceCleanup.cleaned,
+            preserved: resourceCleanup.preserved,
+          },
         });
         return;
       }