@fieldwangai/agentflow 0.1.162 → 0.1.164

package/bin/lib/workspace-routes.mjs

@@ -17,12 +17,23 @@ import { buildSkillCompactInjectionBlock, loadResourcesForSkillKeys } from "./co
 import { execFileBuffered } from "./exec-buffered.mjs";
 import { runGit } from "./git-worktree.mjs";
 import {
+  listMarketplaceFlowSnippets,
+  listMarketplaceFlows,
   listMarketplacePackages,
   nodePackageArchive,
+  publishMarketplaceFlow,
   publishNodePackage,
   publishNodePackageArchive,
+  readMarketplaceFlow,
   resolveMarketplaceNodePackage,
+  setMarketplaceVisibility,
 } from "./marketplace.mjs";
+import {
+  appendMarketplaceUsageEvent,
+  marketplaceResourcesForRun,
+  readMarketplaceFlowOrigin,
+  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";
@@ -38,8 +49,8 @@ import { mergeWorkspaceGraphs, workspaceDesignRevision, workspaceRuntimeRevision
 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, 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 { WORKSPACE_STATE_FILENAME } from "./workspace-state.mjs";
+import { activeWorkspaceRuns, appendWorkspaceRunFinished, appendWorkspaceRunStarted, cleanupWorkspaceRunResources, hydrateWorkspaceGraphForRuntime, isReadonlyBuiltinFlowSource, isTransientAgentNetworkError, isValidFlowSourceRead, isWorkspaceRunAbortError, listWorkspaceScheduleStatusesForFlow, mergeWorkspacePersistentNodeRefs, mergeWorkspaceRunGraph, normalizeWorkspaceEntry, normalizeWorkspaceScheduledRunConfig, publishWorkspaceRelease, readWorkspaceConversations, readWorkspaceFiles, readWorkspaceGraph, readWorkspaceReleaseStatus, removeWorkspaceDeferredRun, resolveWorkspaceFilePath, resolveWorkspaceScopeRoot, rollbackWorkspaceRelease, 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";
@@ -899,6 +910,45 @@ function workspaceBufferLooksLikeZip(buf) {
   );
 }
 
+function installedMarketplaceFlowCopies(userId) {
+  const copies = new Map();
+  const pipelinesRoot = getUserPipelinesRoot(userId);
+  if (!fs.existsSync(pipelinesRoot)) return copies;
+  for (const entry of fs.readdirSync(pipelinesRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const origin = readMarketplaceFlowOrigin(path.join(pipelinesRoot, entry.name));
+    if (!origin) continue;
+    const key = `${origin.id}@${origin.version}`;
+    const flowIds = copies.get(key) || [];
+    flowIds.push(entry.name);
+    copies.set(key, flowIds);
+  }
+  return copies;
+}
+
+function marketplaceResourceMatches(item, queryText) {
+  if (!queryText) return true;
+  return [
+    item.id,
+    item.definitionId,
+    item.displayName,
+    item.description,
+    item.ownerUserId,
+    item.source,
+    ...(Array.isArray(item.tags) ? item.tags : []),
+  ].filter(Boolean).join("\n").toLowerCase().includes(queryText);
+}
+
+function sortMarketplaceResources(items) {
+  return items.sort((a, b) => (
+    Number(b.useCount || 0) - Number(a.useCount || 0)
+    || Number(b.installCount || 0) - Number(a.installCount || 0)
+    || String(b.updatedAt || b.createdAt || "").localeCompare(String(a.updatedAt || a.createdAt || ""))
+    || String(a.displayName || a.id).localeCompare(String(b.displayName || b.id))
+    || String(b.version || "").localeCompare(String(a.version || ""), undefined, { numeric: true, sensitivity: "base" })
+  ));
+}
+
 /**
  * @param {import('http').IncomingMessage} req
  * @param {import('http').ServerResponse} res
@@ -921,6 +971,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,
@@ -980,6 +1035,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,
@@ -995,6 +1058,199 @@ 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 requestedScope = String(url.searchParams.get("scope") || "all").trim();
+        const scope = ["all", "owned", "installed"].includes(requestedScope) ? requestedScope : "all";
+        const marketplaceScope = scope === "owned" ? "owned" : "all";
+        const queryText = String(url.searchParams.get("q") || "").trim().toLowerCase();
+        if (kind === "node") {
+          const marketplaceNodes = listMarketplacePackages(root, { ...userCtx, marketplaceScope }).nodes
+            .map((node) => ({ ...node, resourceType: "node", installed: true }));
+          let nodes = marketplaceNodes;
+          if (scope === "installed") {
+            const marketplaceByDefinition = new Map(marketplaceNodes.map((node) => [node.definitionId, node]));
+            nodes = listNodesJson(root, "", "", { ...userCtx, marketplaceScope: "all" }).nodes.map((node) => {
+              const marketplaceNode = marketplaceByDefinition.get(node.id);
+              if (marketplaceNode) {
+                return {
+                  ...marketplaceNode,
+                  definitionId: node.id,
+                  source: node.source || "marketplace",
+                  installed: true,
+                };
+              }
+              return {
+                id: node.packageId || node.id,
+                version: node.version || "",
+                definitionId: node.id,
+                displayName: node.displayName || node.label || node.id,
+                description: node.description || "",
+                inputs: node.inputs || {},
+                outputs: node.outputs || {},
+                source: node.source || "project",
+                resourceType: "node",
+                localCatalog: true,
+                installed: true,
+              };
+            });
+          }
+          nodes = sortMarketplaceResources(nodes.filter((item) => marketplaceResourceMatches(item, queryText)));
+          json(res, 200, { kind, scope, sort: "useCount", order: "desc", items: nodes });
+          return;
+        }
+        if (kind !== "flow") {
+          json(res, 400, { error: "kind must be flow or node" });
+          return;
+        }
+        const installedCopies = installedMarketplaceFlowCopies(userCtx.userId);
+        const flows = listMarketplaceFlows(root, { ...userCtx, marketplaceScope }).flows.map((flow) => {
+          const installedFlowIds = installedCopies.get(`${flow.id}@${flow.version}`) || [];
+          return {
+            ...flow,
+            resourceType: "flow",
+            installed: installedFlowIds.length > 0,
+            installedFlowIds,
+          };
+        });
+        const snippets = scope === "installed" ? [] : listMarketplaceFlowSnippets(root, { ...userCtx, marketplaceScope }).snippets
+          .map((snippet) => ({ ...snippet, resourceType: "flow-snippet", installed: false }));
+        const items = sortMarketplaceResources(
+          [...flows, ...snippets]
+            .filter((item) => scope !== "installed" || item.installed)
+            .filter((item) => marketplaceResourceMatches(item, queryText)),
+        );
+        json(res, 200, { kind, scope, sort: "useCount", order: "desc", items });
+      } 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));
@@ -1416,7 +1672,7 @@ async function workspaceRoutes(req, res, ctx) {
         const written = writeWorkspaceGraph(flowDir, graph, root);
         writeWorkspaceDraftMetadata(flowDir, metadata);
         const persisted = readWorkspaceGraph(flowDir, root).graph;
-        const baseUrl = `${url.protocol}//${url.host}`;
+        const baseUrl = requestPublicBaseUrl(req);
         json(res, 200, {
           ok: true,
           flowId,
@@ -1489,7 +1745,7 @@ async function workspaceRoutes(req, res, ctx) {
           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}`;
+          const baseUrl = requestPublicBaseUrl(req);
           json(res, 200, {
             ok: true,
             success: true,
@@ -1578,7 +1834,7 @@ async function workspaceRoutes(req, res, ctx) {
         json(res, 500, { error: (e && e.message) || String(e) });
         return;
       }
-      const baseUrl = `${url.protocol}//${url.host}`;
+      const baseUrl = requestPublicBaseUrl(req);
       const workspaceUrl = `${baseUrl}/workspace?flowId=${encodeURIComponent(flowId)}&flowSource=workspace&archived=1`;
       json(res, 200, { ok: true, flowId, flowSource: "workspace", archived: true, preview: true, expiresAt: metadata.expiresAt, url: workspaceUrl });
       return;
@@ -1690,6 +1946,7 @@ async function workspaceRoutes(req, res, ctx) {
             ownerUserId: scoped.ownerUserId,
             ownerUsername: scoped.ownerUsername,
           } : null,
+          release: readWorkspaceReleaseStatus(scoped.root, root, hydratedGraph),
           workspaceSchedules: listWorkspaceScheduleStatusesForFlow(scopedUserCtx, scoped.flowSource || "user", scoped.flowId || ""),
         });
       } catch (e) {
@@ -1704,6 +1961,126 @@ async function workspaceRoutes(req, res, ctx) {
       return;
     }
 
+    if (req.method === "GET" && url.pathname === "/api/workspace/releases") {
+      try {
+        const scoped = resolveWorkspaceScopeRoot(root, {
+          flowId: url.searchParams.get("flowId") || "",
+          flowSource: url.searchParams.get("flowSource") || "user",
+          workspaceId: url.searchParams.get("workspaceId") || "",
+          adminOwnerId: url.searchParams.get("adminOwnerId") || "",
+          archived: url.searchParams.get("archived") === "1",
+        }, userCtx);
+        if (scoped.error) {
+          json(res, scoped.status || 400, { error: scoped.error });
+          return;
+        }
+        json(res, 200, { ok: true, release: readWorkspaceReleaseStatus(scoped.root, root) });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/workspace/releases/publish") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      try {
+        const scoped = resolveWorkspaceScopeRoot(root, {
+          flowId: payload.flowId || "",
+          flowSource: payload.flowSource || "user",
+          workspaceId: payload.workspaceId || "",
+          archived: payload.archived === true || payload.flowArchived === true,
+        }, userCtx);
+        if (scoped.error) {
+          json(res, scoped.status || 400, { error: scoped.error });
+          return;
+        }
+        if (
+          scoped.archived
+          || scoped.draft === true
+          || isReadonlyBuiltinFlowSource(scoped.flowSource)
+          || scoped.collaborationAccess?.writable === false
+        ) {
+          json(res, 403, { error: "Workspace release publish permission denied" });
+          return;
+        }
+        const result = publishWorkspaceRelease(scoped.root, root, {
+          expectedRevision: payload.expectedRevision || "",
+          createdBy: userCtx.userId || authUser?.userId || "",
+          notes: payload.notes || "",
+        });
+        if (result.error) {
+          json(res, result.conflict ? 409 : 400, result);
+          return;
+        }
+        const graph = readWorkspaceGraph(scoped.root, root).graph;
+        const workspaceSchedules = syncWorkspaceSchedulesForGraph(root, scoped, graph, authUser, userCtx);
+        broadcastWorkspaceCollaborationEvent(userCtx, scoped.flowSource, scoped.flowId, scoped.archived, {
+          type: "release.published",
+          releaseId: result.release.id,
+          revision: result.release.designRevision,
+          actorId: userCtx.userId || "",
+        });
+        json(res, 200, { ...result, workspaceSchedules });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
+    if (req.method === "POST" && url.pathname === "/api/workspace/releases/rollback") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      try {
+        const scoped = resolveWorkspaceScopeRoot(root, {
+          flowId: payload.flowId || "",
+          flowSource: payload.flowSource || "user",
+          workspaceId: payload.workspaceId || "",
+          archived: payload.archived === true || payload.flowArchived === true,
+        }, userCtx);
+        if (scoped.error) {
+          json(res, scoped.status || 400, { error: scoped.error });
+          return;
+        }
+        if (
+          scoped.archived
+          || scoped.draft === true
+          || isReadonlyBuiltinFlowSource(scoped.flowSource)
+          || scoped.collaborationAccess?.writable === false
+        ) {
+          json(res, 403, { error: "Workspace release rollback permission denied" });
+          return;
+        }
+        const result = rollbackWorkspaceRelease(scoped.root, payload.releaseId || "", root);
+        if (result.error) {
+          json(res, 404, result);
+          return;
+        }
+        const graph = readWorkspaceGraph(scoped.root, root).graph;
+        const workspaceSchedules = syncWorkspaceSchedulesForGraph(root, scoped, graph, authUser, userCtx);
+        broadcastWorkspaceCollaborationEvent(userCtx, scoped.flowSource, scoped.flowId, scoped.archived, {
+          type: "release.rollback",
+          releaseId: result.release.id,
+          revision: result.release.designRevision,
+          actorId: userCtx.userId || "",
+        });
+        json(res, 200, { ...result, workspaceSchedules });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "POST" && url.pathname === "/api/workspace/graph") {
       let payload;
       try {
@@ -1836,6 +2213,7 @@ async function workspaceRoutes(req, res, ctx) {
           designRevision: revision,
           runtimeRevision,
           merged,
+          release: readWorkspaceReleaseStatus(scoped.root, root, committed.graph),
           workspaceSchedules,
         });
       } catch (e) {
@@ -2158,6 +2536,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,
@@ -2255,6 +2635,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,
@@ -2350,6 +2731,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,
@@ -2574,6 +2956,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",
@@ -2602,6 +2989,10 @@ async function workspaceRoutes(req, res, ctx) {
           ok: true,
           stopped: true,
           monitoringOnly: true,
+          resources: {
+            cleaned: resourceCleanup.cleaned,
+            preserved: resourceCleanup.preserved,
+          },
         });
         return;
       }

package/bin/lib/workspace-run-logs.mjs

@@ -90,6 +90,8 @@ function indexRecord(meta = {}, patch = {}) {
     flowSource: String(meta.flowSource || "user"),
     scheduleNodeId: String(meta.scheduleNodeId || ""),
     runNodeId: String(meta.runNodeId || ""),
+    releaseId: String(meta.releaseId || ""),
+    designRevision: String(meta.designRevision || ""),
     scheduled: meta.scheduled === true,
     trigger: String(meta.trigger || (meta.scheduled === true ? "scheduled" : "manual")),
     label: String(meta.label || ""),