+
**Agent 节点自动路由**
event.stopPropagation()}
+ onClick={(event) => event.stopPropagation()}
+ >
+
+
+
+ )
+}
diff --git a/frontend/components/flow/workflow-agent-proposal.ts b/frontend/components/flow/workflow-agent-proposal.ts
new file mode 100644
index 0000000..53e1825
--- /dev/null
+++ b/frontend/components/flow/workflow-agent-proposal.ts
@@ -0,0 +1,78 @@
+import { useCallback, useEffect, useState, type Dispatch, type SetStateAction } from "react"
+
+import { useFlowStore } from "@/lib/flow/store"
+import { acceptAgentProposal, type AgentProposal } from "@/lib/workflow/proposal"
+import type { ProposalFocusTarget } from "@/lib/workflow/proposal-focus"
+
+type FitView = (options?: { padding?: number; duration?: number; nodes?: { id: string }[] }) => unknown
+
+export function useWorkflowAgentProposal(options: {
+ clearPendingAgentProposal: () => void
+ clearProposalFocus: () => void
+ fitView: FitView
+ focusProposalTargets: (nodeIds: string[], edgeIds: string[]) => void
+ importWorkflowProject: (project: ReturnType
+ DOP Operators
+
+
+ {dopNodeMenuItems.map((item) => {
+ const text = localizeNodeText(item.id, { label: item.label, description: item.description }, language)
+ const visual = getNodeVisualSignature({
+ label: item.label,
+ description: item.description,
+ nodeType: item.kind === "router" ? "condition" : item.kind === "schedule" ? "trigger" : item.kind === "source" ? "http" : "action",
+ category: item.category === "decision" ? "logic" : item.category === "trigger" ? "trigger" : item.category === "source" ? "data" : item.category === "output" ? "action" : "action",
+ icon: item.icon,
+ canonical: { catalogId: item.id, kind: item.kind, capability: item.capability },
+ })
+ return (
+
+ )
+ })}
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Add Internal Primitive
+ ›
+
+
+ {primitiveMenuGroups.map((group) => (
+
+
+
+ ))}
+
+ {group.label}
+ ›
+
+
+ {group.items.map((item, itemIndex) => {
+ const text = localizeNodeText(item.id, { label: item.label, description: item.description }, language)
+ const runtimeCapability = primitiveRuntimeCapability(capabilities, item.id)
+ const visual = getNodeVisualSignature({
+ label: item.label,
+ description: item.description,
+ nodeType: item.nodeType,
+ category: item.nodeCategory,
+ icon: item.icon,
+ primitiveId: item.id,
+ primitiveCategory: item.category,
+ })
+ return (
+
+ )
+ })}
+
+ Help...
+
+
+
+
+ props.setNodeManagementOpen(false)}
+ onProfileChange={props.onProfileChange}
+ projectSettingsOpen={props.projectSettingsOpen}
+ runTraceOpen={props.runTraceOpen}
+ settingsOpen={props.settingsOpen}
+ workflowProfile={props.workflowProfile}
+ />
+
+ props.setAgentDrawerOpen(false)}
+ />
+
+
+ )
+}
diff --git a/frontend/components/flow/workflow-editor-effects.ts b/frontend/components/flow/workflow-editor-effects.ts
new file mode 100644
index 0000000..c670b66
--- /dev/null
+++ b/frontend/components/flow/workflow-editor-effects.ts
@@ -0,0 +1,106 @@
+"use client"
+
+import { useCallback, useEffect, type Dispatch, type SetStateAction } from "react"
+
+import { useFlowStore } from "@/lib/flow/store"
+import { loadShareStateFromUrl } from "@/lib/flow/share-state"
+import type { WorkflowCapabilitiesResponse } from "@/lib/workflow/capabilities"
+import type { WorkflowNode } from "@/lib/flow/types"
+import type { NodeMenuState } from "./workflow-node-menu-actions"
+
+type FitView = (options?: { padding?: number; duration?: number; nodes?: { id: string }[] }) => unknown
+type ShowToast = (message: string) => void
+
+export function isNetworkLocked(networkStack: { nodeId: string; label: string }[], nodes: WorkflowNode[]) {
+ return networkStack.length > 0 && nodes.some((node) => node.data.internalLocked === true)
+}
+
+export function useApplyWorkflowCapabilities(options: {
+ applyWorkflowCapabilities: (capabilities: WorkflowCapabilitiesResponse) => void
+ capabilities: WorkflowCapabilitiesResponse | null | undefined
+ workflowProjectId: string
+}) {
+ const { applyWorkflowCapabilities, capabilities, workflowProjectId } = options
+ useEffect(() => {
+ if (capabilities) applyWorkflowCapabilities(capabilities)
+ }, [applyWorkflowCapabilities, capabilities, workflowProjectId])
+}
+
+export function useSharedWorkflowImport(options: {
+ fitView: FitView
+ showToast: ShowToast
+}) {
+ const { fitView, showToast } = options
+ useEffect(() => {
+ if (typeof window === "undefined") return
+ const shared = loadShareStateFromUrl(window.location.href)
+ if (!shared) return
+ useFlowStore.setState({
+ workflowProject: shared.workflowProject,
+ nodes: shared.nodes,
+ edges: shared.edges,
+ drawings: shared.drawings ?? [],
+ networkStack: [],
+ helperLines: { snapPosition: {} },
+ })
+ showToast("已从分享 URL 恢复 workflow")
+ window.setTimeout(() => void fitView({ padding: 0.24, duration: 220 }), 30)
+ }, [fitView, showToast])
+}
+
+export function useAutoDismissToast(toast: string | null, setToast: Dispatch
+
+ /
+ obj
+ {networkStack.map((entry) => (
+
+ /
+ {entry.label}
+
+ ))}
+
+ {locked ? "LOCKED" : "DRAFT"}
+
+ Esc / Backspace
+
+ )
+}
+
+export function WorkflowFloatingPanels({
+ inspectorOpen,
+ nodeManagementOpen,
+ onCloseNodeManagement,
+ onProfileChange,
+ projectSettingsOpen,
+ runTraceOpen,
+ settingsOpen,
+ workflowProfile,
+}: {
+ inspectorOpen: boolean
+ nodeManagementOpen: boolean
+ onCloseNodeManagement: () => void
+ onProfileChange: (profile: WorkflowProfile) => void
+ projectSettingsOpen: boolean
+ runTraceOpen: boolean
+ settingsOpen: boolean
+ workflowProfile: WorkflowProfile
+}) {
+ return (
+ <>
+ {runTraceOpen ? (
+
+
+ ) : null}
+
+ {nodeManagementOpen ?
+
+ ) : settingsOpen ? (
+
+
+ ) : inspectorOpen ? (
+
+
+ ) : null}
+
+ )
+}
+
+export function WorkflowToast({ message }: { message: string | null }) {
+ if (!message) return null
+ return (
+
+ {message}
+
+ )
+}
diff --git a/frontend/components/flow/workflow-editor-selectors.ts b/frontend/components/flow/workflow-editor-selectors.ts
new file mode 100644
index 0000000..abed9de
--- /dev/null
+++ b/frontend/components/flow/workflow-editor-selectors.ts
@@ -0,0 +1,49 @@
+import type { FlowState } from "@/lib/flow/store"
+
+export function selectEditorCanvasState(state: FlowState) {
+ return {
+ addNodeFromPalette: state.addNodeFromPalette,
+ addPrimitiveNode: state.addPrimitiveNode,
+ addWorkflowNodeFromCatalog: state.addWorkflowNodeFromCatalog,
+ applyWorkflowCapabilities: state.applyWorkflowCapabilities,
+ attachToParent: state.attachToParent,
+ autoLayout: state.autoLayout,
+ clearHelperLines: state.clearHelperLines,
+ clearPendingAgentProposal: state.clearPendingAgentProposal,
+ clearProposalFocus: state.clearProposalFocus,
+ copy: state.copy,
+ cut: state.cut,
+ deleteSelected: state.deleteSelected,
+ detachFromParent: state.detachFromParent,
+ disconnectNodeConnections: state.disconnectNodeConnections,
+ duplicate: state.duplicateSelected,
+ edges: state.edges,
+ enterNodeNetwork: state.enterNodeNetwork,
+ exitNodeNetwork: state.exitNodeNetwork,
+ focusProposalTargets: state.focusProposalTargets,
+ groupSelection: state.groupSelection,
+ helperLines: state.helperLines,
+ importWorkflowProject: state.importWorkflowProject,
+ lockNodeInternals: state.lockNodeInternals,
+ networkStack: state.networkStack,
+ nodes: state.nodes,
+ onConnect: state.onConnect,
+ onEdgesChange: state.onEdgesChange,
+ onNodesChange: state.onNodesChange,
+ paste: state.paste,
+ pendingAgentProposal: state.pendingAgentProposal,
+ redo: state.redo,
+ removeEdgesByIds: state.removeEdgesByIds,
+ resizeGroupToFit: state.resizeGroupToFit,
+ resolveNodeCollisions: state.resolveNodeCollisions,
+ save: state.save,
+ selectConnectedComponent: state.selectConnectedComponent,
+ setToolMode: state.setToolMode,
+ takeSnapshot: state.takeSnapshot,
+ toolMode: state.toolMode,
+ undo: state.undo,
+ unlockNodeInternals: state.unlockNodeInternals,
+ updateWorkflowProfile: state.updateWorkflowProfile,
+ workflowProject: state.workflowProject,
+ }
+}
diff --git a/frontend/components/flow/workflow-editor.tsx b/frontend/components/flow/workflow-editor.tsx
index 4d2b608..6d7ed27 100644
--- a/frontend/components/flow/workflow-editor.tsx
+++ b/frontend/components/flow/workflow-editor.tsx
@@ -1,175 +1,94 @@
"use client"
-import { useCallback, useEffect, useMemo, useRef, useState, type DragEvent, type MouseEvent as ReactMouseEvent } from "react"
-import {
- ReactFlow,
- ReactFlowProvider,
- Background,
- BackgroundVariant,
- Controls,
- MiniMap,
- SelectionMode,
- useReactFlow,
- useStore,
- type IsValidConnection,
- type Node,
- type OnBeforeDelete,
- type OnNodeDrag,
-} from "@xyflow/react"
+import { useCallback, useMemo, useRef, useState, type MouseEvent as ReactMouseEvent } from "react"
+import { ReactFlowProvider, useReactFlow, type NodeMouseHandler } from "@xyflow/react"
import "@xyflow/react/dist/style.css"
import { useFlowStore } from "@/lib/flow/store"
import { useSettingsStore } from "@/lib/flow/settings-store"
-import { validateConnection } from "@/lib/flow/graph"
-import type { PaletteItem, WorkflowNode, WorkflowEdge, ToolMode } from "@/lib/flow/types"
-import { Inspector } from "./inspector"
+import type { WorkflowNode, WorkflowEdge, ToolMode } from "@/lib/flow/types"
import { CommandStrip } from "./command-strip"
import { CommandPalette } from "./command-palette"
-import { HelperLinesRenderer } from "./helper-lines-renderer"
-import { WorkflowMotionRuntime } from "./workflow-motion-runtime"
-import { DrawingLayer } from "./drawing-layer"
-import { Collaboration } from "./collaboration"
-import WorkflowNodeComp from "./nodes/workflow-node"
-import NoteNode from "./nodes/note-node"
-import GroupNode from "./nodes/group-node"
-import ShapeNode from "./nodes/shape-node"
-import MathNode from "./nodes/math-node"
-import WorkflowEdge_ from "./edges/workflow-edge"
-import EditableEdge from "./edges/editable-edge"
-import RoutedEdge from "./edges/routed-edge"
-import { InteractionSettingsPanel } from "./interaction-settings-panel"
-import { ProjectSettingsPanel } from "./project-settings-panel"
-import { RunTracePanel } from "./run-trace-panel"
-import { AgentDrawer } from "./agent-drawer"
-import { NodeManagementPanel } from "./node-management-panel"
-import { acceptAgentProposal, type AgentProposal } from "@/lib/workflow/proposal"
-import type { ProposalFocusTarget } from "@/lib/workflow/proposal-focus"
-import { getWorkflowNodeCatalog, type WorkflowNodeCatalogItem } from "@/lib/workflow/node-catalog"
-import { getWorkflowPrimitives, type WorkflowPrimitive } from "@/lib/workflow/node-primitives"
+import { getWorkflowNodeCatalog } from "@/lib/workflow/node-catalog"
+import { getWorkflowPrimitives } from "@/lib/workflow/node-primitives"
import { groupPrimitivesForNodeMenu } from "@/lib/workflow/node-menu"
-import { localizeNodeText } from "@/lib/workflow/node-i18n"
-import { getNodeVisualSignature } from "@/lib/workflow/node-visuals"
-import { primitiveRuntimeCapability, runtimeStatusLabel, runtimeStatusTone } from "@/lib/workflow/capabilities"
import { useWorkflowCapabilities } from "@/lib/workflow/use-workflow-capabilities"
-import { loadShareStateFromUrl } from "@/lib/flow/share-state"
-import { cn } from "@/lib/utils"
-
-const nodeTypes = {
- workflow: WorkflowNodeComp,
- note: NoteNode,
- group: GroupNode,
- shape: ShapeNode,
- math: MathNode,
-}
-
-const edgeTypes = {
- workflow: WorkflowEdge_,
- editable: EditableEdge,
- routed: RoutedEdge,
-}
-
-type ShakeState = {
- lastX: number
- lastDirection: -1 | 0 | 1
- turns: number
- disconnected: boolean
-}
-
-function distance(a: { x: number; y: number }, b: { x: number; y: number }) {
- return Math.hypot(a.x - b.x, a.y - b.y)
-}
-
-function edgeIdsAtScreenPoint(point: { x: number; y: number }, threshold = 10): string[] {
- const hits: string[] = []
- const edges = document.querySelectorAll
@@ -719,12 +248,7 @@ function EditorCanvas() {
onOpenPalette={() => setPaletteOpen(true)}
onExported={showToast}
collab={settings.collabProvider !== "off"}
- onToggleCollab={() =>
- settings.set(
- "collabProvider",
- settings.collabProvider === "off" ? "yjs" : "off",
- )
- }
+ onToggleCollab={toggleCollabProvider}
settingsOpen={settingsOpen}
onToggleSettings={() => setSettingsOpen((v) => !v)}
projectSettingsOpen={projectSettingsOpen}
@@ -737,328 +261,66 @@ function EditorCanvas() {
onToggleNodeManagement={() => setNodeManagementOpen((v) => !v)}
/>
= { current: T }
+type SetOpen = Dispatch>
+
+type WorkflowKeyboardShortcutOptions = {
+ autoLayout: (direction: "TB", engine: "elk", animated: boolean) => Promise
+ copy: () => void
+ cut: () => void
+ deleteSelected: () => void
+ duplicate: () => void
+ exitNodeNetwork: () => boolean
+ fitView: (options?: { padding?: number; duration?: number }) => unknown
+ groupSelection: () => void
+ mousePosRef: WritableRef
+ paste: (position?: Point) => void
+ projectSettingsOpen: boolean
+ redo: () => void
+ save: () => void
+ screenToFlowPosition: (position: Point) => Point
+ scissorCutRef: WritableRef>
+ scissorDraggingRef: WritableRef
+ setInspectorOpen: SetOpen
+ setPaletteOpen: SetOpen
+ setProjectSettingsOpen: SetOpen
+ setScissorTrail: Dispatch>
+ setSettingsOpen: SetOpen
+ setToolMode: (mode: ToolMode) => void
+ setMiniMapVisible: (visible: boolean) => void
+ settingsOpen: boolean
+ showToast: (message: string) => void
+ undo: () => void
+ yMomentaryModeRef: WritableRef
+}
+
+function isEditableTarget(target: EventTarget | null) {
+ const element = target as HTMLElement | null
+ if (!element) return false
+ return element.tagName === "INPUT" || element.tagName === "TEXTAREA" || element.isContentEditable
+}
+
+export function useWorkflowKeyboardShortcuts({
+ autoLayout,
+ copy,
+ cut,
+ deleteSelected,
+ duplicate,
+ exitNodeNetwork,
+ fitView,
+ groupSelection,
+ mousePosRef,
+ paste,
+ projectSettingsOpen,
+ redo,
+ save,
+ screenToFlowPosition,
+ scissorCutRef,
+ scissorDraggingRef,
+ setInspectorOpen,
+ setPaletteOpen,
+ setProjectSettingsOpen,
+ setScissorTrail,
+ setSettingsOpen,
+ setToolMode,
+ setMiniMapVisible,
+ settingsOpen,
+ showToast,
+ undo,
+ yMomentaryModeRef,
+}: WorkflowKeyboardShortcutOptions) {
+ useEffect(() => {
+ const onKeyDown = (event: KeyboardEvent) => {
+ const mod = event.metaKey || event.ctrlKey
+ const key = event.key.toLowerCase()
+
+ if (mod && key === "k") {
+ event.preventDefault()
+ setPaletteOpen((open) => !open)
+ return
+ }
+ if (isEditableTarget(event.target)) return
+
+ if (!mod && (event.key === "Tab" || key === "b")) {
+ event.preventDefault()
+ setPaletteOpen(true)
+ return
+ }
+
+ if (mod && key === "s") {
+ event.preventDefault()
+ save()
+ showToast("已保存到本地")
+ } else if (mod && key === "z" && !event.shiftKey) {
+ event.preventDefault()
+ undo()
+ } else if (mod && (key === "y" || (key === "z" && event.shiftKey))) {
+ event.preventDefault()
+ redo()
+ } else if (mod && key === "c") {
+ copy()
+ } else if (mod && key === "v") {
+ event.preventDefault()
+ paste(screenToFlowPosition(mousePosRef.current))
+ } else if (mod && key === "x") {
+ cut()
+ } else if (mod && key === "d") {
+ event.preventDefault()
+ duplicate()
+ } else if (mod && key === "g") {
+ event.preventDefault()
+ groupSelection()
+ } else if (!mod && key === "o") {
+ event.preventDefault()
+ const next = !useSettingsStore.getState().showMiniMap
+ setMiniMapVisible(next)
+ showToast(next ? "节点缩略图已显示" : "节点缩略图已隐藏")
+ } else if (!mod && key === "p") {
+ event.preventDefault()
+ if (settingsOpen || projectSettingsOpen) {
+ setSettingsOpen(false)
+ setProjectSettingsOpen(false)
+ setInspectorOpen(true)
+ showToast("Parameter Interface 已显示")
+ return
+ }
+ setInspectorOpen((open) => {
+ const next = !open
+ showToast(next ? "Parameter Interface 已显示" : "Parameter Interface 已隐藏")
+ return next
+ })
+ } else if (!mod && key === "h") {
+ event.preventDefault()
+ if (useFlowStore.getState().nodes.length === 0) return
+ void fitView({ padding: 0.24, duration: 220 })
+ showToast("已显示全部节点")
+ } else if (!mod && key === "l") {
+ event.preventDefault()
+ if (useFlowStore.getState().nodes.length === 0) return
+ showToast("正在自动排布节点")
+ void autoLayout("TB", "elk", true).then(() => {
+ showToast("已自动排布整体节点")
+ window.setTimeout(() => void fitView({ padding: 0.24, duration: 260 }), 30)
+ })
+ } else if (!mod && (event.key === "Escape" || event.key === "Backspace") && useFlowStore.getState().networkStack.length > 0) {
+ event.preventDefault()
+ if (exitNodeNetwork()) {
+ showToast("已返回上一层 Network")
+ window.setTimeout(() => void fitView({ padding: 0.24, duration: 180 }), 20)
+ }
+ } else if (!mod && key === "y") {
+ event.preventDefault()
+ if (event.repeat) return
+ yMomentaryModeRef.current = useFlowStore.getState().toolMode
+ setToolMode("scissors")
+ } else if (event.key === "Delete" || event.key === "Backspace") {
+ deleteSelected()
+ }
+ }
+
+ const onKeyUp = (event: KeyboardEvent) => {
+ if (isEditableTarget(event.target)) return
+ if (event.metaKey || event.ctrlKey || event.key.toLowerCase() !== "y") return
+ if (yMomentaryModeRef.current === null) return
+ event.preventDefault()
+ const restoreMode = yMomentaryModeRef.current
+ yMomentaryModeRef.current = null
+ scissorDraggingRef.current = false
+ scissorCutRef.current = new Set()
+ setScissorTrail([])
+ setToolMode(restoreMode)
+ }
+
+ window.addEventListener("keydown", onKeyDown)
+ window.addEventListener("keyup", onKeyUp)
+ return () => {
+ window.removeEventListener("keydown", onKeyDown)
+ window.removeEventListener("keyup", onKeyUp)
+ }
+ }, [
+ autoLayout,
+ copy,
+ cut,
+ deleteSelected,
+ duplicate,
+ exitNodeNetwork,
+ fitView,
+ groupSelection,
+ mousePosRef,
+ paste,
+ projectSettingsOpen,
+ redo,
+ save,
+ screenToFlowPosition,
+ scissorCutRef,
+ scissorDraggingRef,
+ setInspectorOpen,
+ setPaletteOpen,
+ setProjectSettingsOpen,
+ setScissorTrail,
+ setSettingsOpen,
+ setToolMode,
+ setMiniMapVisible,
+ settingsOpen,
+ showToast,
+ undo,
+ yMomentaryModeRef,
+ ])
+}
diff --git a/frontend/components/flow/workflow-node-menu-actions.ts b/frontend/components/flow/workflow-node-menu-actions.ts
new file mode 100644
index 0000000..1927349
--- /dev/null
+++ b/frontend/components/flow/workflow-node-menu-actions.ts
@@ -0,0 +1,143 @@
+import { useCallback, type Dispatch, type SetStateAction } from "react"
+
+import { useFlowStore } from "@/lib/flow/store"
+import { primitiveRuntimeCapability, type WorkflowCapabilitiesResponse } from "@/lib/workflow/capabilities"
+import { localizeNodeText, type WorkflowLanguage } from "@/lib/workflow/node-i18n"
+import type { WorkflowNodeCatalogItem } from "@/lib/workflow/node-catalog"
+import type { WorkflowPrimitive } from "@/lib/workflow/node-primitives"
+import type { CanvasPoint } from "./workflow-canvas-geometry"
+
+export type NodeMenuState = { nodeId: string; x: number; y: number }
+
+type FitView = (options?: { padding?: number; duration?: number; nodes?: { id: string }[] }) => unknown
+
+export function useWorkflowNodeMenuActions(options: {
+ addPrimitiveNode: (item: WorkflowPrimitive, position: CanvasPoint, runtimeCapability: ReturnType) => void
+ addWorkflowNodeFromCatalog: (item: WorkflowNodeCatalogItem, position: CanvasPoint) => void
+ capabilities: WorkflowCapabilitiesResponse | null | undefined
+ enterNodeNetwork: (nodeId: string) => number
+ fitView: FitView
+ language: WorkflowLanguage
+ lockNodeInternals: (nodeId: string) => number
+ nodeMenu: NodeMenuState | null
+ screenToFlowPosition: (position: CanvasPoint) => CanvasPoint
+ selectConnectedComponent: (nodeId: string) => { nodeIds: string[]; edgeIds: string[] }
+ setInspectorOpen: Dispatch>
+ setNodeMenu: Dispatch>
+ showToast: (message: string) => void
+ unlockNodeInternals: (nodeId: string) => number
+}) {
+ const {
+ addPrimitiveNode,
+ addWorkflowNodeFromCatalog,
+ capabilities,
+ enterNodeNetwork,
+ fitView,
+ language,
+ lockNodeInternals,
+ nodeMenu,
+ screenToFlowPosition,
+ selectConnectedComponent,
+ setInspectorOpen,
+ setNodeMenu,
+ showToast,
+ unlockNodeInternals,
+ } = options
+
+ const unlockInternals = useCallback(
+ (nodeId: string) => {
+ const count = unlockNodeInternals(nodeId)
+ showToast(count > 0 ? `已解锁 ${count} 个下层节点` : "这个节点没有可解锁的下层节点")
+ setNodeMenu(null)
+ },
+ [setNodeMenu, showToast, unlockNodeInternals],
+ )
+
+ const diveIntoNetwork = useCallback(
+ (nodeId: string) => {
+ const count = enterNodeNetwork(nodeId)
+ showToast(count > 0 ? `Dive into Network: ${count} nodes` : "这个节点没有下层 Network")
+ setNodeMenu(null)
+ if (count > 0) window.setTimeout(() => void fitView({ padding: 0.24, duration: 180 }), 20)
+ },
+ [enterNodeNetwork, fitView, setNodeMenu, showToast],
+ )
+
+ const addDopNodeFromMenu = useCallback(
+ (item: WorkflowNodeCatalogItem) => {
+ if (!nodeMenu) return
+ const text = localizeNodeText(item.id, { label: item.label, description: item.description }, language)
+ addWorkflowNodeFromCatalog(item, screenToFlowPosition({ x: nodeMenu.x + 26, y: nodeMenu.y + 26 }))
+ showToast(`已添加 DOP 节点：${text.label}`)
+ setNodeMenu(null)
+ },
+ [addWorkflowNodeFromCatalog, language, nodeMenu, screenToFlowPosition, setNodeMenu, showToast],
+ )
+
+ const addPrimitiveFromMenu = useCallback(
+ (item: WorkflowPrimitive, itemIndex: number) => {
+ if (!nodeMenu) return
+ const text = localizeNodeText(item.id, { label: item.label, description: item.description }, language)
+ const isInsideNetwork = useFlowStore.getState().networkStack.length > 0
+ let position = screenToFlowPosition({ x: nodeMenu.x + 280, y: nodeMenu.y + 26 + itemIndex * 34 })
+
+ if (!isInsideNetwork) {
+ const count = enterNodeNetwork(nodeMenu.nodeId)
+ if (count > 0) {
+ position = { x: 780, y: 96 + itemIndex * 96 }
+ window.setTimeout(() => void fitView({ padding: 0.24, duration: 180 }), 20)
+ } else {
+ showToast("这个节点没有下层 Network，已在当前层添加 draft primitive")
+ }
+ }
+
+ addPrimitiveNode(item, position, primitiveRuntimeCapability(capabilities, item.id))
+ showToast(`已添加原子节点：${text.label}`)
+ setNodeMenu(null)
+ },
+ [addPrimitiveNode, capabilities, enterNodeNetwork, fitView, language, nodeMenu, screenToFlowPosition, setNodeMenu, showToast],
+ )
+
+ const lockInternals = useCallback(
+ (nodeId: string) => {
+ const count = lockNodeInternals(nodeId)
+ showToast(count > 0 ? `已收回 ${count} 个下层节点` : "没有已解锁的下层节点")
+ setNodeMenu(null)
+ },
+ [lockNodeInternals, setNodeMenu, showToast],
+ )
+
+ const selectComponentFromMenu = useCallback(
+ (nodeId: string) => {
+ const result = selectConnectedComponent(nodeId)
+ showToast(`已选中组件：${result.nodeIds.length} 节点 / ${result.edgeIds.length} 连线`)
+ setNodeMenu(null)
+ if (result.nodeIds.length > 0) {
+ window.setTimeout(() => void fitView({ nodes: result.nodeIds.map((id) => ({ id })), padding: 0.35, duration: 260 }), 20)
+ }
+ },
+ [fitView, selectConnectedComponent, setNodeMenu, showToast],
+ )
+
+ const showNodeInfo = useCallback(() => {
+ setNodeMenu(null)
+ showToast("Node information is in Parameter Interface")
+ }, [setNodeMenu, showToast])
+
+ const showParameters = useCallback(() => {
+ setNodeMenu(null)
+ setInspectorOpen(true)
+ showToast("Parameter Interface 已显示")
+ }, [setInspectorOpen, setNodeMenu, showToast])
+
+ return {
+ addDopNodeFromMenu,
+ addPrimitiveFromMenu,
+ diveIntoNetwork,
+ lockInternals,
+ selectComponentFromMenu,
+ showNodeInfo,
+ showParameters,
+ unlockInternals,
+ }
+}
diff --git a/frontend/lib/flow/store-layout-actions.ts b/frontend/lib/flow/store-layout-actions.ts
new file mode 100644
index 0000000..511324f
--- /dev/null
+++ b/frontend/lib/flow/store-layout-actions.ts
@@ -0,0 +1,308 @@
+import { nanoid } from "nanoid"
+import type { StoreApi } from "zustand"
+import { animateNodes } from "./animate"
+import { COLLISION_GAP, findFreePosition, nodeRect, resolveCollisions } from "./collision"
+import { getLayoutedElements } from "./layout"
+import type { FlowState } from "./store"
+import type { WorkflowEdge, WorkflowNode } from "./types"
+
+type FlowSet = StoreApi["setState"]
+type FlowGet = StoreApi["getState"]
+
+function withoutParent(node: WorkflowNode): WorkflowNode {
+ const next = { ...node }
+ delete next.parentId
+ delete next.extent
+ return next
+}
+
+export function createLayoutActions(
+ set: FlowSet,
+ get: FlowGet,
+): Pick<
+ FlowState,
+ | "autoLayout"
+ | "toggleGroupCollapse"
+ | "groupSelection"
+ | "ungroupSelection"
+ | "attachToParent"
+ | "detachFromParent"
+ | "addChildNode"
+ | "insertNodeOnEdge"
+ | "resolveNodeCollisions"
+ | "resizeGroupToFit"
+> {
+ return {
+ autoLayout: async (direction, engine = "elk", animated = true) => {
+ get().takeSnapshot()
+ const current = get().nodes
+ const { nodes } = await getLayoutedElements(current, get().edges, direction, engine)
+ if (!animated || typeof window === "undefined") {
+ set({ nodes })
+ return
+ }
+ animateNodes(current, nodes, (frame) => set({ nodes: frame }))
+ },
+
+ toggleGroupCollapse: (id) => {
+ get().takeSnapshot()
+ set((state) => {
+ const target = state.nodes.find((n) => n.id === id)
+ if (!target) return {}
+ const collapsed = !target.data.collapsed
+ const expandedHeight = (target.data.expandedHeight as number) ?? (target.height as number) ?? 220
+ return {
+ nodes: state.nodes.map((n) => {
+ if (n.id === id) {
+ return {
+ ...n,
+ data: { ...n.data, collapsed, expandedHeight },
+ height: collapsed ? 56 : expandedHeight,
+ style: {
+ ...n.style,
+ width: (n.width as number) ?? 320,
+ height: collapsed ? 56 : expandedHeight,
+ },
+ }
+ }
+ if (n.parentId === id) {
+ return { ...n, hidden: collapsed }
+ }
+ return n
+ }),
+ }
+ })
+ },
+
+ groupSelection: () => {
+ const { nodes } = get()
+ const selected = nodes.filter((n) => n.selected && !n.parentId && n.type !== "group")
+ if (selected.length < 1) return
+ get().takeSnapshot()
+
+ const pad = 40
+ const minX = Math.min(...selected.map((n) => n.position.x))
+ const minY = Math.min(...selected.map((n) => n.position.y))
+ const maxX = Math.max(...selected.map((n) => n.position.x + ((n.measured?.width ?? (n.width as number)) ?? 220)))
+ const maxY = Math.max(...selected.map((n) => n.position.y + ((n.measured?.height ?? (n.height as number)) ?? 90)))
+
+ const groupId = `group-${nanoid(6)}`
+ const width = maxX - minX + pad * 2
+ const height = maxY - minY + pad * 2
+ const groupNode: WorkflowNode = {
+ id: groupId,
+ type: "group",
+ position: { x: minX - pad, y: minY - pad },
+ width,
+ height,
+ style: { width, height },
+ data: {
+ label: "分组",
+ nodeType: "group",
+ category: "logic",
+ icon: "Group",
+ color: "var(--muted-foreground)",
+ },
+ }
+
+ const selectedIds = new Set(selected.map((n) => n.id))
+ const updated = nodes.map((n) => {
+ if (!selectedIds.has(n.id)) return { ...n, selected: false }
+ return {
+ ...n,
+ parentId: groupId,
+ selected: false,
+ position: { x: n.position.x - (minX - pad), y: n.position.y - (minY - pad) },
+ }
+ })
+
+ set({ nodes: [groupNode, ...updated] })
+ },
+
+ ungroupSelection: () => {
+ const { nodes } = get()
+ const groups = nodes.filter((n) => n.selected && n.type === "group")
+ if (groups.length === 0) return
+ get().takeSnapshot()
+ const groupIds = new Set(groups.map((g) => g.id))
+ const groupPos = new Map(groups.map((g) => [g.id, g.position]))
+
+ const detached = nodes
+ .filter((n) => !groupIds.has(n.id))
+ .map((n) => {
+ if (n.parentId && groupIds.has(n.parentId)) {
+ const gp = groupPos.get(n.parentId)!
+ const rest = withoutParent(n)
+ return { ...rest, position: { x: n.position.x + gp.x, y: n.position.y + gp.y } }
+ }
+ return n
+ })
+
+ set({ nodes: detached })
+ },
+
+ attachToParent: (childId, parentId) => {
+ const { nodes } = get()
+ const child = nodes.find((n) => n.id === childId)
+ const parent = nodes.find((n) => n.id === parentId)
+ if (!child || !parent || child.parentId === parentId) return
+ get().takeSnapshot()
+
+ const attached = nodes.map((n) =>
+ n.id === childId
+ ? {
+ ...n,
+ parentId,
+ position: { x: n.position.x - parent.position.x, y: n.position.y - parent.position.y },
+ }
+ : n,
+ )
+ const parentIdx = attached.findIndex((n) => n.id === parentId)
+ const childIdx = attached.findIndex((n) => n.id === childId)
+ if (childIdx < parentIdx) {
+ const [childNode] = attached.splice(childIdx, 1)
+ const newParentIdx = attached.findIndex((n) => n.id === parentId)
+ attached.splice(newParentIdx + 1, 0, childNode)
+ }
+ set({ nodes: attached })
+ get().resizeGroupToFit(parentId)
+ },
+
+ detachFromParent: (childId) => {
+ const { nodes } = get()
+ const child = nodes.find((n) => n.id === childId)
+ if (!child || !child.parentId) return
+ const parent = nodes.find((n) => n.id === child.parentId)
+ if (!parent) return
+ get().takeSnapshot()
+ set({
+ nodes: nodes.map((n) => {
+ if (n.id !== childId) return n
+ const rest = withoutParent(n)
+ return { ...rest, position: { x: n.position.x + parent.position.x, y: n.position.y + parent.position.y } }
+ }),
+ })
+ },
+
+ addChildNode: (parentId) => {
+ const { nodes, edges } = get()
+ const parent = nodes.find((n) => n.id === parentId)
+ if (!parent) return
+ get().takeSnapshot()
+ const id = nanoid(8)
+ const parentRect = nodeRect(parent)
+ const size = { width: 240, height: 96 }
+ const childCount = edges.filter((e) => e.source === parentId).length
+ const desired = {
+ x: parentRect.x + childCount * (size.width + COLLISION_GAP),
+ y: parentRect.y + parentRect.height + 96,
+ }
+ const freePos = findFreePosition(nodes, desired, size, parent.parentId)
+ const newNode: WorkflowNode = {
+ id,
+ type: "workflow",
+ position: freePos,
+ ...(parent.parentId ? { parentId: parent.parentId } : {}),
+ data: {
+ label: "新节点",
+ nodeType: "action",
+ category: "action",
+ icon: "Zap",
+ color: "var(--chart-1)",
+ status: "idle",
+ },
+ }
+ const newEdge: WorkflowEdge = {
+ id: `e-${nanoid(6)}`,
+ source: parentId,
+ target: id,
+ type: "workflow",
+ animated: true,
+ }
+ set({ nodes: [...nodes, newNode], edges: [...edges, newEdge] })
+ },
+
+ insertNodeOnEdge: (edgeId) => {
+ const { nodes, edges } = get()
+ const edge = edges.find((e) => e.id === edgeId)
+ if (!edge) return
+ get().takeSnapshot()
+ const source = nodes.find((n) => n.id === edge.source)
+ const target = nodes.find((n) => n.id === edge.target)
+ if (!source || !target) return
+
+ const id = nanoid(8)
+ const newNode: WorkflowNode = {
+ id,
+ type: "workflow",
+ position: {
+ x: (source.position.x + target.position.x) / 2,
+ y: (source.position.y + target.position.y) / 2,
+ },
+ data: {
+ label: "插入节点",
+ nodeType: "action",
+ category: "action",
+ icon: "Zap",
+ color: "var(--chart-1)",
+ status: "idle",
+ },
+ }
+ const newEdges = edges.filter((e) => e.id !== edgeId)
+ newEdges.push(
+ { id: `e-${nanoid(6)}`, source: edge.source, target: id, type: "workflow", animated: true },
+ { id: `e-${nanoid(6)}`, source: id, target: edge.target, type: "workflow", animated: true },
+ )
+ set({ nodes: resolveCollisions([...nodes, newNode], id), edges: newEdges })
+ },
+
+ resolveNodeCollisions: (movedId) => {
+ set((state) => ({ nodes: resolveCollisions(state.nodes, movedId) }))
+ },
+
+ resizeGroupToFit: (groupId) => {
+ const { nodes } = get()
+ const group = nodes.find((n) => n.id === groupId && n.type === "group")
+ if (!group || group.data.collapsed) return
+ const children = nodes.filter((n) => n.parentId === groupId && !n.hidden)
+ if (children.length === 0) return
+
+ const pad = 32
+ const header = 44
+ let minX = Number.POSITIVE_INFINITY
+ let minY = Number.POSITIVE_INFINITY
+ let maxX = Number.NEGATIVE_INFINITY
+ let maxY = Number.NEGATIVE_INFINITY
+ for (const child of children) {
+ const rect = nodeRect(child)
+ minX = Math.min(minX, rect.x)
+ minY = Math.min(minY, rect.y)
+ maxX = Math.max(maxX, rect.x + rect.width)
+ maxY = Math.max(maxY, rect.y + rect.height)
+ }
+
+ const shiftX = Math.max(0, pad - minX)
+ const shiftY = Math.max(0, header + pad - minY)
+ const width = Math.max((group.width as number) ?? 320, maxX + shiftX + pad)
+ const height = Math.max((group.height as number) ?? 220, maxY + shiftY + pad)
+
+ set({
+ nodes: nodes.map((n) => {
+ if (n.id === groupId) {
+ return {
+ ...n,
+ position: { x: n.position.x - shiftX, y: n.position.y - shiftY },
+ width,
+ height,
+ style: { ...n.style, width, height },
+ }
+ }
+ if (n.parentId === groupId) {
+ return { ...n, position: { x: n.position.x + shiftX, y: n.position.y + shiftY } }
+ }
+ return n
+ }),
+ })
+ },
+ }
+}
diff --git a/frontend/lib/flow/store-slices.ts b/frontend/lib/flow/store-slices.ts
new file mode 100644
index 0000000..f15759f
--- /dev/null
+++ b/frontend/lib/flow/store-slices.ts
@@ -0,0 +1,306 @@
+import { nanoid } from "nanoid"
+import { addEdge, applyEdgeChanges, applyNodeChanges } from "@xyflow/react"
+import type { StoreApi } from "zustand"
+import { applyHelperLines } from "./helper-lines"
+import { useSettingsStore } from "./settings-store"
+import { connectedComponentEdges, findConnectedComponentForNode } from "./graph-components"
+import type { FlowState } from "./store"
+import { HISTORY_LIMIT, snapshot } from "./store-utils"
+
+type FlowSet = StoreApi["setState"]
+type FlowGet = StoreApi["getState"]
+
+export function createWhiteboardActions(
+ set: FlowSet,
+ get: FlowGet,
+): Pick {
+ return {
+ setToolMode: (mode) => set({ toolMode: mode }),
+ setPenColor: (color) => set({ penColor: color }),
+ setPenSize: (size) => set({ penSize: size }),
+ addStroke: (stroke) => set((state) => ({ drawings: [...state.drawings, stroke] })),
+ clearDrawings: () => {
+ get().takeSnapshot()
+ set({ drawings: [] })
+ },
+ }
+}
+
+export function createCanvasChangeActions(
+ set: FlowSet,
+ get: FlowGet,
+): Pick {
+ return {
+ onNodesChange: (changes) => {
+ const { changes: nextChanges, helperLines } = applyHelperLines(
+ changes,
+ get().nodes,
+ useSettingsStore.getState().snapToHelperLines,
+ )
+ set({
+ nodes: applyNodeChanges(nextChanges, get().nodes),
+ helperLines,
+ })
+ },
+
+ onEdgesChange: (changes) => {
+ set({ edges: applyEdgeChanges(changes, get().edges) })
+ },
+
+ onConnect: (connection) => {
+ get().takeSnapshot()
+ set({
+ edges: addEdge(
+ {
+ ...connection,
+ type: "workflow",
+ animated: true,
+ },
+ get().edges,
+ ),
+ })
+ },
+
+ setNodes: (updater) => set((state) => ({ nodes: updater(state.nodes) })),
+ setSelectedIds: (ids) => set({ selectedIds: ids }),
+ clearHelperLines: () => set({ helperLines: { snapPosition: {} } }),
+ }
+}
+
+export function createHistoryActions(
+ set: FlowSet,
+ get: FlowGet,
+): Pick {
+ return {
+ takeSnapshot: () => {
+ set((state) => ({
+ past: [...state.past, snapshot(state)].slice(-HISTORY_LIMIT),
+ future: [],
+ }))
+ },
+
+ undo: () => {
+ const { past } = get()
+ if (past.length === 0) return
+ const previous = past[past.length - 1]
+ set((state) => ({
+ past: state.past.slice(0, -1),
+ future: [snapshot(state), ...state.future].slice(0, HISTORY_LIMIT),
+ nodes: previous.nodes,
+ edges: previous.edges,
+ drawings: previous.drawings ?? [],
+ helperLines: { snapPosition: {} },
+ }))
+ },
+
+ redo: () => {
+ const { future } = get()
+ if (future.length === 0) return
+ const next = future[0]
+ set((state) => ({
+ past: [...state.past, snapshot(state)].slice(-HISTORY_LIMIT),
+ future: state.future.slice(1),
+ nodes: next.nodes,
+ edges: next.edges,
+ drawings: next.drawings ?? [],
+ helperLines: { snapPosition: {} },
+ }))
+ },
+
+ canUndo: () => get().past.length > 0,
+ canRedo: () => get().future.length > 0,
+ }
+}
+
+export function createSelectionActions(
+ set: FlowSet,
+ get: FlowGet,
+): Pick<
+ FlowState,
+ | "deleteSelected"
+ | "disconnectSelectedConnections"
+ | "disconnectNodeConnections"
+ | "removeEdgesByIds"
+ | "selectConnectedComponent"
+ | "duplicateSelected"
+ | "copy"
+ | "cut"
+ | "paste"
+> {
+ return {
+ deleteSelected: () => {
+ const { nodes, edges } = get()
+ const selectedNodeIds = new Set(nodes.filter((n) => n.selected).map((n) => n.id))
+ const selectedEdgeIds = new Set(edges.filter((e) => e.selected).map((e) => e.id))
+ if (selectedNodeIds.size === 0 && selectedEdgeIds.size === 0) return
+ get().takeSnapshot()
+ set({
+ nodes: nodes.filter((n) => !selectedNodeIds.has(n.id)),
+ edges: edges.filter(
+ (e) => !selectedEdgeIds.has(e.id) && !selectedNodeIds.has(e.source) && !selectedNodeIds.has(e.target),
+ ),
+ })
+ },
+
+ disconnectSelectedConnections: () => {
+ const { nodes, edges } = get()
+ const selectedNodeIds = new Set(nodes.filter((n) => n.selected).map((n) => n.id))
+ const selectedEdgeIds = new Set(edges.filter((e) => e.selected).map((e) => e.id))
+ if (selectedNodeIds.size === 0 && selectedEdgeIds.size === 0) return 0
+ const nextEdges = edges.filter(
+ (e) => !selectedEdgeIds.has(e.id) && !selectedNodeIds.has(e.source) && !selectedNodeIds.has(e.target),
+ )
+ const removed = edges.length - nextEdges.length
+ if (removed === 0) return 0
+ get().takeSnapshot()
+ set({ edges: nextEdges })
+ return removed
+ },
+
+ disconnectNodeConnections: (nodeId) => {
+ const { edges } = get()
+ const nextEdges = edges.filter((e) => e.source !== nodeId && e.target !== nodeId)
+ const removed = edges.length - nextEdges.length
+ if (removed === 0) return 0
+ get().takeSnapshot()
+ set({ edges: nextEdges })
+ return removed
+ },
+
+ removeEdgesByIds: (edgeIds) => {
+ const ids = new Set(edgeIds)
+ if (ids.size === 0) return 0
+ const { edges } = get()
+ const nextEdges = edges.filter((e) => !ids.has(e.id))
+ const removed = edges.length - nextEdges.length
+ if (removed === 0) return 0
+ get().takeSnapshot()
+ set({ edges: nextEdges })
+ return removed
+ },
+
+ selectConnectedComponent: (nodeId) => {
+ const { nodes, edges } = get()
+ const nodeIds = findConnectedComponentForNode(nodeId, nodes, edges)
+ const edgeIds = connectedComponentEdges(nodeIds, edges)
+ const selectedNodes = new Set(nodeIds)
+ const selectedEdges = new Set(edgeIds)
+ set({
+ nodes: nodes.map((node) => ({ ...node, selected: selectedNodes.has(node.id) })),
+ edges: edges.map((edge) => ({ ...edge, selected: selectedEdges.has(edge.id) })),
+ })
+ return { nodeIds, edgeIds }
+ },
+
+ duplicateSelected: () => {
+ const { nodes } = get()
+ const selected = nodes.filter((n) => n.selected)
+ if (selected.length === 0) return
+ get().takeSnapshot()
+ const clones = selected.map((n) => ({
+ ...n,
+ id: nanoid(8),
+ selected: true,
+ position: { x: n.position.x + 40, y: n.position.y + 40 },
+ data: JSON.parse(JSON.stringify(n.data)),
+ }))
+ set({
+ nodes: [...nodes.map((n) => ({ ...n, selected: false })), ...clones],
+ })
+ },
+
+ copy: () => {
+ const { nodes, edges } = get()
+ const selectedNodes = nodes.filter((n) => n.selected)
+ if (selectedNodes.length === 0) return
+ const ids = new Set(selectedNodes.map((n) => n.id))
+ const internalEdges = edges.filter((e) => ids.has(e.source) && ids.has(e.target))
+ set({
+ clipboard: {
+ nodes: JSON.parse(JSON.stringify(selectedNodes)),
+ edges: JSON.parse(JSON.stringify(internalEdges)),
+ },
+ })
+ },
+
+ cut: () => {
+ get().copy()
+ get().deleteSelected()
+ },
+
+ paste: (position) => {
+ const { clipboard, nodes } = get()
+ if (!clipboard || clipboard.nodes.length === 0) return
+ get().takeSnapshot()
+
+ const idMap = new Map()
+ const minX = Math.min(...clipboard.nodes.map((n) => n.position.x))
+ const minY = Math.min(...clipboard.nodes.map((n) => n.position.y))
+ const offsetX = position ? position.x - minX : 48
+ const offsetY = position ? position.y - minY : 48
+
+ const newNodes = clipboard.nodes.map((n) => {
+ const newId = nanoid(8)
+ idMap.set(n.id, newId)
+ return {
+ ...n,
+ id: newId,
+ selected: true,
+ position: { x: n.position.x + offsetX, y: n.position.y + offsetY },
+ data: JSON.parse(JSON.stringify(n.data)),
+ }
+ })
+
+ const newEdges = clipboard.edges.map((e) => ({
+ ...e,
+ id: `e-${nanoid(6)}`,
+ source: idMap.get(e.source) ?? e.source,
+ target: idMap.get(e.target) ?? e.target,
+ selected: false,
+ }))
+
+ set((state) => ({
+ nodes: [...nodes.map((n) => ({ ...n, selected: false })), ...newNodes],
+ edges: [...state.edges, ...newEdges],
+ }))
+ },
+ }
+}
+
+export function createEdgeActions(
+ set: FlowSet,
+ get: FlowGet,
+): Pick {
+ return {
+ updateEdgeWaypoints: (edgeId, waypoints) => {
+ set((state) => ({
+ edges: state.edges.map((e) =>
+ e.id === edgeId ? { ...e, type: "editable", data: { ...e.data, waypoints } } : e,
+ ),
+ }))
+ },
+
+ updateEdgeData: (edgeId, data) => {
+ set((state) => ({
+ edges: state.edges.map((e) => (e.id === edgeId ? { ...e, data: { ...e.data, ...data } } : e)),
+ }))
+ },
+
+ updateEdgeType: (edgeId, type) => {
+ get().takeSnapshot()
+ set((state) => ({
+ edges: state.edges.map((e) =>
+ e.id === edgeId
+ ? { ...e, type, data: { ...e.data, ...(type === "editable" ? {} : { waypoints: undefined }) } }
+ : e,
+ ),
+ }))
+ },
+
+ toggleEdgeAnimated: (edgeId) => {
+ set((state) => ({
+ edges: state.edges.map((e) => (e.id === edgeId ? { ...e, animated: !e.animated } : e)),
+ }))
+ },
+ }
+}
diff --git a/frontend/lib/flow/store-utils.ts b/frontend/lib/flow/store-utils.ts
new file mode 100644
index 0000000..a2ff500
--- /dev/null
+++ b/frontend/lib/flow/store-utils.ts
@@ -0,0 +1,15 @@
+import type { FlowSnapshot, FreehandStroke, WorkflowEdge, WorkflowNode } from "./types"
+
+export const HISTORY_LIMIT = 100
+
+export function snapshot(state: {
+ nodes: WorkflowNode[]
+ edges: WorkflowEdge[]
+ drawings: FreehandStroke[]
+}): FlowSnapshot {
+ return {
+ nodes: JSON.parse(JSON.stringify(state.nodes)),
+ edges: JSON.parse(JSON.stringify(state.edges)),
+ drawings: JSON.parse(JSON.stringify(state.drawings)),
+ }
+}
diff --git a/frontend/lib/flow/store.ts b/frontend/lib/flow/store.ts
index 11c6e24..3a4a060 100644
--- a/frontend/lib/flow/store.ts
+++ b/frontend/lib/flow/store.ts
@@ -3,9 +3,6 @@
import { create } from "zustand"
import { nanoid } from "nanoid"
import {
- addEdge,
- applyEdgeChanges,
- applyNodeChanges,
type Connection,
type EdgeChange,
type NodeChange,
@@ -23,13 +20,19 @@ import type {
GeneratedWorkflowSpec,
ParameterInterface,
} from "./types"
-import { applyHelperLines, type HelperLines } from "./helper-lines"
-import { useSettingsStore } from "./settings-store"
-import { resolveCollisions, findFreePosition, nodeRect, COLLISION_GAP } from "./collision"
-import { connectedComponentEdges, findConnectedComponentForNode } from "./graph-components"
-import { getLayoutedElements, type LayoutDirection, type LayoutEngine } from "./layout"
-import { animateNodes } from "./animate"
+import type { HelperLines } from "./helper-lines"
+import { resolveCollisions, findFreePosition, nodeRect } from "./collision"
+import type { LayoutDirection, LayoutEngine } from "./layout"
import { NODE_PALETTE } from "./palette"
+import { createLayoutActions } from "./store-layout-actions"
+import {
+ createCanvasChangeActions,
+ createEdgeActions,
+ createHistoryActions,
+ createSelectionActions,
+ createWhiteboardActions,
+} from "./store-slices"
+import { snapshot } from "./store-utils"
import { COLLECTION_WORKFLOW_PROJECT } from "../workflow/collection-pipeline"
import type { WorkflowProject } from "../workflow/schema"
import { parseWorkflowProject, type AdapterBinding, type WorkflowProfile, type WorkflowProjectNode } from "../workflow/schema"
@@ -53,12 +56,11 @@ import type {
export type { GeneratedWorkflowSpec } from "./types"
-const HISTORY_LIMIT = 100
const STORAGE_KEY = "workflow-editor-state"
const initialWorkflowProject = COLLECTION_WORKFLOW_PROJECT
const initialWorkflowFlow = workflowProjectToReactFlow(initialWorkflowProject)
-type FlowState = {
+export type FlowState = {
workflowProject: WorkflowProject
nodes: WorkflowNode[]
edges: WorkflowEdge[]
@@ -163,14 +165,6 @@ type FlowState = {
applyGeneratedWorkflow: (spec: GeneratedWorkflowSpec) => void
}
-function snapshot(state: Pick): FlowSnapshot {
- return {
- nodes: JSON.parse(JSON.stringify(state.nodes)),
- edges: JSON.parse(JSON.stringify(state.edges)),
- drawings: JSON.parse(JSON.stringify(state.drawings)),
- }
-}
-
function uniqueWorkflowNodeId(prefix: string, nodes: WorkflowProject["nodes"]): string {
const ids = new Set(nodes.map((node) => node.id))
let candidate = prefix
@@ -598,82 +592,9 @@ export const useFlowStore = create((set, get) => ({
penColor: "var(--chart-1)",
penSize: 4,
- setToolMode: (mode) => set({ toolMode: mode }),
- setPenColor: (color) => set({ penColor: color }),
- setPenSize: (size) => set({ penSize: size }),
- addStroke: (stroke) => set((state) => ({ drawings: [...state.drawings, stroke] })),
- clearDrawings: () => {
- get().takeSnapshot()
- set({ drawings: [] })
- },
-
- onNodesChange: (changes) => {
- const { changes: nextChanges, helperLines } = applyHelperLines(
- changes,
- get().nodes,
- useSettingsStore.getState().snapToHelperLines,
- )
- set({
- nodes: applyNodeChanges(nextChanges, get().nodes),
- helperLines,
- })
- },
-
- onEdgesChange: (changes) => {
- set({ edges: applyEdgeChanges(changes, get().edges) })
- },
-
- onConnect: (connection) => {
- get().takeSnapshot()
- set({
- edges: addEdge(
- {
- ...connection,
- type: "workflow",
- animated: true,
- },
- get().edges,
- ),
- })
- },
-
- takeSnapshot: () => {
- set((state) => ({
- past: [...state.past, snapshot(state)].slice(-HISTORY_LIMIT),
- future: [],
- }))
- },
-
- undo: () => {
- const { past } = get()
- if (past.length === 0) return
- const previous = past[past.length - 1]
- set((state) => ({
- past: state.past.slice(0, -1),
- future: [snapshot(state), ...state.future].slice(0, HISTORY_LIMIT),
- nodes: previous.nodes,
- edges: previous.edges,
- drawings: previous.drawings ?? [],
- helperLines: { snapPosition: {} },
- }))
- },
-
- redo: () => {
- const { future } = get()
- if (future.length === 0) return
- const next = future[0]
- set((state) => ({
- past: [...state.past, snapshot(state)].slice(-HISTORY_LIMIT),
- future: state.future.slice(1),
- nodes: next.nodes,
- edges: next.edges,
- drawings: next.drawings ?? [],
- helperLines: { snapPosition: {} },
- }))
- },
-
- canUndo: () => get().past.length > 0,
- canRedo: () => get().future.length > 0,
+ ...createWhiteboardActions(set, get),
+ ...createCanvasChangeActions(set, get),
+ ...createHistoryActions(set, get),
addNodeFromPalette: (item, position) => {
get().takeSnapshot()
@@ -854,405 +775,10 @@ export const useFlowStore = create((set, get) => ({
}))
},
- deleteSelected: () => {
- const { nodes, edges } = get()
- const selectedNodeIds = new Set(nodes.filter((n) => n.selected).map((n) => n.id))
- const selectedEdgeIds = new Set(edges.filter((e) => e.selected).map((e) => e.id))
- if (selectedNodeIds.size === 0 && selectedEdgeIds.size === 0) return
- get().takeSnapshot()
- set({
- nodes: nodes.filter((n) => !selectedNodeIds.has(n.id)),
- edges: edges.filter(
- (e) => !selectedEdgeIds.has(e.id) && !selectedNodeIds.has(e.source) && !selectedNodeIds.has(e.target),
- ),
- })
- },
-
- disconnectSelectedConnections: () => {
- const { nodes, edges } = get()
- const selectedNodeIds = new Set(nodes.filter((n) => n.selected).map((n) => n.id))
- const selectedEdgeIds = new Set(edges.filter((e) => e.selected).map((e) => e.id))
- if (selectedNodeIds.size === 0 && selectedEdgeIds.size === 0) return 0
- const nextEdges = edges.filter(
- (e) => !selectedEdgeIds.has(e.id) && !selectedNodeIds.has(e.source) && !selectedNodeIds.has(e.target),
- )
- const removed = edges.length - nextEdges.length
- if (removed === 0) return 0
- get().takeSnapshot()
- set({ edges: nextEdges })
- return removed
- },
-
- disconnectNodeConnections: (nodeId) => {
- const { edges } = get()
- const nextEdges = edges.filter((e) => e.source !== nodeId && e.target !== nodeId)
- const removed = edges.length - nextEdges.length
- if (removed === 0) return 0
- get().takeSnapshot()
- set({ edges: nextEdges })
- return removed
- },
-
- removeEdgesByIds: (edgeIds) => {
- const ids = new Set(edgeIds)
- if (ids.size === 0) return 0
- const { edges } = get()
- const nextEdges = edges.filter((e) => !ids.has(e.id))
- const removed = edges.length - nextEdges.length
- if (removed === 0) return 0
- get().takeSnapshot()
- set({ edges: nextEdges })
- return removed
- },
-
- selectConnectedComponent: (nodeId) => {
- const { nodes, edges } = get()
- const nodeIds = findConnectedComponentForNode(nodeId, nodes, edges)
- const edgeIds = connectedComponentEdges(nodeIds, edges)
- const selectedNodes = new Set(nodeIds)
- const selectedEdges = new Set(edgeIds)
- set({
- nodes: nodes.map((node) => ({ ...node, selected: selectedNodes.has(node.id) })),
- edges: edges.map((edge) => ({ ...edge, selected: selectedEdges.has(edge.id) })),
- })
- return { nodeIds, edgeIds }
- },
-
- duplicateSelected: () => {
- const { nodes } = get()
- const selected = nodes.filter((n) => n.selected)
- if (selected.length === 0) return
- get().takeSnapshot()
- const idMap = new Map()
- const clones = selected.map((n) => {
- const newId = nanoid(8)
- idMap.set(n.id, newId)
- return {
- ...n,
- id: newId,
- selected: true,
- position: { x: n.position.x + 40, y: n.position.y + 40 },
- data: JSON.parse(JSON.stringify(n.data)),
- }
- })
- set({
- nodes: [...nodes.map((n) => ({ ...n, selected: false })), ...clones],
- })
- },
-
- copy: () => {
- const { nodes, edges } = get()
- const selectedNodes = nodes.filter((n) => n.selected)
- if (selectedNodes.length === 0) return
- const ids = new Set(selectedNodes.map((n) => n.id))
- const internalEdges = edges.filter((e) => ids.has(e.source) && ids.has(e.target))
- set({
- clipboard: {
- nodes: JSON.parse(JSON.stringify(selectedNodes)),
- edges: JSON.parse(JSON.stringify(internalEdges)),
- },
- })
- },
-
- cut: () => {
- get().copy()
- get().deleteSelected()
- },
-
- paste: (position) => {
- const { clipboard, nodes } = get()
- if (!clipboard || clipboard.nodes.length === 0) return
- get().takeSnapshot()
-
- const idMap = new Map()
- // anchor offset
- const minX = Math.min(...clipboard.nodes.map((n) => n.position.x))
- const minY = Math.min(...clipboard.nodes.map((n) => n.position.y))
- const offsetX = position ? position.x - minX : 48
- const offsetY = position ? position.y - minY : 48
-
- const newNodes = clipboard.nodes.map((n) => {
- const newId = nanoid(8)
- idMap.set(n.id, newId)
- return {
- ...n,
- id: newId,
- selected: true,
- position: { x: n.position.x + offsetX, y: n.position.y + offsetY },
- data: JSON.parse(JSON.stringify(n.data)),
- }
- })
-
- const newEdges = clipboard.edges.map((e) => ({
- ...e,
- id: `e-${nanoid(6)}`,
- source: idMap.get(e.source) ?? e.source,
- target: idMap.get(e.target) ?? e.target,
- selected: false,
- }))
-
- set((state) => ({
- nodes: [...nodes.map((n) => ({ ...n, selected: false })), ...newNodes],
- edges: [...state.edges, ...newEdges],
- }))
- },
-
- autoLayout: async (direction, engine = "elk", animated = true) => {
- get().takeSnapshot()
- const current = get().nodes
- const { nodes } = await getLayoutedElements(current, get().edges, direction, engine)
- if (!animated || typeof window === "undefined") {
- set({ nodes })
- return
- }
- animateNodes(current, nodes, (frame) => set({ nodes: frame }))
- },
-
- toggleGroupCollapse: (id) => {
- get().takeSnapshot()
- set((state) => {
- const target = state.nodes.find((n) => n.id === id)
- if (!target) return {}
- const collapsed = !target.data.collapsed
- const expandedHeight = (target.data.expandedHeight as number) ?? (target.height as number) ?? 220
- return {
- nodes: state.nodes.map((n) => {
- if (n.id === id) {
- return {
- ...n,
- data: { ...n.data, collapsed, expandedHeight },
- height: collapsed ? 56 : expandedHeight,
- style: {
- ...n.style,
- width: (n.width as number) ?? 320,
- height: collapsed ? 56 : expandedHeight,
- },
- }
- }
- if (n.parentId === id) {
- return { ...n, hidden: collapsed }
- }
- return n
- }),
- }
- })
- },
-
- groupSelection: () => {
- const { nodes } = get()
- const selected = nodes.filter((n) => n.selected && !n.parentId && n.type !== "group")
- if (selected.length < 1) return
- get().takeSnapshot()
-
- const PAD = 40
- const minX = Math.min(...selected.map((n) => n.position.x))
- const minY = Math.min(...selected.map((n) => n.position.y))
- const maxX = Math.max(...selected.map((n) => n.position.x + ((n.measured?.width ?? (n.width as number)) ?? 220)))
- const maxY = Math.max(...selected.map((n) => n.position.y + ((n.measured?.height ?? (n.height as number)) ?? 90)))
-
- const groupId = `group-${nanoid(6)}`
- const width = maxX - minX + PAD * 2
- const height = maxY - minY + PAD * 2
- const groupNode: WorkflowNode = {
- id: groupId,
- type: "group",
- position: { x: minX - PAD, y: minY - PAD },
- width,
- height,
- style: { width, height },
- data: {
- label: "分组",
- nodeType: "group",
- category: "logic",
- icon: "Group",
- color: "var(--muted-foreground)",
- },
- }
-
- const selectedIds = new Set(selected.map((n) => n.id))
- const updated = nodes.map((n) => {
- if (!selectedIds.has(n.id)) return { ...n, selected: false }
- return {
- ...n,
- parentId: groupId,
- selected: false,
- position: { x: n.position.x - (minX - PAD), y: n.position.y - (minY - PAD) },
- }
- })
-
- set({ nodes: [groupNode, ...updated] })
- },
-
- ungroupSelection: () => {
- const { nodes } = get()
- const groups = nodes.filter((n) => n.selected && n.type === "group")
- if (groups.length === 0) return
- get().takeSnapshot()
- const groupIds = new Set(groups.map((g) => g.id))
- const groupPos = new Map(groups.map((g) => [g.id, g.position]))
-
- const detached = nodes
- .filter((n) => !groupIds.has(n.id))
- .map((n) => {
- if (n.parentId && groupIds.has(n.parentId)) {
- const gp = groupPos.get(n.parentId)!
- const { parentId, extent, ...rest } = n
- return { ...rest, position: { x: n.position.x + gp.x, y: n.position.y + gp.y } }
- }
- return n
- })
-
- set({ nodes: detached })
- },
-
- attachToParent: (childId, parentId) => {
- const { nodes } = get()
- const child = nodes.find((n) => n.id === childId)
- const parent = nodes.find((n) => n.id === parentId)
- if (!child || !parent || child.parentId === parentId) return
- get().takeSnapshot()
-
- const attached = nodes.map((n) =>
- n.id === childId
- ? {
- ...n,
- parentId,
- position: { x: n.position.x - parent.position.x, y: n.position.y - parent.position.y },
- }
- : n,
- )
- // React Flow 要求 parent 必须出现在 child 之前，否则子节点渲染异常（"消失"）
- const parentIdx = attached.findIndex((n) => n.id === parentId)
- const childIdx = attached.findIndex((n) => n.id === childId)
- if (childIdx < parentIdx) {
- const [childNode] = attached.splice(childIdx, 1)
- const newParentIdx = attached.findIndex((n) => n.id === parentId)
- attached.splice(newParentIdx + 1, 0, childNode)
- }
- set({ nodes: attached })
- get().resizeGroupToFit(parentId)
- },
-
- detachFromParent: (childId) => {
- const { nodes } = get()
- const child = nodes.find((n) => n.id === childId)
- if (!child || !child.parentId) return
- const parent = nodes.find((n) => n.id === child.parentId)
- if (!parent) return
- get().takeSnapshot()
- set({
- nodes: nodes.map((n) => {
- if (n.id !== childId) return n
- const { parentId, extent, ...rest } = n
- return { ...rest, position: { x: n.position.x + parent.position.x, y: n.position.y + parent.position.y } }
- }),
- })
- },
-
- updateEdgeWaypoints: (edgeId, waypoints) => {
- set((state) => ({
- edges: state.edges.map((e) =>
- e.id === edgeId ? { ...e, type: "editable", data: { ...e.data, waypoints } } : e,
- ),
- }))
- },
-
- updateEdgeData: (edgeId, data) => {
- set((state) => ({
- edges: state.edges.map((e) => (e.id === edgeId ? { ...e, data: { ...e.data, ...data } } : e)),
- }))
- },
-
- updateEdgeType: (edgeId, type) => {
- get().takeSnapshot()
- set((state) => ({
- edges: state.edges.map((e) =>
- e.id === edgeId
- ? { ...e, type, data: { ...e.data, ...(type === "editable" ? {} : { waypoints: undefined }) } }
- : e,
- ),
- }))
- },
-
- toggleEdgeAnimated: (edgeId) => {
- set((state) => ({
- edges: state.edges.map((e) => (e.id === edgeId ? { ...e, animated: !e.animated } : e)),
- }))
- },
+ ...createSelectionActions(set, get),
+ ...createLayoutActions(set, get),
- addChildNode: (parentId) => {
- const { nodes, edges } = get()
- const parent = nodes.find((n) => n.id === parentId)
- if (!parent) return
- get().takeSnapshot()
- const id = nanoid(8)
- const parentRect = nodeRect(parent)
- const size = { width: 240, height: 96 }
- // 端口在上下两侧 → 子节点放在父节点下方，同层不重叠（不做全图重排）
- const childCount = edges.filter((e) => e.source === parentId).length
- const desired = {
- x: parentRect.x + childCount * (size.width + COLLISION_GAP),
- y: parentRect.y + parentRect.height + 96,
- }
- const freePos = findFreePosition(nodes, desired, size, parent.parentId)
- const newNode: WorkflowNode = {
- id,
- type: "workflow",
- position: freePos,
- ...(parent.parentId ? { parentId: parent.parentId } : {}),
- data: {
- label: "新节点",
- nodeType: "action",
- category: "action",
- icon: "Zap",
- color: "var(--chart-1)",
- status: "idle",
- },
- }
- const newEdge: WorkflowEdge = {
- id: `e-${nanoid(6)}`,
- source: parentId,
- target: id,
- type: "workflow",
- animated: true,
- }
- set({ nodes: [...nodes, newNode], edges: [...edges, newEdge] })
- },
-
- insertNodeOnEdge: (edgeId) => {
- const { nodes, edges } = get()
- const edge = edges.find((e) => e.id === edgeId)
- if (!edge) return
- get().takeSnapshot()
- const source = nodes.find((n) => n.id === edge.source)
- const target = nodes.find((n) => n.id === edge.target)
- if (!source || !target) return
-
- const id = nanoid(8)
- const newNode: WorkflowNode = {
- id,
- type: "workflow",
- position: {
- x: (source.position.x + target.position.x) / 2,
- y: (source.position.y + target.position.y) / 2,
- },
- data: {
- label: "插入节点",
- nodeType: "action",
- category: "action",
- icon: "Zap",
- color: "var(--chart-1)",
- status: "idle",
- },
- }
- const newEdges = edges.filter((e) => e.id !== edgeId)
- newEdges.push(
- { id: `e-${nanoid(6)}`, source: edge.source, target: id, type: "workflow", animated: true },
- { id: `e-${nanoid(6)}`, source: id, target: edge.target, type: "workflow", animated: true },
- )
- // 插入点保持原位，把周围节点推开，避免全图重排
- set({ nodes: resolveCollisions([...nodes, newNode], id), edges: newEdges })
- },
+ ...createEdgeActions(set, get),
enterNodeNetwork: (nodeId) => {
const { workflowProject, nodes, edges, drawings, networkStack } = get()
@@ -1453,60 +979,6 @@ export const useFlowStore = create((set, get) => ({
return internalIds.size
},
- resolveNodeCollisions: (movedId) => {
- set((state) => ({ nodes: resolveCollisions(state.nodes, movedId) }))
- },
-
- resizeGroupToFit: (groupId) => {
- const { nodes } = get()
- const group = nodes.find((n) => n.id === groupId && n.type === "group")
- if (!group || group.data.collapsed) return
- const children = nodes.filter((n) => n.parentId === groupId && !n.hidden)
- if (children.length === 0) return
-
- const PAD = 32
- const HEADER = 44
- let minX = Number.POSITIVE_INFINITY
- let minY = Number.POSITIVE_INFINITY
- let maxX = Number.NEGATIVE_INFINITY
- let maxY = Number.NEGATIVE_INFINITY
- for (const c of children) {
- const r = nodeRect(c)
- minX = Math.min(minX, r.x)
- minY = Math.min(minY, r.y)
- maxX = Math.max(maxX, r.x + r.width)
- maxY = Math.max(maxY, r.y + r.height)
- }
-
- // 子节点相对坐标可能为负（拖到分组左/上侧）→ 平移分组原点并修正所有子节点
- const shiftX = Math.max(0, PAD - minX)
- const shiftY = Math.max(0, HEADER + PAD - minY)
- const width = Math.max((group.width as number) ?? 320, maxX + shiftX + PAD)
- const height = Math.max((group.height as number) ?? 220, maxY + shiftY + PAD)
-
- set({
- nodes: nodes.map((n) => {
- if (n.id === groupId) {
- return {
- ...n,
- position: { x: n.position.x - shiftX, y: n.position.y - shiftY },
- width,
- height,
- style: { ...n.style, width, height },
- }
- }
- if (n.parentId === groupId) {
- return { ...n, position: { x: n.position.x + shiftX, y: n.position.y + shiftY } }
- }
- return n
- }),
- })
- },
-
- setNodes: (updater) => set((state) => ({ nodes: updater(state.nodes) })),
- setSelectedIds: (ids) => set({ selectedIds: ids }),
- clearHelperLines: () => set({ helperLines: { snapPosition: {} } }),
-
save: () => {
const { nodes, edges, drawings } = get()
if (typeof window === "undefined") return
diff --git a/openspec/changes/runtime-conformance-next-granularity/proposal.md b/openspec/changes/runtime-conformance-next-granularity/proposal.md
new file mode 100644
index 0000000..acba22f
--- /dev/null
+++ b/openspec/changes/runtime-conformance-next-granularity/proposal.md
@@ -0,0 +1,48 @@
+## Why
+
+The first workflow runtime conformance slice proves registry declaration,
+fixture execution, and observed `/events` snapshot transcripts for the current
+backend path. It intentionally leaves config-blocked evidence, SSE parity,
+ODP/Redis mirroring, full node I/O contracts, and real webhook delivery outside
+that first slice.
+
+Those items are coupled, but they are not one deliverable. If they are tracked
+as a single "runtime support" task, the project can again look supported from
+Canvas labels while runtime truth remains unproven. The next conformance change
+needs a finer acceptance ladder.
+
+## What Changes
+
+- Define the next workflow runtime conformance granularity as five separately
+ verifiable layers:
+ 1. config-blocked evidence
+ 2. SSE/events-stream parity
+ 3. ODP/Redis event mirroring
+ 4. real node I/O contracts
+ 5. webhook real delivery
+- Require the implementation order to start with stable block reason taxonomy,
+ then config fixtures, then event transport parity, then node I/O contracts,
+ then webhook delivery.
+- Keep the first conformance slice truthful: it remains partial until later
+ fixture groups pass their own evidence gates.
+- Align this planning layer with `real-node-io-webhook-runtime` without claiming
+ that change is complete.
+
+## Capabilities
+
+### New Capabilities
+
+- `runtime-conformance-next-granularity`: Acceptance ladder for completing
+ workflow runtime support after the first backend conformance slice.
+
+### Modified Capabilities
+
+- `workflow-runtime-conformance`: Clarifies that partial runtime passports can
+ only become complete after all next-granularity layers are evidenced.
+
+## Impact
+
+- OpenSpec acceptance criteria for the next runtime conformance milestones.
+- A checklist that keeps config, stream transport, ODP/Redis, node I/O, and
+ webhook delivery independently testable.
+- No runtime behavior changes in this planning-only change.
diff --git a/openspec/changes/runtime-conformance-next-granularity/specs/runtime-conformance-next-granularity/spec.md b/openspec/changes/runtime-conformance-next-granularity/specs/runtime-conformance-next-granularity/spec.md
new file mode 100644
index 0000000..369b35e
--- /dev/null
+++ b/openspec/changes/runtime-conformance-next-granularity/specs/runtime-conformance-next-granularity/spec.md
@@ -0,0 +1,80 @@
+## ADDED Requirements
+
+### Requirement: Next runtime conformance is layered
+The project SHALL complete workflow runtime conformance through separately
+verifiable layers rather than a single broad runtime-support claim.
+
+#### Scenario: Layers are ordered
+- **WHEN** planning work after the first backend conformance slice
+- **THEN** the acceptance order is block reason taxonomy, config-blocked fixtures, SSE parity with `/events` snapshot, ODP/Redis event mirror, real node I/O contracts, and webhook real delivery.
+
+#### Scenario: First slice remains partial
+- **WHEN** only the current `/events` snapshot conformance slice has passed
+- **THEN** generated runtime passports remain `partial` and SHALL NOT claim config-blocked, SSE, ODP/Redis, real node I/O, or real webhook delivery certification.
+
+### Requirement: Config absence is blocked, not failed
+The backend SHALL expose missing runtime configuration as stable blocked
+evidence instead of failed runs or silent skips.
+
+#### Scenario: Missing webhook URL blocks delivery
+- **WHEN** `workflow.notifier.webhook.send` is selected without a configured webhook URL
+- **THEN** the run remains `valid=true`, projection status is `blocked`, and the event transcript includes a stable block reason code for missing webhook configuration.
+
+#### Scenario: Missing source credential blocks fetch
+- **WHEN** a source/fetch binding requires a credential that is absent
+- **THEN** the run remains `valid=true`, projection status is `blocked`, and the event transcript includes a stable block reason code for missing source credential.
+
+#### Scenario: Missing runtime resource blocks execution
+- **WHEN** a runtime-backed node requires a resource that cannot be resolved
+- **THEN** the run remains `valid=true`, projection status is `blocked`, and the event transcript includes a stable block reason code for missing runtime resource.
+
+### Requirement: SSE stream matches snapshot semantics
+The workflow event stream SHALL carry the same stable event facts as the
+existing `/api/v1/workflows/runs/{runId}/events` snapshot API.
+
+#### Scenario: Snapshot and stream share a matcher
+- **WHEN** a conformance run is observed through both `/events` and `/events/stream`
+- **THEN** the same expected transcript matcher can validate node id, event type, binding id, block reason code, message substring, event details subset, and block reason details subset from both sources.
+
+#### Scenario: Volatile stream fields are ignored
+- **WHEN** stream event ids, timestamps, sequence numbers, or transport framing differ from snapshot output
+- **THEN** the matcher ignores those volatile fields unless a fixture explicitly asserts ordering.
+
+### Requirement: ODP and Redis mirror runtime event evidence
+Workflow-run event evidence SHALL be available from the ODP/Redis event stream
+after the event transport layer is enabled.
+
+#### Scenario: Redis stream mirrors stable event facts
+- **WHEN** a canonical conformance run emits workflow events
+- **THEN** Redis/ODP stream output contains the same stable event facts required by the expected transcript.
+
+#### Scenario: Stream mirror does not replace public API evidence
+- **WHEN** ODP/Redis stream evidence is generated
+- **THEN** `/events` snapshot evidence remains available and both sources can be compared against the same expected transcript.
+
+### Requirement: Supported runtime bindings declare real node I/O
+Every binding marked runnable SHALL have an explicit runtime I/O contract.
+
+#### Scenario: Runnable binding has complete contract
+- **WHEN** a runtime binding is marked runnable
+- **THEN** it declares input shape, output shape, permission gate, config gate, event shape, and fixture coverage.
+
+#### Scenario: Incomplete binding is not runnable
+- **WHEN** a binding lacks input shape, output shape, permission gate, config gate, event shape, or fixture coverage
+- **THEN** Canvas and backend capability surfaces expose it as blocked, preview-only, or design-only rather than runnable.
+
+#### Scenario: Contract truth is projected without resource internals
+- **WHEN** Canvas capability/status surfaces expose a runtime binding
+- **THEN** they include the stable node I/O contract summary and do not expose secret values, service URLs, or runtime resource internals as user-entered fields.
+
+### Requirement: Webhook delivery becomes real only when all gates pass
+`workflow.notifier.webhook.send` SHALL perform real HTTP delivery only when its
+permission, configuration, and resource projection gates are satisfied.
+
+#### Scenario: Webhook sends real HTTP request
+- **WHEN** send permission is granted, webhook URL is configured, and EvidenceBatch/resource projection is available
+- **THEN** the node performs deterministic HTTP delivery and emits stable delivery evidence in the run transcript.
+
+#### Scenario: Webhook preconditions block explicitly
+- **WHEN** send permission, webhook URL, or EvidenceBatch/resource projection is missing
+- **THEN** the node does not send HTTP and emits stable blocked evidence for the unmet precondition.
diff --git a/openspec/changes/runtime-conformance-next-granularity/tasks.md b/openspec/changes/runtime-conformance-next-granularity/tasks.md
new file mode 100644
index 0000000..db7c4de
--- /dev/null
+++ b/openspec/changes/runtime-conformance-next-granularity/tasks.md
@@ -0,0 +1,49 @@
+## 1. Alignment Contract
+
+- [x] 1.1 Define the five next-granularity conformance layers.
+- [x] 1.2 Preserve the first conformance slice as partial until all later layers have evidence.
+- [x] 1.3 Align with `real-node-io-webhook-runtime` without marking its runtime work complete.
+
+## 2. Block Reason Taxonomy
+
+- [x] 2.1 Define stable block reason codes for missing config, missing source credential, missing runtime resource, missing permission, and missing runtime binding.
+- [x] 2.2 Document which block reason fields are stable matcher inputs and which fields are volatile diagnostics.
+- [x] 2.3 Add matcher support for config/resource block reason details without depending on timestamps, generated ids, or environment-specific paths.
+
+## 3. Config-Blocked Fixtures
+
+- [x] 3.1 Add a missing `webhook_url` fixture for `workflow.notifier.webhook.send`.
+- [x] 3.2 Add a missing source credential fixture for a source/fetch binding.
+- [x] 3.3 Add a missing runtime resource fixture for a runtime-backed node.
+- [x] 3.4 Verify each fixture remains `valid=true`, emits projection status `blocked`, and records stable `block_reason.code`.
+
+## 4. SSE Events Stream
+
+- [x] 4.1 Add `/api/v1/workflows/runs/{runId}/events/stream` smoke coverage for a canonical conformance run.
+- [x] 4.2 Reuse the same expected transcript matcher for `/events` snapshot and `/events/stream` output.
+- [x] 4.3 Document the volatile fields that differ between snapshot and stream events.
+
+## 5. ODP/Redis Event Mirror
+
+- [x] 5.1 Identify or add the workflow-run event publisher path for ODP/Redis.
+- [x] 5.2 Add a fixture that reads the same stable event facts from Redis/ODP stream output.
+- [x] 5.3 Verify Redis/ODP stream evidence aligns with the canonical expected transcript.
+
+## 6. Real Node I/O Contracts
+
+- [x] 6.1 Require every supported runtime binding to declare input shape, output shape, permission gate, config gate, event shape, and fixture coverage.
+- [x] 6.2 Mark bindings without that contract as blocked or design-only rather than runnable.
+- [x] 6.3 Project contract truth to Canvas capability/status surfaces without exposing resource internals as user-entered fields.
+
+## 7. Webhook Real Delivery
+
+- [x] 7.1 Connect EvidenceBatch/resource projection, send permission, and configured webhook URL for `workflow.notifier.webhook.send`.
+- [x] 7.2 Add a real HTTP delivery fixture with deterministic request capture.
+- [x] 7.3 Add negative fixtures for missing permission, missing URL, and missing EvidenceBatch/resource projection.
+- [x] 7.4 Verify success emits real delivery evidence and all unmet preconditions emit stable blocked evidence.
+
+## 8. Verification
+
+- [x] 8.1 Run `openspec validate runtime-conformance-next-granularity --strict`.
+- [x] 8.2 Run targeted pytest suites for each implemented layer as it lands.
+- [x] 8.3 Run Code Intel Pipeline and Sentrux after implementation slices, recording any baseline debt separately from conformance evidence.
diff --git a/openspec/changes/workflow-runtime-conformance/proposal.md b/openspec/changes/workflow-runtime-conformance/proposal.md
new file mode 100644
index 0000000..7c778e4
--- /dev/null
+++ b/openspec/changes/workflow-runtime-conformance/proposal.md
@@ -0,0 +1,34 @@
+## Why
+
+OpenCLI Admin can project workflow runs and expose run events, but a canvas node
+should not claim live runtime support from labels alone. Backend runtime support
+needs an executable conformance gate that proves the registry declaration,
+fixture execution, and observed event transcript agree.
+
+## What Changes
+
+- Define the first workflow runtime conformance contract for the interim
+ `/api/v1/workflows/runs/{runId}/events` source.
+- Add canonical fixture, expected transcript, and passport expectations for the
+ backend first slice.
+- Cover happy path, permission-blocked path, and unsupported missing-binding
+ path as executable evidence.
+- Record that config-blocked, SSE, and ODP/Redis-stream conformance are later
+ fixture groups, not part of this first backend slice.
+
+## Capabilities
+
+### New Capabilities
+
+- `workflow-runtime-conformance`: Runtime compatibility evidence from workflow
+ fixtures, expected event transcripts, and generated runtime passports.
+
+### Modified Capabilities
+
+- None.
+
+## Impact
+
+- Backend workflow conformance helpers and expected transcript goldens.
+- Integration tests that hit the public workflow run and run event APIs.
+- Generated conformance passports scoped to caller-provided artifact directories.
diff --git a/openspec/changes/workflow-runtime-conformance/specs/workflow-runtime-conformance/spec.md b/openspec/changes/workflow-runtime-conformance/specs/workflow-runtime-conformance/spec.md
new file mode 100644
index 0000000..01d3e61
--- /dev/null
+++ b/openspec/changes/workflow-runtime-conformance/specs/workflow-runtime-conformance/spec.md
@@ -0,0 +1,43 @@
+## ADDED Requirements
+
+### Requirement: Runtime support is proved by executable conformance evidence
+The backend SHALL treat workflow runtime compatibility as the combination of a
+registry declaration, an executable workflow fixture, and an observed event
+transcript from the public workflow-run event API.
+
+#### Scenario: Happy path emits expected runtime evidence
+- **WHEN** the canonical conformance workflow runs with deterministic source outputs and configured notification delivery
+- **THEN** `/api/v1/workflows/runs/{runId}/events` contains expected transcript evidence for `workflow.source.fetch`, `workflow.transform.normalize`, `workflow.router.route`, `workflow.inbox.store`, and `workflow.notify.send`.
+
+#### Scenario: Permission absence is blocked, not failed
+- **WHEN** the canonical conformance workflow runs without fetch and notification permissions
+- **THEN** the run remains `valid=true`, the projection status is `blocked`, and event block reasons include `fetch_permission_required` and `send_permission_required`.
+
+#### Scenario: Unsupported runtime binding is explicit
+- **WHEN** a conformance fixture includes an unsupported node through the normal compile/runtime path
+- **THEN** the run remains `valid=true`, the projection status is `blocked`, and the unsupported node emits `missing_runtime_binding`.
+
+### Requirement: Expected transcripts ignore volatile event fields
+The conformance matcher SHALL compare stable event facts while ignoring volatile
+fields such as run id, trace id, generated event id, timestamp, and sequence
+numbers unless a case explicitly asserts ordering.
+
+#### Scenario: Stable event facts match
+- **WHEN** the matcher evaluates an expected event
+- **THEN** it checks node id, event type, optional binding id, optional block reason code, message substring, event details subset, and block reason details subset.
+
+### Requirement: Runtime passports are generated artifacts
+The backend SHALL write generated `opencli-runtime-passport.json` files only
+under a caller-provided artifact directory.
+
+#### Scenario: Passport is artifact-scoped
+- **WHEN** the conformance harness writes a runtime passport
+- **THEN** the file is created under the provided artifact directory and not at the repository root.
+
+### Requirement: Later conformance groups remain out of the first slice
+The first backend conformance slice SHALL NOT claim config-blocked, SSE stream,
+or ODP/Redis-stream certification.
+
+#### Scenario: Later groups are documented as follow-up
+- **WHEN** first-slice evidence is generated
+- **THEN** the runtime passport status remains `partial` until later fixture groups are implemented.
diff --git a/openspec/changes/workflow-runtime-conformance/tasks.md b/openspec/changes/workflow-runtime-conformance/tasks.md
new file mode 100644
index 0000000..080e560
--- /dev/null
+++ b/openspec/changes/workflow-runtime-conformance/tasks.md
@@ -0,0 +1,19 @@
+## 1. Contract
+
+- [x] 1.1 Define the workflow runtime conformance OpenSpec capability.
+- [x] 1.2 Specify the first-slice event source, fixture expectations, and runtime passport.
+- [x] 1.3 Mark config-blocked, SSE, and ODP/Redis stream conformance as later fixture groups.
+
+## 2. Backend Harness
+
+- [x] 2.1 Add canonical workflow conformance fixture builders.
+- [x] 2.2 Add expected event transcript schemas and matcher.
+- [x] 2.3 Add expected transcript golden files for happy, permission-blocked, and missing-binding cases.
+- [x] 2.4 Add runtime passport artifact writer scoped to caller-provided output directories.
+
+## 3. Verification
+
+- [x] 3.1 Add integration tests for the first conformance slice.
+- [x] 3.2 Run `.\.venv\Scripts\python.exe -m pytest tests\integration\test_workflow_conformance.py -q --no-cov`.
+- [x] 3.3 Run `openspec validate workflow-runtime-conformance --strict`.
+- [x] 3.4 Re-run code-intel/Sentrux checks and record the existing frontend hotspot as baseline debt.
diff --git a/scripts/install-agent.sh b/scripts/install-agent.sh
index 7726ae1..2bd0d8c 100755
--- a/scripts/install-agent.sh
+++ b/scripts/install-agent.sh
@@ -78,7 +78,7 @@ if [[ "$INSTALL_CHROME" == "true" ]]; then
else
CHROME_SUFFIX=""
fi
-AGENT_IMAGE="xjh1994/opencli-admin-agent:${IMAGE_TAG}${CHROME_SUFFIX}"
+AGENT_IMAGE="${DOCKER_IMAGE_NAMESPACE:-2233admin}/opencli-admin-agent:${IMAGE_TAG}${CHROME_SUFFIX}"
# ─────────────────────────────────────────────────────────────────────────────
diff --git a/tests/fixtures/__init__.py b/tests/fixtures/__init__.py
new file mode 100644
index 0000000..10fa52d
--- /dev/null
+++ b/tests/fixtures/__init__.py
@@ -0,0 +1 @@
+"""Shared test fixture builders."""
diff --git a/tests/fixtures/workflow_conformance.py b/tests/fixtures/workflow_conformance.py
new file mode 100644
index 0000000..8c4950d
--- /dev/null
+++ b/tests/fixtures/workflow_conformance.py
@@ -0,0 +1,275 @@
+"""Canonical workflow runtime conformance fixtures."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Any
+
+EXPECTED_FIRST_SLICE_BINDINGS = [
+ "workflow.source.fetch",
+ "workflow.transform.normalize",
+ "workflow.router.route",
+ "workflow.inbox.store",
+ "workflow.notify.send",
+]
+
+
+def workflow_conformance_project(
+ *,
+ can_fetch_network: bool = True,
+ can_send_notifications: bool = True,
+ delivery_configured: bool = True,
+ include_unsupported_node: bool = False,
+) -> dict[str, Any]:
+ notify_config: dict[str, Any] = {
+ "notifierType": "operator-preview",
+ "target": "simulated-webhook",
+ }
+ if delivery_configured:
+ notify_config["url"] = "mock://opencli-conformance/notify"
+
+ project: dict[str, Any] = {
+ "id": "workflow-runtime-conformance",
+ "name": "Runtime Conformance",
+ "profile": "intelligence",
+ "version": 1,
+ "settings": {
+ "timezone": "Asia/Shanghai",
+ "deterministicSimulation": True,
+ "maxItemsPerRun": 20,
+ },
+ "adapters": [
+ {
+ "id": "jin10-kuaixun",
+ "type": "source",
+ "provider": "jin10",
+ "mode": "fixture",
+ "config": {"feed": "kuaixun"},
+ },
+ {
+ "id": "simulated-webhook",
+ "type": "notification",
+ "provider": "operator-preview",
+ "mode": "mock",
+ "config": notify_config,
+ },
+ ],
+ "agentPermissions": {
+ "canFetchNetwork": can_fetch_network,
+ "canSendNotifications": can_send_notifications,
+ "canWriteInbox": True,
+ "allowedDomains": ["jin10.com"],
+ },
+ "nodes": [
+ {
+ "id": "source-jin10",
+ "kind": "source",
+ "capability": "fetch",
+ "adapter": "jin10-kuaixun",
+ "params": {"limit": 20, "importantOnly": False},
+ },
+ {
+ "id": "agent-normalize",
+ "kind": "agent",
+ "capability": "normalize",
+ "params": {"language": "zh-CN"},
+ },
+ {
+ "id": "router-importance",
+ "kind": "router",
+ "capability": "route",
+ "params": {"expression": "item.important === true || item.score >= 0.7"},
+ },
+ {
+ "id": "inbox-review",
+ "kind": "inbox",
+ "capability": "store",
+ "params": {"queue": "macro-watch"},
+ },
+ {
+ "id": "notify-preview",
+ "kind": "notify",
+ "capability": "send",
+ "adapter": "simulated-webhook",
+ "params": {"template": "brief", "target": "simulated-webhook"},
+ },
+ ],
+ "edges": [
+ {
+ "id": "e-source-normalize",
+ "source": "source-jin10",
+ "target": "agent-normalize",
+ },
+ {
+ "id": "e-normalize-router",
+ "source": "agent-normalize",
+ "target": "router-importance",
+ },
+ {
+ "id": "e-router-inbox",
+ "source": "router-importance",
+ "target": "inbox-review",
+ },
+ {
+ "id": "e-router-notify",
+ "source": "router-importance",
+ "target": "notify-preview",
+ },
+ ],
+ }
+
+ if include_unsupported_node:
+ project["nodes"].append(
+ {
+ "id": "unsupported-export",
+ "kind": "action",
+ "capability": "summarize",
+ "params": {"format": "pdf"},
+ }
+ )
+ project["edges"].append(
+ {
+ "id": "e-router-unsupported",
+ "source": "router-importance",
+ "target": "unsupported-export",
+ }
+ )
+
+ return project
+
+
+def workflow_conformance_source_outputs() -> dict[str, list[dict[str, Any]]]:
+ return {
+ "source-jin10": [
+ {
+ "id": "macro-1",
+ "title": "Fed signal: watch rates",
+ "url": "https://www.jin10.com/flash/macro-1",
+ "important": True,
+ "score": 0.91,
+ },
+ {
+ "id": "macro-2",
+ "title": "Low-signal item",
+ "url": "https://www.jin10.com/flash/macro-2",
+ "important": False,
+ "score": 0.22,
+ },
+ ]
+ }
+
+
+def workflow_conformance_missing_webhook_url_project() -> dict[str, Any]:
+ project = workflow_conformance_project()
+ project["adapters"] = [
+ adapter for adapter in project["adapters"] if adapter["id"] != "simulated-webhook"
+ ]
+ project["adapters"].append(
+ {
+ "id": "webhook-notifier",
+ "type": "notification",
+ "provider": "webhook",
+ "mode": "live",
+ "config": {
+ "notifierType": "webhook",
+ "target": "webhook",
+ },
+ }
+ )
+ for node in project["nodes"]:
+ if node["id"] == "notify-preview":
+ node.update(
+ {
+ "id": "notify-webhook",
+ "adapter": "webhook-notifier",
+ "params": {"template": "brief", "target": "webhook"},
+ "ui": {"catalogId": "intelligence.output.webhook"},
+ }
+ )
+ for edge in project["edges"]:
+ if edge["target"] == "notify-preview":
+ edge["target"] = "notify-webhook"
+ return project
+
+
+def workflow_conformance_webhook_delivery_project(
+ *,
+ can_send_notifications: bool = True,
+ include_projection_edge: bool = True,
+) -> dict[str, Any]:
+ project = workflow_conformance_missing_webhook_url_project()
+ project["agentPermissions"]["canSendNotifications"] = can_send_notifications
+ for adapter in project["adapters"]:
+ if adapter["id"] == "webhook-notifier":
+ adapter["config"] = {
+ **adapter["config"],
+ "url": "https://hooks.example.com/opencli-conformance",
+ }
+ if not include_projection_edge:
+ project["edges"] = [
+ edge for edge in project["edges"] if edge["target"] != "notify-webhook"
+ ]
+ return project
+
+
+def workflow_conformance_missing_source_credential_project() -> dict[str, Any]:
+ project = workflow_conformance_project()
+ for adapter in project["adapters"]:
+ if adapter["id"] == "jin10-kuaixun":
+ adapter["mode"] = "live"
+ adapter["config"] = {
+ **adapter["config"],
+ "requiresCredential": True,
+ "requiredCredentialKey": "jin10_api_token",
+ }
+ return project
+
+
+def workflow_conformance_missing_runtime_resource_project() -> dict[str, Any]:
+ return {
+ "id": "workflow-runtime-conformance-resource",
+ "name": "Runtime Conformance Resource",
+ "profile": "intelligence",
+ "version": 1,
+ "nodes": [
+ {
+ "id": "publish-turbopush",
+ "kind": "notify",
+ "capability": "send",
+ "adapter": "turbopush-local",
+ "params": {
+ "contentType": "graph_text",
+ "contentSource": "upstream",
+ "title": "{{item.title}}",
+ "desc": "{{item.summary}}",
+ "targetPlatforms": ["xiaohongshu"],
+ "accountSelector": "logged_accounts_by_platform",
+ "syncDraft": False,
+ },
+ "ui": {"catalogId": "intelligence.output.turbopush-publish"},
+ }
+ ],
+ "edges": [],
+ "adapters": [
+ {
+ "id": "turbopush-local",
+ "type": "notification",
+ "provider": "turbopush",
+ "mode": "live",
+ "config": {
+ "channel": "turbopush",
+ "mcpServer": "turbo-push",
+ "resourceMode": "auto",
+ },
+ }
+ ],
+ "agentPermissions": {
+ "canFetchNetwork": True,
+ "canSendNotifications": True,
+ "canWriteInbox": True,
+ },
+ }
+
+
+def copy_workflow_fixture(project: dict[str, Any]) -> dict[str, Any]:
+ return deepcopy(project)
diff --git a/tests/integration/test_generic_webhook_live.py b/tests/integration/test_generic_webhook_live.py
new file mode 100644
index 0000000..86dd4c3
--- /dev/null
+++ b/tests/integration/test_generic_webhook_live.py
@@ -0,0 +1,97 @@
+"""Live generic webhook delivery acceptance tests."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import re
+import time
+
+import httpx
+import pytest
+
+from backend.workflow.webhook_delivery import (
+ WEBHOOK_DELIVERY_EVENT,
+ WEBHOOK_DELIVERY_PAYLOAD_SCHEMA,
+ execute_workflow_webhook_delivery,
+)
+
+WEBHOOK_SITE_TOKEN_API = "https://webhook.site/token"
+WEBHOOK_SITE_URL_RE = re.compile(
+ r"^https://webhook\.site/(?P[0-9a-fA-F-]{36})(?:[/?#].*)?$"
+)
+
+
+@pytest.mark.live
+@pytest.mark.asyncio
+async def test_generic_webhook_live_delivery_posts_public_http_request() -> None:
+ target_url, webhook_site_token = await _resolve_live_webhook_target()
+ run_id = f"generic-webhook-live-{int(time.time())}"
+
+ result = await execute_workflow_webhook_delivery(
+ {
+ "target": "generic-webhook-live",
+ "url": target_url,
+ "config": {"timeout": 30},
+ },
+ [
+ {
+ "raw": {
+ "id": "live-item-1",
+ "title": "WSL generic webhook live acceptance",
+ "url": "https://example.com/opencli-admin-backend/live-webhook",
+ },
+ "lineage": [{"source": "pytest-live", "runId": run_id}],
+ }
+ ],
+ workflow_id="opencli-admin-backend",
+ run_id=run_id,
+ node_id="notify-webhook",
+ )
+
+ assert result == {
+ "notifierType": "webhook",
+ "target": "generic-webhook-live",
+ "deliveryAttempted": True,
+ "delivered": True,
+ "event": WEBHOOK_DELIVERY_EVENT,
+ "payloadSchema": WEBHOOK_DELIVERY_PAYLOAD_SCHEMA,
+ "itemCount": 1,
+ }
+
+ if webhook_site_token:
+ captured = await _read_webhook_site_latest_payload(webhook_site_token)
+ assert captured["event"] == WEBHOOK_DELIVERY_EVENT
+ assert captured["source_id"] == "opencli-admin-backend"
+ assert captured["record_id"] == run_id
+ assert captured["data"]["schema"] == WEBHOOK_DELIVERY_PAYLOAD_SCHEMA
+ assert captured["data"]["nodeId"] == "notify-webhook"
+ assert captured["data"]["items"][0]["title"] == "WSL generic webhook live acceptance"
+
+
+async def _resolve_live_webhook_target() -> tuple[str, str | None]:
+ configured_url = os.environ.get("OPENCLI_GENERIC_WEBHOOK_LIVE_URL", "").strip()
+ if configured_url:
+ return configured_url, _webhook_site_token_from_url(configured_url)
+
+ async with httpx.AsyncClient(timeout=30) as client:
+ response = await client.post(WEBHOOK_SITE_TOKEN_API)
+ response.raise_for_status()
+ token = response.json()["uuid"]
+ return f"https://webhook.site/{token}", token
+
+
+def _webhook_site_token_from_url(url: str) -> str | None:
+ match = WEBHOOK_SITE_URL_RE.match(url)
+ return match.group("token") if match else None
+
+
+async def _read_webhook_site_latest_payload(token: str) -> dict:
+ latest_url = f"{WEBHOOK_SITE_TOKEN_API}/{token}/request/latest/raw"
+ async with httpx.AsyncClient(timeout=30) as client:
+ for _ in range(10):
+ response = await client.get(latest_url, headers={"accept": "application/json"})
+ if response.status_code == 200 and response.text.strip():
+ return response.json()
+ await asyncio.sleep(1)
+ raise AssertionError("Webhook.site did not expose the latest request payload in time")
diff --git a/tests/integration/test_workflow_capabilities_api.py b/tests/integration/test_workflow_capabilities_api.py
index efd6ce3..0035740 100644
--- a/tests/integration/test_workflow_capabilities_api.py
+++ b/tests/integration/test_workflow_capabilities_api.py
@@ -120,6 +120,10 @@ async def test_compile_reports_webhook_notify_contract_without_live_delivery(cli
assert node["runtime"]["notifier"]["binding_id"] == "workflow.notifier.webhook.send"
assert node["runtime"]["notifier"]["dispatch"] == "blocked_until_projection"
assert node["runtime"]["notifier"]["input"]["delivery_configured"] is False
+ notifier_contract = node["runtime"]["notifier"]["contract"]
+ assert notifier_contract["bindingId"] == "workflow.notifier.webhook.send"
+ assert notifier_contract["certification"]["realNodeIoContract"] is True
+ assert notifier_contract["certification"]["realWebhookDelivery"] is True
assert node["runtime"]["missing_runtime"] == {
"status": "missing",
"code": "missing_delivery_projection",
@@ -161,6 +165,16 @@ async def test_workflow_capabilities_project_real_backend_surfaces(client, monke
data = response.json()["data"]
catalog = {item["id"]: item for item in data["catalog"]}
+ for item in catalog.values():
+ if item["status"] == "runnable" and item.get("runtimeBinding"):
+ contract = item["manifest"]["contract"]
+ assert contract["bindingId"] == item["runtimeBinding"]
+ assert contract["inputShape"]["ports"] is not None
+ assert contract["outputShape"]["ports"] is not None
+ assert contract["eventShape"]["events"]
+ assert contract["fixtureCoverage"]["cases"]
+ assert contract["canvas"]["exposeResourceInternals"] is False
+
assert catalog["intelligence.input.collection-need"]["status"] == "runnable"
assert catalog["intelligence.input.collection-need"]["backendAvailable"] is True
assert catalog["intelligence.input.collection-need"]["runtimeBinding"] == (
@@ -256,7 +270,15 @@ async def test_workflow_capabilities_project_real_backend_surfaces(client, monke
"workflow.notifier.webhook.send"
)
assert "workflow_notifier_sink_binding" not in catalog["intelligence.output.webhook"]["missing"]
- assert "delivery_projection" in catalog["intelligence.output.webhook"]["missing"]
+ assert "evidencebatch_projection_input" in catalog["intelligence.output.webhook"]["missing"]
+ webhook_contract = catalog["intelligence.output.webhook"]["manifest"]["contract"]
+ assert webhook_contract["status"] == "blocked_until_preconditions"
+ assert webhook_contract["certification"]["realWebhookDelivery"] is True
+ assert webhook_contract["configGate"]["required"] == [
+ "evidencebatch_projection_api",
+ "delivery_projection",
+ "webhook_url",
+ ]
channels = {item["channelType"]: item for item in data["channels"]}
assert set(channels) == {
@@ -279,7 +301,7 @@ async def test_workflow_capabilities_project_real_backend_surfaces(client, monke
assert notifiers["webhook"]["status"] == "blocked"
assert notifiers["webhook"]["backendAvailable"] is True
assert notifiers["webhook"]["runtimeBinding"] == "workflow.notifier.webhook.send"
- assert "delivery_projection" in notifiers["webhook"]["missing"]
+ assert "evidencebatch_projection_input" in notifiers["webhook"]["missing"]
primitives = {item["id"]: item for item in data["primitives"]}
assert primitives["primitive.ops.trigger-webhook"]["status"] == "blocked"
diff --git a/tests/integration/test_workflow_compile_api.py b/tests/integration/test_workflow_compile_api.py
index 47c8f63..c14f305 100644
--- a/tests/integration/test_workflow_compile_api.py
+++ b/tests/integration/test_workflow_compile_api.py
@@ -3,6 +3,13 @@
import pytest
+def _assert_binding_includes(actual: dict, expected: dict) -> None:
+ for key, value in expected.items():
+ assert actual.get(key) == value
+ if "contract" in actual:
+ assert actual["contract"]["bindingId"] == expected["binding_id"]
+
+
def _valid_workflow_project() -> dict:
return {
"id": "wf-opencli-multi-source",
@@ -274,7 +281,7 @@ async def test_compile_resolves_opencli_source_to_iii_runtime_binding(client):
runtime = response.json()["data"]["plan"]["runtime"]
source_node = runtime["nodes"][0]
assert source_node["id"] == "source-bilibili"
- assert source_node["runtime"]["binding"] == {
+ _assert_binding_includes(source_node["runtime"]["binding"], {
"status": "bound",
"binding_id": "iii.collector-opencli.snapshot",
"runtime": "iii",
@@ -282,7 +289,7 @@ async def test_compile_resolves_opencli_source_to_iii_runtime_binding(client):
"function_id": "odp.collect::opencli_snapshot",
"channel": "opencli",
"input": {"site": "bilibili", "command": "search"},
- }
+ })
@pytest.mark.asyncio
@@ -407,7 +414,7 @@ async def test_compile_resolves_normalize_to_native_transform_binding(client):
runtime_nodes = response.json()["data"]["plan"]["runtime"]["nodes"]
normalize_node = runtime_nodes[1]
assert normalize_node["id"] == "normalize-items"
- assert normalize_node["runtime"]["binding"] == {
+ _assert_binding_includes(normalize_node["runtime"]["binding"], {
"status": "bound",
"binding_id": "workflow.transform.normalize",
"runtime": "workflow",
@@ -418,7 +425,7 @@ async def test_compile_resolves_normalize_to_native_transform_binding(client):
"inputPort": "items[]",
"outputPort": "recordCandidate[]",
},
- }
+ })
assert normalize_node["runtime"]["normalize"] == {
"node_id": "normalize-items",
"candidate_port": "recordCandidate[]",
@@ -1026,7 +1033,7 @@ async def test_compile_resolves_schedule_trigger_binding(client):
if node["id"] == "schedule-cron"
)
assert node["runtime"]["origin"]["catalog_id"] == "intelligence.schedule.cron"
- assert node["runtime"]["binding"] == {
+ _assert_binding_includes(node["runtime"]["binding"], {
"status": "bound",
"binding_id": "workflow.trigger.schedule_tick",
"runtime": "workflow",
@@ -1036,7 +1043,7 @@ async def test_compile_resolves_schedule_trigger_binding(client):
"timezone": "Asia/Shanghai",
"enabled": True,
},
- }
+ })
assert node["runtime"]["trigger"] == {
"node_id": "schedule-cron",
"mode": "manual_schedule_tick",
diff --git a/tests/integration/test_workflow_conformance.py b/tests/integration/test_workflow_conformance.py
new file mode 100644
index 0000000..ae50a22
--- /dev/null
+++ b/tests/integration/test_workflow_conformance.py
@@ -0,0 +1,586 @@
+"""Executable workflow runtime conformance tests."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import httpx
+import pytest
+
+from backend.workflow.block_reasons import WORKFLOW_BLOCK_REASON_TAXONOMY
+from backend.workflow.conformance import (
+ ConformanceCaseResult,
+ load_expected_events,
+ match_expected_events,
+ parse_sse_node_events,
+ write_runtime_passport,
+)
+from backend.workflow.event_mirror import (
+ DEFAULT_WORKFLOW_EVENT_STREAM,
+ WORKFLOW_EVENT_MIRROR_PROVIDER,
+ list_workflow_event_mirror_records,
+ list_workflow_event_mirror_transcript,
+)
+from backend.workflow.runtime_contracts import list_runtime_io_contracts
+from tests.fixtures.workflow_conformance import (
+ EXPECTED_FIRST_SLICE_BINDINGS,
+ workflow_conformance_missing_runtime_resource_project,
+ workflow_conformance_missing_source_credential_project,
+ workflow_conformance_missing_webhook_url_project,
+ workflow_conformance_project,
+ workflow_conformance_source_outputs,
+ workflow_conformance_webhook_delivery_project,
+)
+
+EXPECTED_EVENTS_DIR = (
+ Path(__file__).parents[2] / "backend" / "workflow" / "conformance" / "expected_events"
+)
+
+
+class _FakeRedisStream:
+ def __init__(self) -> None:
+ self.entries: list[tuple[str, str, dict[str, str]]] = []
+ self.closed = False
+
+ async def xadd(self, stream: str, fields: dict[str, str]) -> str:
+ entry_id = f"fake-{len(self.entries) + 1}"
+ self.entries.append((stream, entry_id, fields))
+ return entry_id
+
+ async def xrange(self, stream: str, min: str = "-", max: str = "+"):
+ return [
+ (entry_id, fields)
+ for entry_stream, entry_id, fields in self.entries
+ if entry_stream == stream
+ ]
+
+ async def aclose(self) -> None:
+ self.closed = True
+
+
+def test_workflow_conformance_block_reason_taxonomy_defines_next_layer_codes():
+ expected_categories = {
+ "fetch_permission_required": "missing_permission",
+ "send_permission_required": "missing_permission",
+ "missing_delivery_projection": "missing_config",
+ "missing_source_credential": "missing_source_credential",
+ "missing_turbopush_service": "missing_runtime_resource",
+ "missing_runtime_binding": "missing_runtime_binding",
+ "missing_runtime_io_contract": "missing_runtime_binding",
+ }
+
+ for code, category in expected_categories.items():
+ definition = WORKFLOW_BLOCK_REASON_TAXONOMY[code]
+ assert definition.category == category
+ assert definition.stable_fields
+
+
+def test_workflow_conformance_real_node_io_contract_manifest_is_complete():
+ required_keys = {
+ "bindingId",
+ "inputShape",
+ "outputShape",
+ "permissionGate",
+ "configGate",
+ "eventShape",
+ "fixtureCoverage",
+ "certification",
+ }
+
+ contracts = list_runtime_io_contracts()
+ assert contracts
+ for contract in contracts:
+ manifest = contract.to_manifest()
+ assert required_keys.issubset(manifest)
+ assert manifest["bindingId"] == contract.binding_id
+ assert isinstance(manifest["inputShape"]["ports"], list)
+ assert isinstance(manifest["outputShape"]["ports"], list)
+ assert manifest["eventShape"]["events"]
+ assert manifest["fixtureCoverage"]["cases"]
+ assert manifest["certification"]["realNodeIoContract"] is True
+
+ webhook_contract = next(
+ contract
+ for contract in contracts
+ if contract.binding_id == "workflow.notifier.webhook.send"
+ ).to_manifest()
+ assert webhook_contract["status"] == "blocked_until_preconditions"
+ assert webhook_contract["certification"]["realWebhookDelivery"] is True
+ assert webhook_contract["configGate"]["required"] == [
+ "evidencebatch_projection_api",
+ "delivery_projection",
+ "webhook_url",
+ ]
+
+
+@pytest.mark.asyncio
+async def test_workflow_conformance_happy_path_matches_expected_transcript(client):
+ run_id = "conformance-happy-path"
+ response = await client.post(
+ "/api/v1/workflows/runs",
+ json={
+ "project": workflow_conformance_project(),
+ "runId": run_id,
+ "traceId": "trace-conformance-happy-path",
+ "sourceOutputs": workflow_conformance_source_outputs(),
+ },
+ )
+
+ assert response.status_code == 202
+ projection = response.json()["data"]
+ assert projection["valid"] is True
+ assert projection["status"] == "completed"
+
+ events = (await client.get(f"/api/v1/workflows/runs/{run_id}/events")).json()["data"]
+ match = match_expected_events(
+ events,
+ load_expected_events(EXPECTED_EVENTS_DIR / "happy-path.json"),
+ )
+
+ assert match.passed, match.failures
+
+
+@pytest.mark.asyncio
+async def test_workflow_conformance_compile_projects_real_node_io_contracts(client):
+ response = await client.post(
+ "/api/v1/workflows/compile",
+ json={"project": workflow_conformance_project()},
+ )
+
+ assert response.status_code == 200
+ data = response.json()["data"]
+ assert data["valid"] is True
+ bound_nodes = [
+ node
+ for node in data["plan"]["runtime"]["nodes"]
+ if isinstance(node["runtime"].get("binding"), dict)
+ ]
+ assert bound_nodes
+
+ for node in bound_nodes:
+ binding = node["runtime"]["binding"]
+ contract = binding["contract"]
+ assert contract["bindingId"] == binding["binding_id"]
+ assert contract["certification"]["realNodeIoContract"] is True
+ assert set(contract) >= {
+ "inputShape",
+ "outputShape",
+ "permissionGate",
+ "configGate",
+ "eventShape",
+ "fixtureCoverage",
+ }
+
+
+@pytest.mark.asyncio
+async def test_workflow_conformance_sse_stream_matches_snapshot_transcript(client):
+ run_id = "conformance-sse-parity"
+ response = await client.post(
+ "/api/v1/workflows/runs",
+ json={
+ "project": workflow_conformance_project(),
+ "runId": run_id,
+ "traceId": "trace-conformance-sse-parity",
+ "sourceOutputs": workflow_conformance_source_outputs(),
+ },
+ )
+
+ assert response.status_code == 202
+ expected = load_expected_events(EXPECTED_EVENTS_DIR / "happy-path.json")
+
+ snapshot_events = (await client.get(f"/api/v1/workflows/runs/{run_id}/events")).json()["data"]
+ snapshot_match = match_expected_events(snapshot_events, expected)
+ assert snapshot_match.passed, snapshot_match.failures
+
+ stream_response = await client.get(f"/api/v1/workflows/runs/{run_id}/events/stream")
+ assert stream_response.status_code == 200
+ assert stream_response.headers["content-type"].startswith("text/event-stream")
+ stream_events = parse_sse_node_events(stream_response.text)
+ stream_match = match_expected_events(stream_events, expected)
+ assert stream_match.passed, stream_match.failures
+
+
+@pytest.mark.asyncio
+async def test_workflow_conformance_redis_event_mirror_matches_snapshot_transcript(
+ client,
+ monkeypatch,
+):
+ import redis.asyncio as aioredis
+
+ fake_redis = _FakeRedisStream()
+ monkeypatch.setenv("WORKFLOW_EVENT_MIRROR_BACKEND", "redis")
+ monkeypatch.setenv("WORKFLOW_EVENT_MIRROR_REDIS_URL", "redis://conformance-redis/0")
+ monkeypatch.setenv("WORKFLOW_EVENT_MIRROR_STREAM", DEFAULT_WORKFLOW_EVENT_STREAM)
+ monkeypatch.setattr(aioredis, "from_url", lambda *args, **kwargs: fake_redis)
+
+ run_id = "conformance-redis-event-mirror"
+ response = await client.post(
+ "/api/v1/workflows/runs",
+ json={
+ "project": workflow_conformance_project(),
+ "runId": run_id,
+ "traceId": "trace-conformance-redis-event-mirror",
+ "sourceOutputs": workflow_conformance_source_outputs(),
+ },
+ )
+
+ assert response.status_code == 202
+ assert {entry[0] for entry in fake_redis.entries} == {DEFAULT_WORKFLOW_EVENT_STREAM}
+
+ expected = load_expected_events(EXPECTED_EVENTS_DIR / "happy-path.json")
+ mirror_events = await list_workflow_event_mirror_transcript(
+ run_id,
+ backend="redis",
+ stream=DEFAULT_WORKFLOW_EVENT_STREAM,
+ )
+ mirror_match = match_expected_events(mirror_events, expected)
+ assert mirror_match.passed, mirror_match.failures
+
+ mirror_records = await list_workflow_event_mirror_records(
+ run_id,
+ backend="redis",
+ stream=DEFAULT_WORKFLOW_EVENT_STREAM,
+ )
+ assert mirror_records
+ assert {record.provider for record in mirror_records} == {WORKFLOW_EVENT_MIRROR_PROVIDER}
+ assert {record.ingest_mode for record in mirror_records} == {"stream"}
+ assert all(record.stable_facts["nodeId"] for record in mirror_records)
+
+
+@pytest.mark.asyncio
+async def test_workflow_conformance_missing_webhook_url_blocks_with_stable_reason(client):
+ run_id = "conformance-missing-webhook-url"
+ response = await client.post(
+ "/api/v1/workflows/runs",
+ json={
+ "project": workflow_conformance_missing_webhook_url_project(),
+ "runId": run_id,
+ "traceId": "trace-conformance-missing-webhook-url",
+ "sourceOutputs": workflow_conformance_source_outputs(),
+ },
+ )
+
+ assert response.status_code == 202
+ projection = response.json()["data"]
+ assert projection["valid"] is True
+ assert projection["status"] == "blocked"
+ states = {state["nodeId"]: state for state in projection["nodeStates"]}
+ assert states["notify-webhook"]["blockReasons"][0]["code"] == ("missing_delivery_projection")
+
+ events = (await client.get(f"/api/v1/workflows/runs/{run_id}/events")).json()["data"]
+ match = match_expected_events(
+ events,
+ load_expected_events(EXPECTED_EVENTS_DIR / "missing-webhook-url.json"),
+ )
+
+ assert match.passed, match.failures
+
+
+@pytest.mark.asyncio
+async def test_workflow_conformance_webhook_real_delivery_emits_http_request(
+ client,
+ monkeypatch,
+):
+ captured_requests: list[httpx.Request] = []
+
+ async def fake_guarded_async_client(url: str, **client_kwargs):
+ async def handler(request: httpx.Request) -> httpx.Response:
+ captured_requests.append(request)
+ return httpx.Response(202, json={"ok": True}, request=request)
+
+ return httpx.AsyncClient(transport=httpx.MockTransport(handler)), url
+
+ monkeypatch.setattr(
+ "backend.notifiers.webhook_notifier.guarded_async_client",
+ fake_guarded_async_client,
+ )
+
+ run_id = "conformance-webhook-real-delivery"
+ response = await client.post(
+ "/api/v1/workflows/runs",
+ json={
+ "project": workflow_conformance_webhook_delivery_project(),
+ "runId": run_id,
+ "traceId": "trace-conformance-webhook-real-delivery",
+ "sourceOutputs": workflow_conformance_source_outputs(),
+ },
+ )
+
+ assert response.status_code == 202
+ projection = response.json()["data"]
+ assert projection["valid"] is True
+ assert projection["status"] == "completed"
+
+ events = (await client.get(f"/api/v1/workflows/runs/{run_id}/events")).json()["data"]
+ match = match_expected_events(
+ events,
+ load_expected_events(EXPECTED_EVENTS_DIR / "webhook-real-delivery.json"),
+ )
+ assert match.passed, match.failures
+
+ assert len(captured_requests) == 1
+ request = captured_requests[0]
+ assert request.method == "POST"
+ assert str(request.url) == "https://hooks.example.com/opencli-conformance"
+ body = json.loads(request.content.decode("utf-8"))
+ assert body["event"] == "workflow.evidence_batch.ready"
+ assert body["source_id"] == "workflow-runtime-conformance"
+ assert body["record_id"] == run_id
+ assert body["data"]["schema"] == "workflow.webhook.evidence_batch.v1"
+ assert body["data"]["workflowRunId"] == run_id
+ assert body["data"]["nodeId"] == "notify-webhook"
+ assert body["data"]["itemCount"] == 1
+ assert body["data"]["items"][0]["title"] == "Fed signal: watch rates"
+
+
+@pytest.mark.asyncio
+async def test_workflow_conformance_webhook_delivery_blocks_without_send_permission(
+ client,
+ monkeypatch,
+):
+ captured_requests: list[httpx.Request] = []
+
+ async def fake_guarded_async_client(url: str, **client_kwargs):
+ async def handler(request: httpx.Request) -> httpx.Response:
+ captured_requests.append(request)
+ return httpx.Response(202, request=request)
+
+ return httpx.AsyncClient(transport=httpx.MockTransport(handler)), url
+
+ monkeypatch.setattr(
+ "backend.notifiers.webhook_notifier.guarded_async_client",
+ fake_guarded_async_client,
+ )
+
+ run_id = "conformance-webhook-missing-permission"
+ response = await client.post(
+ "/api/v1/workflows/runs",
+ json={
+ "project": workflow_conformance_webhook_delivery_project(
+ can_send_notifications=False
+ ),
+ "runId": run_id,
+ "traceId": "trace-conformance-webhook-missing-permission",
+ "sourceOutputs": workflow_conformance_source_outputs(),
+ },
+ )
+
+ assert response.status_code == 202
+ projection = response.json()["data"]
+ assert projection["valid"] is True
+ assert projection["status"] == "blocked"
+ states = {state["nodeId"]: state for state in projection["nodeStates"]}
+ reason = states["notify-webhook"]["blockReasons"][0]
+ assert reason["code"] == "send_permission_required"
+ assert reason["details"]["bindingId"] == "workflow.notifier.webhook.send"
+ assert captured_requests == []
+
+
+@pytest.mark.asyncio
+async def test_workflow_conformance_webhook_delivery_blocks_without_projection(
+ client,
+ monkeypatch,
+):
+ captured_requests: list[httpx.Request] = []
+
+ async def fake_guarded_async_client(url: str, **client_kwargs):
+ async def handler(request: httpx.Request) -> httpx.Response:
+ captured_requests.append(request)
+ return httpx.Response(202, request=request)
+
+ return httpx.AsyncClient(transport=httpx.MockTransport(handler)), url
+
+ monkeypatch.setattr(
+ "backend.notifiers.webhook_notifier.guarded_async_client",
+ fake_guarded_async_client,
+ )
+
+ run_id = "conformance-webhook-missing-projection"
+ response = await client.post(
+ "/api/v1/workflows/runs",
+ json={
+ "project": workflow_conformance_webhook_delivery_project(
+ include_projection_edge=False
+ ),
+ "runId": run_id,
+ "traceId": "trace-conformance-webhook-missing-projection",
+ "sourceOutputs": workflow_conformance_source_outputs(),
+ },
+ )
+
+ assert response.status_code == 202
+ projection = response.json()["data"]
+ assert projection["valid"] is True
+ assert projection["status"] == "blocked"
+ states = {state["nodeId"]: state for state in projection["nodeStates"]}
+ reason = states["notify-webhook"]["blockReasons"][0]
+ assert reason["code"] == "missing_delivery_projection"
+ assert reason["details"]["bindingId"] == "workflow.notifier.webhook.send"
+ assert reason["details"]["required_params"] == [
+ "evidencebatch_projection_api",
+ "delivery_projection",
+ ]
+ assert captured_requests == []
+
+
+@pytest.mark.asyncio
+async def test_workflow_conformance_missing_source_credential_blocks_with_stable_reason(
+ client,
+):
+ run_id = "conformance-missing-source-credential"
+ response = await client.post(
+ "/api/v1/workflows/runs",
+ json={
+ "project": workflow_conformance_missing_source_credential_project(),
+ "runId": run_id,
+ "traceId": "trace-conformance-missing-source-credential",
+ },
+ )
+
+ assert response.status_code == 202
+ projection = response.json()["data"]
+ assert projection["valid"] is True
+ assert projection["status"] == "blocked"
+ states = {state["nodeId"]: state for state in projection["nodeStates"]}
+ assert states["source-jin10"]["blockReasons"][0]["code"] == "missing_source_credential"
+
+ events = (await client.get(f"/api/v1/workflows/runs/{run_id}/events")).json()["data"]
+ match = match_expected_events(
+ events,
+ load_expected_events(EXPECTED_EVENTS_DIR / "missing-source-credential.json"),
+ )
+
+ assert match.passed, match.failures
+
+
+@pytest.mark.asyncio
+async def test_workflow_conformance_missing_runtime_resource_blocks_with_stable_reason(
+ client,
+ monkeypatch,
+ tmp_path,
+):
+ monkeypatch.delenv("TURBO_PUSH_PORT", raising=False)
+ monkeypatch.delenv("TURBO_PUSH_AUTH", raising=False)
+ monkeypatch.setenv("TURBO_PUSH_MCP_CONFIG", str(tmp_path / "missing-mcp.json"))
+
+ run_id = "conformance-missing-runtime-resource"
+ response = await client.post(
+ "/api/v1/workflows/runs",
+ json={
+ "project": workflow_conformance_missing_runtime_resource_project(),
+ "runId": run_id,
+ "traceId": "trace-conformance-missing-runtime-resource",
+ },
+ )
+
+ assert response.status_code == 202
+ projection = response.json()["data"]
+ assert projection["valid"] is True
+ assert projection["status"] == "blocked"
+ states = {state["nodeId"]: state for state in projection["nodeStates"]}
+ assert states["publish-turbopush"]["blockReasons"][0]["code"] == ("missing_turbopush_service")
+
+ events = (await client.get(f"/api/v1/workflows/runs/{run_id}/events")).json()["data"]
+ match = match_expected_events(
+ events,
+ load_expected_events(EXPECTED_EVENTS_DIR / "missing-runtime-resource.json"),
+ )
+
+ assert match.passed, match.failures
+
+
+@pytest.mark.asyncio
+async def test_workflow_conformance_permission_blocked_transcript(client):
+ run_id = "conformance-permission-blocked"
+ response = await client.post(
+ "/api/v1/workflows/runs",
+ json={
+ "project": workflow_conformance_project(
+ can_fetch_network=False,
+ can_send_notifications=False,
+ ),
+ "runId": run_id,
+ "traceId": "trace-conformance-permission-blocked",
+ },
+ )
+
+ assert response.status_code == 202
+ projection = response.json()["data"]
+ assert projection["valid"] is True
+ assert projection["status"] == "blocked"
+
+ events = (await client.get(f"/api/v1/workflows/runs/{run_id}/events")).json()["data"]
+ match = match_expected_events(
+ events,
+ load_expected_events(EXPECTED_EVENTS_DIR / "permission-blocked.json"),
+ )
+
+ assert match.passed, match.failures
+
+
+@pytest.mark.asyncio
+async def test_workflow_conformance_missing_binding_transcript(client):
+ run_id = "conformance-missing-binding"
+ response = await client.post(
+ "/api/v1/workflows/runs",
+ json={
+ "project": workflow_conformance_project(include_unsupported_node=True),
+ "runId": run_id,
+ "traceId": "trace-conformance-missing-binding",
+ "sourceOutputs": workflow_conformance_source_outputs(),
+ },
+ )
+
+ assert response.status_code == 202
+ projection = response.json()["data"]
+ assert projection["valid"] is True
+ assert projection["status"] == "blocked"
+
+ events = (await client.get(f"/api/v1/workflows/runs/{run_id}/events")).json()["data"]
+ match = match_expected_events(
+ events,
+ load_expected_events(EXPECTED_EVENTS_DIR / "missing-binding.json"),
+ )
+
+ assert match.passed, match.failures
+
+
+def test_workflow_conformance_passport_is_artifact_scoped(tmp_path):
+ passport_path = write_runtime_passport(
+ tmp_path / "opencli-conformance" / "local-run",
+ [
+ ConformanceCaseResult(
+ id="happy-path",
+ status="passed",
+ bindings=EXPECTED_FIRST_SLICE_BINDINGS,
+ ),
+ ConformanceCaseResult(
+ id="permission-blocked",
+ status="passed",
+ bindings=["workflow.source.fetch", "workflow.notify.send"],
+ blockedReasons=[
+ "fetch_permission_required",
+ "send_permission_required",
+ ],
+ ),
+ ConformanceCaseResult(
+ id="missing-binding",
+ status="passed",
+ bindings=[],
+ blockedReasons=["missing_runtime_binding"],
+ ),
+ ],
+ )
+
+ assert passport_path.name == "opencli-runtime-passport.json"
+ assert passport_path.parent.name == "local-run"
+ passport = json.loads(passport_path.read_text(encoding="utf-8"))
+ assert passport["schemaVersion"] == 1
+ assert passport["eventSource"] == "workflow-run-events"
+ assert passport["status"] == "partial"
+ assert passport["bindings"]["workflow.notify.send"]["status"] == ("conformance-known")
+ assert (
+ "send_permission_required"
+ in (passport["bindings"]["workflow.notify.send"]["blockedReasons"])
+ )
diff --git a/tests/integration/test_workflow_opencli_hda_trace_api.py b/tests/integration/test_workflow_opencli_hda_trace_api.py
index be6cf08..8608a49 100644
--- a/tests/integration/test_workflow_opencli_hda_trace_api.py
+++ b/tests/integration/test_workflow_opencli_hda_trace_api.py
@@ -13,6 +13,7 @@
from backend.models.task import CollectionTask
from backend.models.workflow_run import WorkflowRun, WorkflowRunEvent
from backend.workflow.opencli_hda_tracer import _RUNS
+from tests.fixtures.workflow_conformance import workflow_conformance_project
def _multi_source_opencli_hda_project() -> dict:
@@ -311,6 +312,14 @@ def _native_first_loop_project() -> dict:
}
+def _legacy_canvas_intelligence_project() -> dict:
+ return workflow_conformance_project(
+ can_fetch_network=False,
+ can_send_notifications=False,
+ delivery_configured=False,
+ )
+
+
async def _seed_collected_record(
db_session,
*,
@@ -845,6 +854,93 @@ async def test_workflow_run_emits_native_first_loop_trace_events(client, db_sess
assert {task.parameters["workflowRunId"] for task in tasks} == {"run-native-first-loop"}
+@pytest.mark.asyncio
+async def test_workflow_run_resolves_legacy_canvas_runtime_bindings(client, db_session):
+ response = await client.post(
+ "/api/v1/workflows/runs",
+ json={
+ "project": _legacy_canvas_intelligence_project(),
+ "runId": "run-legacy-canvas-bindings",
+ "traceId": "trace-legacy-canvas-bindings",
+ "sourceOutputs": {
+ "source-jin10": [
+ {
+ "title": "Important macro flash",
+ "url": "https://www.jin10.com/flash/important",
+ "important": True,
+ "score": 0.91,
+ },
+ {
+ "title": "Low priority flash",
+ "url": "https://www.jin10.com/flash/low",
+ "important": False,
+ "score": 0.2,
+ },
+ ],
+ },
+ },
+ )
+
+ assert response.status_code == 202
+ data = response.json()["data"]
+ assert data["valid"] is True
+ assert data["status"] == "blocked"
+ states = {state["nodeId"]: state for state in data["nodeStates"]}
+ assert states["source-jin10"]["status"] == "completed"
+ assert states["agent-normalize"]["status"] == "completed"
+ assert states["router-importance"]["status"] == "completed"
+ assert states["inbox-review"]["status"] == "completed"
+ assert states["notify-preview"]["status"] == "blocked"
+ assert states["notify-preview"]["blockReasons"][0]["code"] == "send_permission_required"
+ assert all(
+ reason["code"] != "missing_runtime_binding"
+ for state in data["nodeStates"]
+ for reason in state["blockReasons"]
+ )
+
+ events = (
+ await client.get("/api/v1/workflows/runs/run-legacy-canvas-bindings/events")
+ ).json()["data"]
+ by_node = {}
+ for event in events:
+ by_node.setdefault(event["nodeId"], []).append(event)
+
+ source_partial = by_node["source-jin10"][2]
+ assert source_partial["details"]["itemCount"] == 2
+ assert source_partial["details"]["outputPort"] == "items[]"
+
+ router_partial = by_node["router-importance"][2]
+ assert router_partial["details"]["bindingId"] == "workflow.router.route"
+ assert router_partial["details"]["inputCandidateCount"] == 2
+ assert router_partial["details"]["routedCandidateCount"] == 1
+
+ inbox_partial = by_node["inbox-review"][2]
+ assert inbox_partial["details"]["bindingId"] == "workflow.inbox.store"
+ assert inbox_partial["details"]["target"] == "macro-watch"
+ assert inbox_partial["details"]["inputRecordCount"] == 1
+ assert inbox_partial["details"]["storedRecordCount"] == 1
+
+ notify_events = by_node["notify-preview"]
+ assert [event["eventType"] for event in notify_events] == [
+ "queued",
+ "started",
+ "blocked",
+ ]
+ assert notify_events[-1]["blockReason"]["details"]["bindingId"] == (
+ "workflow.notify.send"
+ )
+
+ records = (
+ (await db_session.execute(select(CollectedRecord).order_by(CollectedRecord.created_at)))
+ .scalars()
+ .all()
+ )
+ assert len(records) == 1
+ assert records[0].normalized_data["title"] == "Important macro flash"
+ assert records[0].raw_data["_workflowRunId"] == "run-legacy-canvas-bindings"
+ assert records[0].raw_data["_workflowSinkNodeId"] == "inbox-review"
+
+
@pytest.mark.asyncio
async def test_workflow_run_loads_bound_source_task_records_as_items(client, db_session):
_bili_source, bili_task, _bili_record = await _seed_collected_record(
-
{
- mousePos.current = { x: e.clientX, y: e.clientY }
- }}
- data-zoom-bucket={zoom < 0.5 ? "low" : zoom > 1.4 ? "high" : "mid"}
- >
-
-
-
- {isScissors ? (
-
- ) : null}
-
- {runTraceOpen ? (
- setNodeManagementOpen(false)} /> : null}
-
- {networkStack.length > 0 ? (
- setAgentDrawerOpen(false)}
- />
-
- {toast ? (
-
+
-
- ) : null}
-
- {nodeManagementOpen ?
-
- /
- obj
- {networkStack.map((entry) => (
-
- /
- {entry.label}
-
- ))}
-
- {networkLocked ? "LOCKED" : "DRAFT"}
-
- Esc / Backspace
-
- ) : null}
-
- {nodeMenu ? (
- event.stopPropagation()}
- onClick={(event) => event.stopPropagation()}
- >
-
-
-
- ) : null}
-
- {projectSettingsOpen ? (
-
- DOP Operators
-
-
- {dopNodeMenuItems.map((item) => {
- const text = localizeNodeText(item.id, { label: item.label, description: item.description }, settings.language)
- const visual = getNodeVisualSignature({
- label: item.label,
- description: item.description,
- nodeType: item.kind === "router" ? "condition" : item.kind === "schedule" ? "trigger" : item.kind === "source" ? "http" : "action",
- category: item.category === "decision" ? "logic" : item.category === "trigger" ? "trigger" : item.category === "source" ? "data" : item.category === "output" ? "action" : "action",
- icon: item.icon,
- canonical: { catalogId: item.id, kind: item.kind, capability: item.capability },
- })
- return (
-
- )
- })}
-
-
-
-
-
-
-
-
-
-
-
-
-
- Add Internal Primitive
- ›
-
-
- {primitiveMenuGroups.map((group) => (
-
-
-
- ))}
-
- {group.label}
- ›
-
-
- {group.items.map((item, itemIndex) => {
- const text = localizeNodeText(item.id, { label: item.label, description: item.description }, settings.language)
- const runtimeCapability = primitiveRuntimeCapability(capabilities, item.id)
- const visual = getNodeVisualSignature({
- label: item.label,
- description: item.description,
- nodeType: item.nodeType,
- category: item.nodeCategory,
- icon: item.icon,
- primitiveId: item.id,
- primitiveCategory: item.category,
- })
- return (
-
- )
- })}
-
- Help...
-
-
- ) : settingsOpen ? (
-
-
- ) : inspectorOpen ? (
-
-
- ) : null}
-
-
- {toast}
-
- ) : null}
-