From 78e7f3621b982282d4fae49f926883f5fdcd416e Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Wed, 9 Sep 2026 19:55:15 -0700 Subject: [PATCH 001/127] fix: bind canvas ownership to the tracker whose graph is loaded Calling workflowStore.openWorkflow() to switch tabs (without going through workflowService / loadGraphData) made the target workflow 'active' while the previous workflow's graph was still on the canvas. The next captureCanvasState / squashState then serialized the wrong graph into the target's activeState, persisting a draft that survived reload (PM-875). ChangeTracker now records which tracker owns the canvas; ownership is bound only in activateLoadedWorkflow after loadGraphData(). Trackers that are active but not bound to the canvas refuse to serialize it (assert in dev). --- .../workflow/core/services/workflowService.ts | 32 +++++++--- src/scripts/changeTracker.test.ts | 63 +++++++++++++++++++ src/scripts/changeTracker.ts | 43 ++++++++++++- 3 files changed, 130 insertions(+), 8 deletions(-) diff --git a/src/platform/workflow/core/services/workflowService.ts b/src/platform/workflow/core/services/workflowService.ts index 661ce4d7e3e..ca7c9b9d3ed 100644 --- a/src/platform/workflow/core/services/workflowService.ts +++ b/src/platform/workflow/core/services/workflowService.ts @@ -25,6 +25,7 @@ import type { ComfyWorkflowJSON } from '@/platform/workflow/validation/schemas/w // oxlint-disable-next-line comfy/no-restricted-paths import { useWorkflowThumbnail } from '@/renderer/core/thumbnail/useWorkflowThumbnail' import { useApp } from '@/scripts/appInstance' +import { ChangeTracker } from '@/scripts/changeTracker' import { blankGraph, defaultGraph } from '@/scripts/defaultGraph' import { useDialogService } from '@/services/dialogService' import { useAppMode } from '@/composables/useAppMode' @@ -731,6 +732,24 @@ export const useWorkflowService = () => { useExecutionErrorStore().setActiveGraph(rootGraphId, workflow.path) } + /** + * Activate `workflow` in the store and record its tracker as the one + * whose graph is on the canvas. This is the only place the two are + * bound together: loadGraphData() has just configured the root graph + * with this workflow's data. + * + * Returns null when the canvas graph was replaced while the store + * activation was in flight. Binding ownership then would name a tracker + * whose graph is no longer on the canvas, which is the corruption this + * binding exists to prevent. + */ + async function bindToCanvas(workflow: ComfyWorkflow) { + const loadedWorkflow = await workflowStore.openWorkflow(workflow) + if (graphState !== useApp().rootGraphOrUndefined?.state) return null + ChangeTracker.canvasTracker = loadedWorkflow.changeTracker + return loadedWorkflow + } + // Determine the initial app mode for fresh loads from serialized state. // null means linearMode was never explicitly set (not builder-saved). const freshLoadMode = linearModeToAppMode(workflowData.extra?.linearMode) @@ -770,9 +789,8 @@ export const useWorkflowService = () => { ((existingWorkflow.isPersisted && !existingWorkflow.isLoaded) || isSameActiveWorkflowLoad) ) { - const loadedWorkflow = - await workflowStore.openWorkflow(existingWorkflow) - if (graphState !== useApp().rootGraphOrUndefined?.state) return + const loadedWorkflow = await bindToCanvas(existingWorkflow) + if (!loadedWorkflow) return activateRunErrors(loadedWorkflow) if (loadedWorkflow.initialMode === undefined) { // Prefer the file's linearMode over the draft's since the file @@ -807,14 +825,14 @@ export const useWorkflowService = () => { tempWorkflow.shareId = shareId } trackIfEnteringApp(tempWorkflow) - const loadedWorkflow = await workflowStore.openWorkflow(tempWorkflow) - if (graphState !== useApp().rootGraphOrUndefined?.state) return + const loadedWorkflow = await bindToCanvas(tempWorkflow) + if (!loadedWorkflow) return activateRunErrors(loadedWorkflow) return } - const loadedWorkflow = await workflowStore.openWorkflow(value) - if (graphState !== useApp().rootGraphOrUndefined?.state) return + const loadedWorkflow = await bindToCanvas(value) + if (!loadedWorkflow) return activateRunErrors(loadedWorkflow) if (shareId) { loadedWorkflow.shareId = shareId diff --git a/src/scripts/changeTracker.test.ts b/src/scripts/changeTracker.test.ts index bee96772dc3..962b8df2faa 100644 --- a/src/scripts/changeTracker.test.ts +++ b/src/scripts/changeTracker.test.ts @@ -182,6 +182,7 @@ describe('ChangeTracker', () => { nodeIdCounter = 0 ChangeTracker.isLoadingGraph = false ChangeTracker.resetCheckStateWarningForTest() + ChangeTracker.resetCanvasTrackerForTest() useWorkflowStore().activeWorkflow = null vi.mocked(useWorkflowStore().getWorkflowByPath).mockReturnValue(null) mockCanvasState(createState()) @@ -483,6 +484,68 @@ describe('ChangeTracker', () => { 'ChangeTracker.captureCanvasState() called on inactive tracker' ) }) + + describe('canvas ownership', () => { + it('does not copy the canvas graph into a workflow activated without a graph load', () => { + // Workflow A owns the canvas (afterLoadNewGraph bound it). + const trackerA = createTracker(createState(2)) + ChangeTracker.canvasTracker = trackerA + mockCanvasState(createState(2)) + + // An extension calls useWorkflowStore().openWorkflow(B) directly: + // B becomes activeWorkflow but A's graph is still on the canvas. + const originalB = createState(0) + const trackerB = createTracker(originalB) + + trackerB.captureCanvasState() + + expect(trackerB.activeState).toBe(originalB) + expect(trackerB.activeState.nodes).toHaveLength(0) + expect(mockAssert).toHaveBeenCalledWith( + false, + "ChangeTracker.captureCanvasState() called while another workflow's graph is on the canvas" + ) + }) + + it('does not persist the canvas graph via deactivate() into an unbound workflow', () => { + const trackerA = createTracker(createState(2)) + ChangeTracker.canvasTracker = trackerA + mockCanvasState(createState(2)) + + const originalB = createState(0) + const trackerB = createTracker(originalB) + + trackerB.deactivate() + + expect(trackerB.activeState).toBe(originalB) + expect(app.rootGraph.serialize).not.toHaveBeenCalled() + }) + + it('captures the canvas once the tracker is bound to the canvas', () => { + const trackerA = createTracker(createState(2)) + ChangeTracker.canvasTracker = trackerA + + const trackerB = createTracker(createState(0)) + ChangeTracker.canvasTracker = trackerB + const canvasState = createState(3) + mockCanvasState(canvasState) + + trackerB.captureCanvasState() + + expect(trackerB.activeState).toEqual(canvasState) + expect(mockAssert).not.toHaveBeenCalled() + }) + + it('is permissive when no tracker has been bound to the canvas yet', () => { + const tracker = createTracker(createState(0)) + const canvasState = createState(1) + mockCanvasState(canvasState) + + tracker.captureCanvasState() + + expect(tracker.activeState).toEqual(canvasState) + }) + }) }) describe('state capture', () => { diff --git a/src/scripts/changeTracker.ts b/src/scripts/changeTracker.ts index 515bd3beca0..5f8a8f0a9c0 100644 --- a/src/scripts/changeTracker.ts +++ b/src/scripts/changeTracker.ts @@ -121,6 +121,15 @@ function historyShortcut(e: KeyboardEvent): 'undo' | 'redo' | undefined { if (key === 'Z') return e.shiftKey ? 'redo' : 'undo' } +/** + * Whether `tracker` owns the graph currently on the canvas. `null` (nothing + * bound yet, e.g. before the first load or in unit tests) is permissive. + */ +function isCanvasTracker(tracker: ChangeTracker): boolean { + const canvasTracker = ChangeTracker.canvasTracker + return canvasTracker === null || canvasTracker === tracker +} + function isAutoQueueOnChange(): boolean { const { ui } = useApp() return ( @@ -331,8 +340,35 @@ function reportInactiveTrackerCall(method: string, workflowPath: string) { assert(false, `ChangeTracker.${method}() called on inactive tracker`) } +const reportedCanvasMismatchCalls = new Set() + +function reportCanvasMismatchCall(method: string, workflowPath: string) { + const key = `${method}:${workflowPath}` + if (reportedCanvasMismatchCalls.has(key)) return + reportedCanvasMismatchCalls.add(key) + assert( + false, + `ChangeTracker.${method}() called while another workflow's graph is on the canvas` + ) +} + export class ChangeTracker implements WorkflowChangeTracker { static MAX_HISTORY = 50 + /** + * The tracker whose workflow graph is currently loaded on the canvas. + * Bound by `afterLoadNewGraph()` after `loadGraphData()` has configured + * the root graph. `activeWorkflow` can be moved without a graph load + * (e.g. an extension calling `useWorkflowStore().openWorkflow()` directly); + * in that state the active tracker must not serialize the canvas, or the + * previous workflow's graph would be written into the new workflow's + * activeState and persisted as its draft. + */ + static canvasTracker: ChangeTracker | null = null + + static resetCanvasTrackerForTest() { + ChangeTracker.canvasTracker = null + reportedCanvasMismatchCalls.clear() + } /** * Guard flag to prevent captureCanvasState from running during loadGraphData. * Between rootGraph.configure() and afterLoadNewGraph(), the rootGraph @@ -501,6 +537,10 @@ export class ChangeTracker implements WorkflowChangeTracker { reportInactiveTrackerCall('captureCanvasState', this.workflow.path) return } + if (!isCanvasTracker(this)) { + reportCanvasMismatchCall('captureCanvasState', this.workflow.path) + return + } const currentState = clone( useApp().rootGraph.serialize() @@ -531,7 +571,8 @@ export class ChangeTracker implements WorkflowChangeTracker { squashState = useDebounceFn(() => { if ( this !== useWorkflowStore().activeWorkflow?.changeTracker || - ChangeTracker.isLoadingGraph + ChangeTracker.isLoadingGraph || + !isCanvasTracker(this) ) return From 9ad0a9a2265b06f4a44440fe0e9dccf06affc732 Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Sun, 13 Sep 2026 05:04:35 -0700 Subject: [PATCH 002/127] fix: fail closed while replacing canvas ownership Addresses reviewer findings in PR #17331. --- .../core/services/workflowService.test.ts | 15 +++++++++++++++ .../workflow/core/services/workflowService.ts | 2 ++ src/scripts/changeTracker.ts | 6 +++++- 3 files changed, 22 insertions(+), 1 deletion(-) diff --git a/src/platform/workflow/core/services/workflowService.test.ts b/src/platform/workflow/core/services/workflowService.test.ts index 637e2d3655c..64253ce02b9 100644 --- a/src/platform/workflow/core/services/workflowService.test.ts +++ b/src/platform/workflow/core/services/workflowService.test.ts @@ -669,6 +669,7 @@ describe('useWorkflowService', () => { path: 'workflows/active-noop.json' }) workflowStore.activeWorkflow = active as LoadedComfyWorkflow + ChangeTracker.canvasTracker = active.changeTracker const service = useWorkflowService() await service.openWorkflow(active) @@ -678,6 +679,19 @@ describe('useWorkflowService', () => { expect(app.loadGraphData).toHaveBeenCalledTimes(1) }) + it('loads an active workflow that does not own the canvas', async () => { + const workflowStore = useWorkflowStore() + const active = createWorkflow(null, { + loadable: true, + path: 'workflows/store-selected.json' + }) + workflowStore.activeWorkflow = active as LoadedComfyWorkflow + + await useWorkflowService().openWorkflow(active) + + expect(app.loadGraphData).toHaveBeenCalledOnce() + }) + it('re-opens a workflow normally once its close has settled', async () => { const workflowStore = useWorkflowStore() const cycled = createWorkflow(null, { @@ -2145,6 +2159,7 @@ describe('useWorkflowService', () => { await useWorkflowService().afterLoadNewGraph('repeat', makeWorkflowData()) + expect(ChangeTracker.canvasTracker).toBe(existingWorkflow.changeTracker) expect( useNodeOutputStore().restorePreviewsForWorkflow ).toHaveBeenCalledWith(existingWorkflow.path) diff --git a/src/platform/workflow/core/services/workflowService.ts b/src/platform/workflow/core/services/workflowService.ts index ca7c9b9d3ed..5c19a412fc2 100644 --- a/src/platform/workflow/core/services/workflowService.ts +++ b/src/platform/workflow/core/services/workflowService.ts @@ -442,6 +442,7 @@ export const useWorkflowService = () => { if ( pendingWorkflowLoads === 0 && workflowStore.isActive(workflow) && + ChangeTracker.canvasTracker === workflow.changeTracker && !options.force ) { return Promise.resolve(true) @@ -467,6 +468,7 @@ export const useWorkflowService = () => { return false } + ChangeTracker.invalidateCanvasTracker() const loaded = await useApp().loadGraphData( toRaw(workflow.activeState) as ComfyWorkflowJSON, /* clean=*/ true, diff --git a/src/scripts/changeTracker.ts b/src/scripts/changeTracker.ts index 5f8a8f0a9c0..c5cc7e46ae1 100644 --- a/src/scripts/changeTracker.ts +++ b/src/scripts/changeTracker.ts @@ -363,7 +363,11 @@ export class ChangeTracker implements WorkflowChangeTracker { * previous workflow's graph would be written into the new workflow's * activeState and persisted as its draft. */ - static canvasTracker: ChangeTracker | null = null + static canvasTracker: ChangeTracker | null | false = null + + static invalidateCanvasTracker() { + ChangeTracker.canvasTracker = false + } static resetCanvasTrackerForTest() { ChangeTracker.canvasTracker = null From 2522b1b2cdd63f213d7371835568d1bb29d47253 Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Sun, 13 Sep 2026 18:49:23 -0700 Subject: [PATCH 003/127] test: cover canvas ownership review cases Addresses review feedback: https://github.com/Comfy-Org/ComfyUI_frontend/pull/17331#discussion_r3999578916 https://github.com/Comfy-Org/ComfyUI_frontend/pull/17331#discussion_r3999578917 https://github.com/Comfy-Org/ComfyUI_frontend/pull/17331#discussion_r3999611215 --- .../core/services/workflowService.test.ts | 32 ++++++++++++++++++- src/scripts/changeTracker.test.ts | 17 ++++++++++ 2 files changed, 48 insertions(+), 1 deletion(-) diff --git a/src/platform/workflow/core/services/workflowService.test.ts b/src/platform/workflow/core/services/workflowService.test.ts index 64253ce02b9..c8ca74a1484 100644 --- a/src/platform/workflow/core/services/workflowService.test.ts +++ b/src/platform/workflow/core/services/workflowService.test.ts @@ -686,10 +686,18 @@ describe('useWorkflowService', () => { path: 'workflows/store-selected.json' }) workflowStore.activeWorkflow = active as LoadedComfyWorkflow + const service = useWorkflowService() + vi.mocked(app.loadGraphData).mockImplementationOnce( + async (_workflowData, _clean, _restoreView, workflow) => { + await service.afterLoadNewGraph(workflow ?? null, makeWorkflowData()) + return true + } + ) - await useWorkflowService().openWorkflow(active) + await service.openWorkflow(active) expect(app.loadGraphData).toHaveBeenCalledOnce() + expect(ChangeTracker.canvasTracker).toBe(active.changeTracker) }) it('re-opens a workflow normally once its close has settled', async () => { @@ -885,6 +893,28 @@ describe('useWorkflowService', () => { expect(app.loadGraphData).toHaveBeenCalledOnce() }) + it('invalidates ownership when the replacement and retained loads fail', async () => { + const workflowStore = useWorkflowStore() + const retained = createWorkflow(null, { + loadable: true, + path: 'workflows/retained.json' + }) + const failing = createWorkflow(null, { + loadable: true, + path: 'workflows/failing.json' + }) + workflowStore.activeWorkflow = retained as LoadedComfyWorkflow + ChangeTracker.canvasTracker = retained.changeTracker + vi.mocked(app.loadGraphData).mockResolvedValue(false) + + await expect(useWorkflowService().openWorkflow(failing)).resolves.toBe( + false + ) + + expect(app.loadGraphData).toHaveBeenCalledTimes(2) + expect(ChangeTracker.canvasTracker).toBe(false) + }) + it('serializes rapid workflow opens so the final selection stays active', async () => { const workflowStore = useWorkflowStore() const first = createWorkflow(null, { diff --git a/src/scripts/changeTracker.test.ts b/src/scripts/changeTracker.test.ts index 962b8df2faa..4213ca8e8a9 100644 --- a/src/scripts/changeTracker.test.ts +++ b/src/scripts/changeTracker.test.ts @@ -693,6 +693,23 @@ describe('ChangeTracker', () => { ]) }) + it('does not squash after canvas ownership changes', async () => { + const initial = createState(1) + const changed = structuredClone(initial) + changed.nodes[0].widgets_values = [2] + const lateState = structuredClone(changed) + lateState.nodes[0].widgets_values = [3] + const tracker = createTracker(initial) + mockCanvasState(changed) + + tracker.captureCanvasState() + mockCanvasState(lateState) + ChangeTracker.canvasTracker = createTracker() + await vi.advanceTimersByTimeAsync(50) + + expect(tracker.activeState).toEqual(changed) + }) + it('does not emit an execution change for a late layout-only update', async () => { const initial = createState(1) const changed = structuredClone(initial) From a1257a019ae78f897803d7cb8aaa7e626809c056 Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Mon, 14 Sep 2026 22:51:13 -0700 Subject: [PATCH 004/127] test: keep canvas owner regression active Addresses review feedback: https://github.com/Comfy-Org/ComfyUI_frontend/pull/17331#discussion_r4001695052 --- src/scripts/changeTracker.test.ts | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/scripts/changeTracker.test.ts b/src/scripts/changeTracker.test.ts index 4213ca8e8a9..de401d375ab 100644 --- a/src/scripts/changeTracker.test.ts +++ b/src/scripts/changeTracker.test.ts @@ -705,6 +705,9 @@ describe('ChangeTracker', () => { tracker.captureCanvasState() mockCanvasState(lateState) ChangeTracker.canvasTracker = createTracker() + useWorkflowStore().activeWorkflow = fromPartial({ + changeTracker: tracker + }) await vi.advanceTimersByTimeAsync(50) expect(tracker.activeState).toEqual(changed) From 40df1dc0ba8213f80ea4a66afcac1a7387b1df23 Mon Sep 17 00:00:00 2001 From: Amp Date: Sat, 19 Sep 2026 00:50:02 +0000 Subject: [PATCH 005/127] fix: preserve canvas ownership during graph transitions Amp-Thread-ID: https://ampcode.com/threads/T-01a0895f-d100-7289-a982-e7361c1a21e0 --- .../core/services/workflowService.test.ts | 24 ++++++++--- .../workflow/core/services/workflowService.ts | 6 +-- src/scripts/app.test.ts | 29 +++++++++++++ src/scripts/app.ts | 11 +++-- src/scripts/changeTracker.test.ts | 23 +++++++--- src/scripts/changeTracker.ts | 43 +++++++++++-------- 6 files changed, 101 insertions(+), 35 deletions(-) diff --git a/src/platform/workflow/core/services/workflowService.test.ts b/src/platform/workflow/core/services/workflowService.test.ts index c8ca74a1484..4814bdfdc73 100644 --- a/src/platform/workflow/core/services/workflowService.test.ts +++ b/src/platform/workflow/core/services/workflowService.test.ts @@ -159,6 +159,7 @@ describe('useWorkflowService', () => { beforeEach(() => { vi.mocked(app.loadGraphData).mockResolvedValue(true) resetWorkflowLoadQueueForTests() + ChangeTracker.resetCanvasTrackerForTest() vi.mocked(useWorkflowDraftStoreV2().saveDraft).mockReturnValue(true) }) @@ -668,8 +669,10 @@ describe('useWorkflowService', () => { loadable: true, path: 'workflows/active-noop.json' }) + const activeTracker = active.changeTracker + if (!activeTracker) throw new Error('Expected loaded workflow') workflowStore.activeWorkflow = active as LoadedComfyWorkflow - ChangeTracker.canvasTracker = active.changeTracker + ChangeTracker.bindCanvasTracker(activeTracker) const service = useWorkflowService() await service.openWorkflow(active) @@ -685,6 +688,8 @@ describe('useWorkflowService', () => { loadable: true, path: 'workflows/store-selected.json' }) + const activeTracker = active.changeTracker + if (!activeTracker) throw new Error('Expected loaded workflow') workflowStore.activeWorkflow = active as LoadedComfyWorkflow const service = useWorkflowService() vi.mocked(app.loadGraphData).mockImplementationOnce( @@ -697,7 +702,7 @@ describe('useWorkflowService', () => { await service.openWorkflow(active) expect(app.loadGraphData).toHaveBeenCalledOnce() - expect(ChangeTracker.canvasTracker).toBe(active.changeTracker) + expect(ChangeTracker.isCanvasOwner(activeTracker)).toBe(true) }) it('re-opens a workflow normally once its close has settled', async () => { @@ -903,16 +908,21 @@ describe('useWorkflowService', () => { loadable: true, path: 'workflows/failing.json' }) + const retainedTracker = retained.changeTracker + if (!retainedTracker) throw new Error('Expected loaded workflow') workflowStore.activeWorkflow = retained as LoadedComfyWorkflow - ChangeTracker.canvasTracker = retained.changeTracker - vi.mocked(app.loadGraphData).mockResolvedValue(false) + ChangeTracker.bindCanvasTracker(retainedTracker) + vi.mocked(app.loadGraphData).mockImplementation(async () => { + ChangeTracker.invalidateCanvasTracker() + return false + }) await expect(useWorkflowService().openWorkflow(failing)).resolves.toBe( false ) expect(app.loadGraphData).toHaveBeenCalledTimes(2) - expect(ChangeTracker.canvasTracker).toBe(false) + expect(ChangeTracker.canCaptureCanvas(retainedTracker)).toBe(false) }) it('serializes rapid workflow opens so the final selection stays active', async () => { @@ -2189,7 +2199,9 @@ describe('useWorkflowService', () => { await useWorkflowService().afterLoadNewGraph('repeat', makeWorkflowData()) - expect(ChangeTracker.canvasTracker).toBe(existingWorkflow.changeTracker) + expect(ChangeTracker.isCanvasOwner(existingWorkflow.changeTracker)).toBe( + true + ) expect( useNodeOutputStore().restorePreviewsForWorkflow ).toHaveBeenCalledWith(existingWorkflow.path) diff --git a/src/platform/workflow/core/services/workflowService.ts b/src/platform/workflow/core/services/workflowService.ts index 5c19a412fc2..655417073f8 100644 --- a/src/platform/workflow/core/services/workflowService.ts +++ b/src/platform/workflow/core/services/workflowService.ts @@ -442,7 +442,8 @@ export const useWorkflowService = () => { if ( pendingWorkflowLoads === 0 && workflowStore.isActive(workflow) && - ChangeTracker.canvasTracker === workflow.changeTracker && + workflow.changeTracker !== null && + ChangeTracker.isCanvasOwner(workflow.changeTracker) && !options.force ) { return Promise.resolve(true) @@ -468,7 +469,6 @@ export const useWorkflowService = () => { return false } - ChangeTracker.invalidateCanvasTracker() const loaded = await useApp().loadGraphData( toRaw(workflow.activeState) as ComfyWorkflowJSON, /* clean=*/ true, @@ -748,7 +748,7 @@ export const useWorkflowService = () => { async function bindToCanvas(workflow: ComfyWorkflow) { const loadedWorkflow = await workflowStore.openWorkflow(workflow) if (graphState !== useApp().rootGraphOrUndefined?.state) return null - ChangeTracker.canvasTracker = loadedWorkflow.changeTracker + ChangeTracker.bindCanvasTracker(loadedWorkflow.changeTracker) return loadedWorkflow } diff --git a/src/scripts/app.test.ts b/src/scripts/app.test.ts index fc4a5c61ecd..c10036f2ec4 100644 --- a/src/scripts/app.test.ts +++ b/src/scripts/app.test.ts @@ -118,6 +118,7 @@ import { reportError } from '@/platform/telemetry/reportError' import { useCanvasScheduler } from '@/renderer/core/canvas/useCanvasScheduler' import { zeroUuid } from '@/utils/uuid' import type { importA1111 } from './pnginfo' +import { ChangeTracker } from './changeTracker' type WorkflowService = ReturnType type WorkflowValidation = ReturnType @@ -303,6 +304,7 @@ describe('ComfyApp', () => { app = new ComfyApp() mockCanvas = createMockCanvas() as LGraphCanvas app.canvas = mockCanvas + ChangeTracker.resetCanvasTrackerForTest() useWorkflowStore().activeWorkflow = null const temporaryWorkflow = new ComfyWorkflow({ path: 'workflows/temporary.json', @@ -522,6 +524,33 @@ describe('ComfyApp', () => { expect(useToast().toasts).toEqual([]) }) + it('invalidates canvas ownership after deactivating the outgoing workflow', async () => { + app.canvasElRef.value = document.createElement('canvas') + Reflect.set(app, 'rootGraphInternal', new LGraph()) + await useRealWorkflowService() + mockWorkflowService.afterLoadNewGraph.mockResolvedValue() + const outgoing = markLoaded( + new ComfyWorkflow({ + path: 'workflows/outgoing.json', + modified: 0, + size: 0 + }) + ) + useWorkflowStore().activeWorkflow = outgoing + ChangeTracker.bindCanvasTracker(outgoing.changeTracker) + let couldCaptureDuringDeactivate = false + vi.mocked(outgoing.changeTracker.deactivate).mockImplementation(() => { + couldCaptureDuringDeactivate = ChangeTracker.canCaptureCanvas( + outgoing.changeTracker + ) + }) + + await app.loadGraphData(createWorkflowGraphData()) + + expect(couldCaptureDuringDeactivate).toBe(true) + expect(ChangeTracker.canCaptureCanvas(outgoing.changeTracker)).toBe(false) + }) + it('forwards clean and navigation intent to workflow navigation', async () => { app.canvasElRef.value = document.createElement('canvas') Reflect.set(app, 'rootGraphInternal', new LGraph()) diff --git a/src/scripts/app.ts b/src/scripts/app.ts index 4338510c9be..84673fe553b 100644 --- a/src/scripts/app.ts +++ b/src/scripts/app.ts @@ -306,6 +306,11 @@ function createNodeOutputsMutationView( }) } +function beginGraphLoad(suppressWorkflowReset: boolean) { + useWorkflowService().beforeLoadNewGraph(suppressWorkflowReset) + ChangeTracker.invalidateCanvasTracker() +} + export class ComfyApp implements IComfyApp { /** * List of entries to queue @@ -1224,7 +1229,7 @@ export class ComfyApp implements IComfyApp { silentAssetErrors = false, workflowNavigationId } = options - useWorkflowService().beforeLoadNewGraph(clean) + beginGraphLoad(clean) await useExtensionService().invokeExtensionsAsync('beforeLoadGraph') ChangeTracker.isLoadingGraph = true @@ -2219,7 +2224,7 @@ export class ComfyApp implements IComfyApp { async () => { try { // false: final destination; no later load republishes the hash. - useWorkflowService().beforeLoadNewGraph(false) + beginGraphLoad(false) await useExtensionService().invokeExtensionsAsync( 'beforeLoadGraph' ) @@ -2406,7 +2411,7 @@ export class ComfyApp implements IComfyApp { options: { deferWarnings?: boolean } ): Promise { // false: no workflow load follows to republish the hash. - useWorkflowService().beforeLoadNewGraph(false) + beginGraphLoad(false) await useExtensionService().invokeExtensionsAsync('beforeLoadGraph') this.canvas.setGraph(this.rootGraph) withGraphIntentSource('load', () => this.clean()) diff --git a/src/scripts/changeTracker.test.ts b/src/scripts/changeTracker.test.ts index de401d375ab..99804cc765e 100644 --- a/src/scripts/changeTracker.test.ts +++ b/src/scripts/changeTracker.test.ts @@ -489,7 +489,7 @@ describe('ChangeTracker', () => { it('does not copy the canvas graph into a workflow activated without a graph load', () => { // Workflow A owns the canvas (afterLoadNewGraph bound it). const trackerA = createTracker(createState(2)) - ChangeTracker.canvasTracker = trackerA + ChangeTracker.bindCanvasTracker(trackerA) mockCanvasState(createState(2)) // An extension calls useWorkflowStore().openWorkflow(B) directly: @@ -509,7 +509,7 @@ describe('ChangeTracker', () => { it('does not persist the canvas graph via deactivate() into an unbound workflow', () => { const trackerA = createTracker(createState(2)) - ChangeTracker.canvasTracker = trackerA + ChangeTracker.bindCanvasTracker(trackerA) mockCanvasState(createState(2)) const originalB = createState(0) @@ -523,10 +523,10 @@ describe('ChangeTracker', () => { it('captures the canvas once the tracker is bound to the canvas', () => { const trackerA = createTracker(createState(2)) - ChangeTracker.canvasTracker = trackerA + ChangeTracker.bindCanvasTracker(trackerA) const trackerB = createTracker(createState(0)) - ChangeTracker.canvasTracker = trackerB + ChangeTracker.bindCanvasTracker(trackerB) const canvasState = createState(3) mockCanvasState(canvasState) @@ -545,6 +545,19 @@ describe('ChangeTracker', () => { expect(tracker.activeState).toEqual(canvasState) }) + + it('silently skips capture while the canvas is being replaced', () => { + const original = createState(0) + const tracker = createTracker(original) + ChangeTracker.invalidateCanvasTracker() + mockCanvasState(createState(1)) + + tracker.captureCanvasState() + + expect(tracker.activeState).toBe(original) + expect(app.rootGraph.serialize).not.toHaveBeenCalled() + expect(mockAssert).not.toHaveBeenCalled() + }) }) }) @@ -704,7 +717,7 @@ describe('ChangeTracker', () => { tracker.captureCanvasState() mockCanvasState(lateState) - ChangeTracker.canvasTracker = createTracker() + ChangeTracker.bindCanvasTracker(createTracker()) useWorkflowStore().activeWorkflow = fromPartial({ changeTracker: tracker }) diff --git a/src/scripts/changeTracker.ts b/src/scripts/changeTracker.ts index c5cc7e46ae1..f48dc7cff49 100644 --- a/src/scripts/changeTracker.ts +++ b/src/scripts/changeTracker.ts @@ -121,15 +121,6 @@ function historyShortcut(e: KeyboardEvent): 'undo' | 'redo' | undefined { if (key === 'Z') return e.shiftKey ? 'redo' : 'undo' } -/** - * Whether `tracker` owns the graph currently on the canvas. `null` (nothing - * bound yet, e.g. before the first load or in unit tests) is permissive. - */ -function isCanvasTracker(tracker: ChangeTracker): boolean { - const canvasTracker = ChangeTracker.canvasTracker - return canvasTracker === null || canvasTracker === tracker -} - function isAutoQueueOnChange(): boolean { const { ui } = useApp() return ( @@ -356,19 +347,34 @@ export class ChangeTracker implements WorkflowChangeTracker { static MAX_HISTORY = 50 /** * The tracker whose workflow graph is currently loaded on the canvas. - * Bound by `afterLoadNewGraph()` after `loadGraphData()` has configured - * the root graph. `activeWorkflow` can be moved without a graph load - * (e.g. an extension calling `useWorkflowStore().openWorkflow()` directly); - * in that state the active tracker must not serialize the canvas, or the - * previous workflow's graph would be written into the new workflow's - * activeState and persisted as its draft. + * `null` permits capture before the first workflow binding; `false` blocks + * capture while the canvas is being replaced or after a failed load. */ - static canvasTracker: ChangeTracker | null | false = null + private static canvasTracker: ChangeTracker | null | false = null + + static bindCanvasTracker(tracker: ChangeTracker) { + ChangeTracker.canvasTracker = tracker + } static invalidateCanvasTracker() { ChangeTracker.canvasTracker = false } + static isCanvasOwner(tracker: ChangeTracker): boolean { + return ChangeTracker.canvasTracker === tracker + } + + static canCaptureCanvas(tracker: ChangeTracker): boolean { + return ( + ChangeTracker.canvasTracker === null || + ChangeTracker.canvasTracker === tracker + ) + } + + private static isCanvasCaptureBlocked(): boolean { + return ChangeTracker.canvasTracker === false + } + static resetCanvasTrackerForTest() { ChangeTracker.canvasTracker = null reportedCanvasMismatchCalls.clear() @@ -541,7 +547,8 @@ export class ChangeTracker implements WorkflowChangeTracker { reportInactiveTrackerCall('captureCanvasState', this.workflow.path) return } - if (!isCanvasTracker(this)) { + if (ChangeTracker.isCanvasCaptureBlocked()) return + if (!ChangeTracker.canCaptureCanvas(this)) { reportCanvasMismatchCall('captureCanvasState', this.workflow.path) return } @@ -576,7 +583,7 @@ export class ChangeTracker implements WorkflowChangeTracker { if ( this !== useWorkflowStore().activeWorkflow?.changeTracker || ChangeTracker.isLoadingGraph || - !isCanvasTracker(this) + !ChangeTracker.canCaptureCanvas(this) ) return From 5433fdae901e315af252363d29457f2352231153 Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Sat, 10 Oct 2026 18:23:29 -0700 Subject: [PATCH 006/127] refactor(workflow): isolate canvas ownership state --- .../workflow/core/services/workflowService.ts | 9 ++++-- src/scripts/app.ts | 3 +- src/scripts/canvasTrackerOwnership.ts | 30 +++++++++++++++++++ src/scripts/changeTracker.ts | 29 +++++++++--------- 4 files changed, 52 insertions(+), 19 deletions(-) create mode 100644 src/scripts/canvasTrackerOwnership.ts diff --git a/src/platform/workflow/core/services/workflowService.ts b/src/platform/workflow/core/services/workflowService.ts index 655417073f8..e9adddae515 100644 --- a/src/platform/workflow/core/services/workflowService.ts +++ b/src/platform/workflow/core/services/workflowService.ts @@ -25,7 +25,10 @@ import type { ComfyWorkflowJSON } from '@/platform/workflow/validation/schemas/w // oxlint-disable-next-line comfy/no-restricted-paths import { useWorkflowThumbnail } from '@/renderer/core/thumbnail/useWorkflowThumbnail' import { useApp } from '@/scripts/appInstance' -import { ChangeTracker } from '@/scripts/changeTracker' +import { + bindCanvasTracker, + isCanvasOwner +} from '@/scripts/canvasTrackerOwnership' import { blankGraph, defaultGraph } from '@/scripts/defaultGraph' import { useDialogService } from '@/services/dialogService' import { useAppMode } from '@/composables/useAppMode' @@ -443,7 +446,7 @@ export const useWorkflowService = () => { pendingWorkflowLoads === 0 && workflowStore.isActive(workflow) && workflow.changeTracker !== null && - ChangeTracker.isCanvasOwner(workflow.changeTracker) && + isCanvasOwner(workflow.changeTracker) && !options.force ) { return Promise.resolve(true) @@ -748,7 +751,7 @@ export const useWorkflowService = () => { async function bindToCanvas(workflow: ComfyWorkflow) { const loadedWorkflow = await workflowStore.openWorkflow(workflow) if (graphState !== useApp().rootGraphOrUndefined?.state) return null - ChangeTracker.bindCanvasTracker(loadedWorkflow.changeTracker) + bindCanvasTracker(loadedWorkflow.changeTracker) return loadedWorkflow } diff --git a/src/scripts/app.ts b/src/scripts/app.ts index 84673fe553b..909bc5c60cf 100644 --- a/src/scripts/app.ts +++ b/src/scripts/app.ts @@ -19,6 +19,7 @@ import { resolveDynamicInputSpec } from '@/core/graph/widgets/dynamicInputSpec' import { setBackendNodeText, st, t } from '@/i18n' import { normalizeI18nKey } from '@/utils/formatUtil' import { ChangeTracker } from '@/scripts/changeTracker' +import { invalidateCanvasTracker } from '@/scripts/canvasTrackerOwnership' import { registerApp } from '@/scripts/appRegistry' import { clipspace, @@ -308,7 +309,7 @@ function createNodeOutputsMutationView( function beginGraphLoad(suppressWorkflowReset: boolean) { useWorkflowService().beforeLoadNewGraph(suppressWorkflowReset) - ChangeTracker.invalidateCanvasTracker() + invalidateCanvasTracker() } export class ComfyApp implements IComfyApp { diff --git a/src/scripts/canvasTrackerOwnership.ts b/src/scripts/canvasTrackerOwnership.ts new file mode 100644 index 00000000000..aeaf7898ba4 --- /dev/null +++ b/src/scripts/canvasTrackerOwnership.ts @@ -0,0 +1,30 @@ +/** + * Identifies which workflow tracker owns the graph currently shown on the + * canvas. Kept outside ChangeTracker so workflow loading can consult ownership + * without importing the tracker implementation (and its navigation stores). + */ +let canvasTracker: object | null | false = null + +export function bindCanvasTracker(tracker: object): void { + canvasTracker = tracker +} + +export function invalidateCanvasTracker(): void { + canvasTracker = false +} + +export function isCanvasOwner(tracker: object): boolean { + return canvasTracker === tracker +} + +export function canCaptureCanvas(tracker: object): boolean { + return canvasTracker === null || canvasTracker === tracker +} + +export function isCanvasCaptureBlocked(): boolean { + return canvasTracker === false +} + +export function resetCanvasTrackerForTest(): void { + canvasTracker = null +} diff --git a/src/scripts/changeTracker.ts b/src/scripts/changeTracker.ts index f48dc7cff49..caf542adf1b 100644 --- a/src/scripts/changeTracker.ts +++ b/src/scripts/changeTracker.ts @@ -27,6 +27,14 @@ import { isSelectOnly } from '@/utils/litegraphUtil' import { isModalOpen } from '@/utils/modalUtil' import { api } from './api' +import { + bindCanvasTracker, + canCaptureCanvas, + invalidateCanvasTracker, + isCanvasCaptureBlocked, + isCanvasOwner, + resetCanvasTrackerForTest +} from './canvasTrackerOwnership' import { collectNodeHistoryWidgets, nodeHistoryValuesChanged, @@ -345,38 +353,29 @@ function reportCanvasMismatchCall(method: string, workflowPath: string) { export class ChangeTracker implements WorkflowChangeTracker { static MAX_HISTORY = 50 - /** - * The tracker whose workflow graph is currently loaded on the canvas. - * `null` permits capture before the first workflow binding; `false` blocks - * capture while the canvas is being replaced or after a failed load. - */ - private static canvasTracker: ChangeTracker | null | false = null static bindCanvasTracker(tracker: ChangeTracker) { - ChangeTracker.canvasTracker = tracker + bindCanvasTracker(tracker) } static invalidateCanvasTracker() { - ChangeTracker.canvasTracker = false + invalidateCanvasTracker() } static isCanvasOwner(tracker: ChangeTracker): boolean { - return ChangeTracker.canvasTracker === tracker + return isCanvasOwner(tracker) } static canCaptureCanvas(tracker: ChangeTracker): boolean { - return ( - ChangeTracker.canvasTracker === null || - ChangeTracker.canvasTracker === tracker - ) + return canCaptureCanvas(tracker) } private static isCanvasCaptureBlocked(): boolean { - return ChangeTracker.canvasTracker === false + return isCanvasCaptureBlocked() } static resetCanvasTrackerForTest() { - ChangeTracker.canvasTracker = null + resetCanvasTrackerForTest() reportedCanvasMismatchCalls.clear() } /** From 4bcc006178e8e1f2cd0cade57f8c314035ef81e5 Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Sat, 17 Oct 2026 02:23:46 -0700 Subject: [PATCH 007/127] fix: invalidate canvas ownership after the beforeLoadGraph hook MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Addresses the remaining blocking finding on #17331 (https://github.com/Comfy-Org/ComfyUI_frontend/pull/17331#discussion_r4016587352). Ownership was invalidated before the awaited `beforeLoadGraph` extension hook, which left a window where the outgoing workflow was still active with its graph still on the canvas. A capture queued into that window (the keydown rAF capture) is legitimate there, but was dropped — so a failed target load would repaint the retained workflow from an activeState missing its last change. `beginGraphLoad` now awaits the hook and invalidates last, immediately before each caller replaces the canvas graph. In `loadGraphData` that puts the invalidation adjacent to `isLoadingGraph = true`, closing the window entirely. Also: - widen the `ChangeTracker` ownership statics to `WorkflowChangeTracker`, the contract `ComfyWorkflow` actually exposes; ownership is identity-only and never calls into the tracker - gate the ownership bind in `bindToCanvas()` behind main's `graphState` staleness check, so a canvas replaced mid-activation cannot bind an owner whose graph is no longer displayed - add a black-box case asserting the PM-875 symptom in visible terms: after a store-only activation, opening the workflow from the sidebar must repaint the canvas. Red on main (0 nodes under a workflow-a selection), green here - pin the ordering with a unit regression that fails on the previous ordering --- .../tests/workflowTabCanvasOwnership.spec.ts | 58 +++++++++++++++++++ src/scripts/app.test.ts | 40 ++++++++++++- src/scripts/app.ts | 25 +++++--- src/scripts/changeTracker.ts | 9 ++- 4 files changed, 119 insertions(+), 13 deletions(-) create mode 100644 browser_tests/tests/workflowTabCanvasOwnership.spec.ts diff --git a/browser_tests/tests/workflowTabCanvasOwnership.spec.ts b/browser_tests/tests/workflowTabCanvasOwnership.spec.ts new file mode 100644 index 00000000000..1500915a8ce --- /dev/null +++ b/browser_tests/tests/workflowTabCanvasOwnership.spec.ts @@ -0,0 +1,58 @@ +import { + comfyExpect as expect, + comfyPageFixture as test +} from '@e2e/fixtures/ComfyPage' +import type { WorkspaceStore } from '@e2e/types/globals' + +/** + * PM-875. A store-only activation moves the selected workflow without loading + * a graph, so the canvas keeps showing the previous tab's graph. Opening that + * workflow through the normal user route must then repaint the canvas rather + * than take the "already active" fast path and leave the mismatch in place. + * + * Source: https://github.com/Comfy-Org/ComfyUI_frontend/pull/17331 + */ +test.describe('Workflow tabs - canvas ownership', { tag: '@workflow' }, () => { + test.beforeEach(async ({ comfyPage }) => { + await comfyPage.workflow.setupWorkflowsDirectory({}) + }) + + test('Repaints the canvas for a workflow that was activated without a graph load', async ({ + comfyPage + }) => { + // Tab 0: default workflow (7 nodes), saved so it has a stable name. + await expect.poll(() => comfyPage.nodeOps.getGraphNodesCount()).toBe(7) + await comfyPage.menu.topbar.saveWorkflow('workflow-a') + + // Tab 1: blank workflow (0 nodes). The canvas now holds this graph. + await comfyPage.menu.topbar.triggerTopbarCommand(['New']) + await expect.poll(() => comfyPage.nodeOps.getGraphNodesCount()).toBe(0) + + // Activate workflow-a in the store only, with no graph load. This is what + // an extension or the agent does when it moves the selected workflow + // directly, and it is the state PM-875 was reported from: workflow-a reads + // as the active workflow while tab 1's blank graph is on the canvas. + const activated = await comfyPage.page.evaluate(async () => { + const workflowStore = (window.app!.extensionManager as WorkspaceStore) + .workflow + const target = workflowStore.openWorkflows.find((workflow) => + workflow.path.includes('workflow-a') + ) + if (!target) throw new Error('workflow-a is not open') + await workflowStore.openWorkflow(target) + return workflowStore.activeWorkflow?.path ?? null + }) + + // The defect, in visible terms: workflow-a is selected, canvas is empty. + expect(activated).toContain('workflow-a') + await expect.poll(() => comfyPage.nodeOps.getGraphNodesCount()).toBe(0) + + // Open workflow-a the way a user does, from the workflows sidebar. Before + // the fix this returned immediately because the store already reported + // workflow-a active, so the blank graph stayed on the canvas. + await comfyPage.menu.workflowsTab.open() + await comfyPage.menu.workflowsTab.getPersistedItem('workflow-a').click() + + await expect.poll(() => comfyPage.nodeOps.getGraphNodesCount()).toBe(7) + }) +}) diff --git a/src/scripts/app.test.ts b/src/scripts/app.test.ts index c10036f2ec4..221a6862b65 100644 --- a/src/scripts/app.test.ts +++ b/src/scripts/app.test.ts @@ -118,7 +118,6 @@ import { reportError } from '@/platform/telemetry/reportError' import { useCanvasScheduler } from '@/renderer/core/canvas/useCanvasScheduler' import { zeroUuid } from '@/utils/uuid' import type { importA1111 } from './pnginfo' -import { ChangeTracker } from './changeTracker' type WorkflowService = ReturnType type WorkflowValidation = ReturnType @@ -551,6 +550,45 @@ describe('ComfyApp', () => { expect(ChangeTracker.canCaptureCanvas(outgoing.changeTracker)).toBe(false) }) + it('keeps the outgoing workflow able to capture across an awaiting beforeLoadGraph hook', async () => { + app.canvasElRef.value = document.createElement('canvas') + Reflect.set(app, 'rootGraphInternal', new LGraph()) + await useRealWorkflowService() + mockWorkflowService.afterLoadNewGraph.mockResolvedValue() + const outgoing = markLoaded( + new ComfyWorkflow({ + path: 'workflows/outgoing.json', + modified: 0, + size: 0 + }) + ) + useWorkflowStore().activeWorkflow = outgoing + ChangeTracker.bindCanvasTracker(outgoing.changeTracker) + + // An extension hook that awaits real work crosses a task boundary, so a + // queued capture (the keydown rAF capture) can run here. The outgoing + // graph is still the one on the canvas, so that capture is legitimate: + // dropping it would let a failed target load repaint the retained + // workflow from an activeState missing its last change. + let hookName: unknown + let couldCaptureInsideHook: boolean | undefined + mockExtensionService.invokeExtensionsAsync.mockImplementationOnce( + async (hook: unknown) => { + hookName = hook + await Promise.resolve() + couldCaptureInsideHook = ChangeTracker.canCaptureCanvas( + outgoing.changeTracker + ) + } + ) + + await app.loadGraphData(createWorkflowGraphData()) + + expect(hookName).toBe('beforeLoadGraph') + expect(couldCaptureInsideHook).toBe(true) + expect(ChangeTracker.canCaptureCanvas(outgoing.changeTracker)).toBe(false) + }) + it('forwards clean and navigation intent to workflow navigation', async () => { app.canvasElRef.value = document.createElement('canvas') Reflect.set(app, 'rootGraphInternal', new LGraph()) diff --git a/src/scripts/app.ts b/src/scripts/app.ts index 909bc5c60cf..5b798178638 100644 --- a/src/scripts/app.ts +++ b/src/scripts/app.ts @@ -307,8 +307,20 @@ function createNodeOutputsMutationView( }) } -function beginGraphLoad(suppressWorkflowReset: boolean) { +/** + * Run the pre-load workflow bookkeeping and the `beforeLoadGraph` hook, then + * invalidate canvas ownership. + * + * Ownership is invalidated last, immediately before the caller replaces the + * canvas graph. Invalidating before the awaited hook leaves a window in which + * the outgoing workflow is still active with its graph still on the canvas, so + * a capture there is legitimate but would be dropped — and a failed target load + * would then repaint the retained workflow from an activeState missing that + * last change. + */ +async function beginGraphLoad(suppressWorkflowReset: boolean) { useWorkflowService().beforeLoadNewGraph(suppressWorkflowReset) + await useExtensionService().invokeExtensionsAsync('beforeLoadGraph') invalidateCanvasTracker() } @@ -1230,8 +1242,7 @@ export class ComfyApp implements IComfyApp { silentAssetErrors = false, workflowNavigationId } = options - beginGraphLoad(clean) - await useExtensionService().invokeExtensionsAsync('beforeLoadGraph') + await beginGraphLoad(clean) ChangeTracker.isLoadingGraph = true let reset_invalid_values = false @@ -2225,10 +2236,7 @@ export class ComfyApp implements IComfyApp { async () => { try { // false: final destination; no later load republishes the hash. - beginGraphLoad(false) - await useExtensionService().invokeExtensionsAsync( - 'beforeLoadGraph' - ) + await beginGraphLoad(false) } finally { useMissingNodesErrorStore().setMissingNodeTypes([]) } @@ -2412,8 +2420,7 @@ export class ComfyApp implements IComfyApp { options: { deferWarnings?: boolean } ): Promise { // false: no workflow load follows to republish the hash. - beginGraphLoad(false) - await useExtensionService().invokeExtensionsAsync('beforeLoadGraph') + await beginGraphLoad(false) this.canvas.setGraph(this.rootGraph) withGraphIntentSource('load', () => this.clean()) diff --git a/src/scripts/changeTracker.ts b/src/scripts/changeTracker.ts index caf542adf1b..f16ee5c1b59 100644 --- a/src/scripts/changeTracker.ts +++ b/src/scripts/changeTracker.ts @@ -354,7 +354,10 @@ function reportCanvasMismatchCall(method: string, workflowPath: string) { export class ChangeTracker implements WorkflowChangeTracker { static MAX_HISTORY = 50 - static bindCanvasTracker(tracker: ChangeTracker) { + // Ownership is identity only — these never call into the tracker — so they + // take the `WorkflowChangeTracker` contract a `ComfyWorkflow` exposes rather + // than the concrete class. + static bindCanvasTracker(tracker: WorkflowChangeTracker) { bindCanvasTracker(tracker) } @@ -362,11 +365,11 @@ export class ChangeTracker implements WorkflowChangeTracker { invalidateCanvasTracker() } - static isCanvasOwner(tracker: ChangeTracker): boolean { + static isCanvasOwner(tracker: WorkflowChangeTracker): boolean { return isCanvasOwner(tracker) } - static canCaptureCanvas(tracker: ChangeTracker): boolean { + static canCaptureCanvas(tracker: WorkflowChangeTracker): boolean { return canCaptureCanvas(tracker) } From 218abaeed33b9629d8af65c0e7c53f61fb8b8866 Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Sat, 17 Oct 2026 09:19:02 -0700 Subject: [PATCH 008/127] docs: define the three canvas-ownership states Completes the remaining half of the ownership encapsulation finding on #17331 (https://github.com/Comfy-Org/ComfyUI_frontend/pull/17331#discussion_r4021024348). The field is already private to this module and reachable only through the named transitions the review asked for, but the review also noted the documentation does not define the `false` state. Name all three states and say why `false` skips a capture silently instead of reporting it. --- src/scripts/canvasTrackerOwnership.ts | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/scripts/canvasTrackerOwnership.ts b/src/scripts/canvasTrackerOwnership.ts index aeaf7898ba4..e829bb240de 100644 --- a/src/scripts/canvasTrackerOwnership.ts +++ b/src/scripts/canvasTrackerOwnership.ts @@ -2,6 +2,15 @@ * Identifies which workflow tracker owns the graph currently shown on the * canvas. Kept outside ChangeTracker so workflow loading can consult ownership * without importing the tracker implementation (and its navigation stores). + * + * Three states, reachable only through the transitions below: + * - `null` — unbound. No tracker has claimed the canvas, so any tracker may + * capture it. This is the initial state and the one a test reset returns to. + * - a tracker — owned. Only that tracker may capture; any other capturing is a + * mismatch and is reported. + * - `false` — invalidated. A graph load is replacing the canvas, so no tracker + * owns it and every capture is skipped silently rather than reported, because + * a capture queued into that window is legitimate and merely stale. */ let canvasTracker: object | null | false = null From fb74747f47ca551e37a1f7059fbadbac9cca3bc7 Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Sat, 17 Oct 2026 09:25:01 -0700 Subject: [PATCH 009/127] Revert "docs: define the three canvas-ownership states" This reverts c9f6650acb, which I added earlier today to close the second half of the ownership finding on #17331. It was the wrong instrument. Root `AGENTS.md` prohibits added code comments, allows only curt JSDoc stating a contract in one or two lines on an *exported* API, and says explicitly that longer JSDoc is a violation and that rationale belongs in the commit message, the PR description, an issue or an ADR. `canvasTracker` is module-private, and the block was twelve lines of rationale, so it was outside the exception on both counts. `docs/guidance/engineering.md` would treat it as a blocking review finding, which is the opposite of what this PR needs. The reviewer's substantive ask was already satisfied by 7f36de30b8: the field is private to this module and reachable only through named transitions. The state definitions move to the PR description, which is where the standard routes them. --- src/scripts/canvasTrackerOwnership.ts | 9 --------- 1 file changed, 9 deletions(-) diff --git a/src/scripts/canvasTrackerOwnership.ts b/src/scripts/canvasTrackerOwnership.ts index e829bb240de..aeaf7898ba4 100644 --- a/src/scripts/canvasTrackerOwnership.ts +++ b/src/scripts/canvasTrackerOwnership.ts @@ -2,15 +2,6 @@ * Identifies which workflow tracker owns the graph currently shown on the * canvas. Kept outside ChangeTracker so workflow loading can consult ownership * without importing the tracker implementation (and its navigation stores). - * - * Three states, reachable only through the transitions below: - * - `null` — unbound. No tracker has claimed the canvas, so any tracker may - * capture it. This is the initial state and the one a test reset returns to. - * - a tracker — owned. Only that tracker may capture; any other capturing is a - * mismatch and is reported. - * - `false` — invalidated. A graph load is replacing the canvas, so no tracker - * owns it and every capture is skipped silently rather than reported, because - * a capture queued into that window is legitimate and merely stale. */ let canvasTracker: object | null | false = null From 65cdf71c8a04ed293d1ba82441a2989387442829 Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Sat, 17 Oct 2026 20:25:48 -0700 Subject: [PATCH 010/127] fix(workflow): harden canvas ownership regression --- .../workflowTabCanvasOwnership.spec.ts | 31 +++++--------- .../workflow/core/canvasTrackerOwnership.ts | 33 +++++++++++++++ .../core/services/workflowService.test.ts | 20 +++++---- .../workflow/core/services/workflowService.ts | 13 +----- src/scripts/app.test.ts | 26 +++++------- src/scripts/app.ts | 13 +----- src/scripts/canvasTrackerOwnership.ts | 30 ------------- src/scripts/changeTracker.test.ts | 19 +++++---- src/scripts/changeTracker.ts | 42 ++++--------------- 9 files changed, 86 insertions(+), 141 deletions(-) rename browser_tests/tests/{ => workflow}/workflowTabCanvasOwnership.spec.ts (50%) create mode 100644 src/platform/workflow/core/canvasTrackerOwnership.ts delete mode 100644 src/scripts/canvasTrackerOwnership.ts diff --git a/browser_tests/tests/workflowTabCanvasOwnership.spec.ts b/browser_tests/tests/workflow/workflowTabCanvasOwnership.spec.ts similarity index 50% rename from browser_tests/tests/workflowTabCanvasOwnership.spec.ts rename to browser_tests/tests/workflow/workflowTabCanvasOwnership.spec.ts index 1500915a8ce..e50f1abf383 100644 --- a/browser_tests/tests/workflowTabCanvasOwnership.spec.ts +++ b/browser_tests/tests/workflow/workflowTabCanvasOwnership.spec.ts @@ -4,34 +4,25 @@ import { } from '@e2e/fixtures/ComfyPage' import type { WorkspaceStore } from '@e2e/types/globals' -/** - * PM-875. A store-only activation moves the selected workflow without loading - * a graph, so the canvas keeps showing the previous tab's graph. Opening that - * workflow through the normal user route must then repaint the canvas rather - * than take the "already active" fast path and leave the mismatch in place. - * - * Source: https://github.com/Comfy-Org/ComfyUI_frontend/pull/17331 - */ -test.describe('Workflow tabs - canvas ownership', { tag: '@workflow' }, () => { +test.describe('Workflow tabs - canvas ownership', { tag: '@canvas' }, () => { test.beforeEach(async ({ comfyPage }) => { await comfyPage.workflow.setupWorkflowsDirectory({}) }) - test('Repaints the canvas for a workflow that was activated without a graph load', async ({ + test('Repaints and persists the workflow opened after a store-only activation', async ({ comfyPage }) => { - // Tab 0: default workflow (7 nodes), saved so it has a stable name. + test.info().annotations.push({ + type: 'issue', + description: 'https://linear.app/comfyorg/issue/PM-875' + }) + await expect.poll(() => comfyPage.nodeOps.getGraphNodesCount()).toBe(7) await comfyPage.menu.topbar.saveWorkflow('workflow-a') - // Tab 1: blank workflow (0 nodes). The canvas now holds this graph. await comfyPage.menu.topbar.triggerTopbarCommand(['New']) await expect.poll(() => comfyPage.nodeOps.getGraphNodesCount()).toBe(0) - // Activate workflow-a in the store only, with no graph load. This is what - // an extension or the agent does when it moves the selected workflow - // directly, and it is the state PM-875 was reported from: workflow-a reads - // as the active workflow while tab 1's blank graph is on the canvas. const activated = await comfyPage.page.evaluate(async () => { const workflowStore = (window.app!.extensionManager as WorkspaceStore) .workflow @@ -43,16 +34,16 @@ test.describe('Workflow tabs - canvas ownership', { tag: '@workflow' }, () => { return workflowStore.activeWorkflow?.path ?? null }) - // The defect, in visible terms: workflow-a is selected, canvas is empty. expect(activated).toContain('workflow-a') await expect.poll(() => comfyPage.nodeOps.getGraphNodesCount()).toBe(0) - // Open workflow-a the way a user does, from the workflows sidebar. Before - // the fix this returned immediately because the store already reported - // workflow-a active, so the blank graph stayed on the canvas. await comfyPage.menu.workflowsTab.open() await comfyPage.menu.workflowsTab.getPersistedItem('workflow-a').click() await expect.poll(() => comfyPage.nodeOps.getGraphNodesCount()).toBe(7) + + await comfyPage.workflow.reloadAndWaitForApp() + + await expect.poll(() => comfyPage.nodeOps.getGraphNodesCount()).toBe(7) }) }) diff --git a/src/platform/workflow/core/canvasTrackerOwnership.ts b/src/platform/workflow/core/canvasTrackerOwnership.ts new file mode 100644 index 00000000000..7c5a8bb9453 --- /dev/null +++ b/src/platform/workflow/core/canvasTrackerOwnership.ts @@ -0,0 +1,33 @@ +type CanvasTrackerOwnership = + | { status: 'unbound' } + | { status: 'bound'; tracker: object } + | { status: 'invalidated' } + +let ownership: CanvasTrackerOwnership = { status: 'unbound' } + +export function bindCanvasTracker(tracker: object): void { + ownership = { status: 'bound', tracker } +} + +export function invalidateCanvasTracker(): void { + ownership = { status: 'invalidated' } +} + +export function isCanvasOwner(tracker: object): boolean { + return ownership.status === 'bound' && ownership.tracker === tracker +} + +export function canCaptureCanvas(tracker: object): boolean { + return ( + ownership.status === 'unbound' || + (ownership.status === 'bound' && ownership.tracker === tracker) + ) +} + +export function isCanvasCaptureBlocked(): boolean { + return ownership.status === 'invalidated' +} + +export function resetCanvasTrackerForTest(): void { + ownership = { status: 'unbound' } +} diff --git a/src/platform/workflow/core/services/workflowService.test.ts b/src/platform/workflow/core/services/workflowService.test.ts index 4814bdfdc73..0b59cc13dc5 100644 --- a/src/platform/workflow/core/services/workflowService.test.ts +++ b/src/platform/workflow/core/services/workflowService.test.ts @@ -29,6 +29,12 @@ import { useMissingModelStore } from '@/platform/missingModel/missingModelStore' import { useMissingMediaStore } from '@/platform/missingMedia/missingMediaStore' import { app } from '@/scripts/app' import { ChangeTracker } from '@/scripts/changeTracker' +import { + bindCanvasTracker, + canCaptureCanvas, + invalidateCanvasTracker, + isCanvasOwner +} from '@/platform/workflow/core/canvasTrackerOwnership' import { useAppMode } from '@/composables/useAppMode' import type { ComfyWorkflowJSON } from '@/platform/workflow/validation/schemas/workflowSchema' import { createTestSubgraph } from '@/lib/litegraph/src/subgraph/__fixtures__/subgraphHelpers' @@ -672,7 +678,7 @@ describe('useWorkflowService', () => { const activeTracker = active.changeTracker if (!activeTracker) throw new Error('Expected loaded workflow') workflowStore.activeWorkflow = active as LoadedComfyWorkflow - ChangeTracker.bindCanvasTracker(activeTracker) + bindCanvasTracker(activeTracker) const service = useWorkflowService() await service.openWorkflow(active) @@ -702,7 +708,7 @@ describe('useWorkflowService', () => { await service.openWorkflow(active) expect(app.loadGraphData).toHaveBeenCalledOnce() - expect(ChangeTracker.isCanvasOwner(activeTracker)).toBe(true) + expect(isCanvasOwner(activeTracker)).toBe(true) }) it('re-opens a workflow normally once its close has settled', async () => { @@ -911,9 +917,9 @@ describe('useWorkflowService', () => { const retainedTracker = retained.changeTracker if (!retainedTracker) throw new Error('Expected loaded workflow') workflowStore.activeWorkflow = retained as LoadedComfyWorkflow - ChangeTracker.bindCanvasTracker(retainedTracker) + bindCanvasTracker(retainedTracker) vi.mocked(app.loadGraphData).mockImplementation(async () => { - ChangeTracker.invalidateCanvasTracker() + invalidateCanvasTracker() return false }) @@ -922,7 +928,7 @@ describe('useWorkflowService', () => { ) expect(app.loadGraphData).toHaveBeenCalledTimes(2) - expect(ChangeTracker.canCaptureCanvas(retainedTracker)).toBe(false) + expect(canCaptureCanvas(retainedTracker)).toBe(false) }) it('serializes rapid workflow opens so the final selection stays active', async () => { @@ -2199,9 +2205,7 @@ describe('useWorkflowService', () => { await useWorkflowService().afterLoadNewGraph('repeat', makeWorkflowData()) - expect(ChangeTracker.isCanvasOwner(existingWorkflow.changeTracker)).toBe( - true - ) + expect(isCanvasOwner(existingWorkflow.changeTracker)).toBe(true) expect( useNodeOutputStore().restorePreviewsForWorkflow ).toHaveBeenCalledWith(existingWorkflow.path) diff --git a/src/platform/workflow/core/services/workflowService.ts b/src/platform/workflow/core/services/workflowService.ts index e9adddae515..f95bc510054 100644 --- a/src/platform/workflow/core/services/workflowService.ts +++ b/src/platform/workflow/core/services/workflowService.ts @@ -28,7 +28,7 @@ import { useApp } from '@/scripts/appInstance' import { bindCanvasTracker, isCanvasOwner -} from '@/scripts/canvasTrackerOwnership' +} from '@/platform/workflow/core/canvasTrackerOwnership' import { blankGraph, defaultGraph } from '@/scripts/defaultGraph' import { useDialogService } from '@/services/dialogService' import { useAppMode } from '@/composables/useAppMode' @@ -737,17 +737,6 @@ export const useWorkflowService = () => { useExecutionErrorStore().setActiveGraph(rootGraphId, workflow.path) } - /** - * Activate `workflow` in the store and record its tracker as the one - * whose graph is on the canvas. This is the only place the two are - * bound together: loadGraphData() has just configured the root graph - * with this workflow's data. - * - * Returns null when the canvas graph was replaced while the store - * activation was in flight. Binding ownership then would name a tracker - * whose graph is no longer on the canvas, which is the corruption this - * binding exists to prevent. - */ async function bindToCanvas(workflow: ComfyWorkflow) { const loadedWorkflow = await workflowStore.openWorkflow(workflow) if (graphState !== useApp().rootGraphOrUndefined?.state) return null diff --git a/src/scripts/app.test.ts b/src/scripts/app.test.ts index 221a6862b65..0eac5739643 100644 --- a/src/scripts/app.test.ts +++ b/src/scripts/app.test.ts @@ -53,6 +53,10 @@ import { } from '@/platform/workflow/management/stores/workflowStore' import type { LoadedComfyWorkflow } from '@/platform/workflow/management/stores/comfyWorkflow' import { useWorkflowService } from '@/platform/workflow/core/services/workflowService' +import { + bindCanvasTracker, + canCaptureCanvas +} from '@/platform/workflow/core/canvasTrackerOwnership' import type { useWorkflowValidation } from '@/platform/workflow/validation/composables/useWorkflowValidation' import { createMockChangeTracker } from '@/utils/__tests__/litegraphTestUtils' import { ChangeTracker } from '@/scripts/changeTracker' @@ -536,18 +540,16 @@ describe('ComfyApp', () => { }) ) useWorkflowStore().activeWorkflow = outgoing - ChangeTracker.bindCanvasTracker(outgoing.changeTracker) + bindCanvasTracker(outgoing.changeTracker) let couldCaptureDuringDeactivate = false vi.mocked(outgoing.changeTracker.deactivate).mockImplementation(() => { - couldCaptureDuringDeactivate = ChangeTracker.canCaptureCanvas( - outgoing.changeTracker - ) + couldCaptureDuringDeactivate = canCaptureCanvas(outgoing.changeTracker) }) await app.loadGraphData(createWorkflowGraphData()) expect(couldCaptureDuringDeactivate).toBe(true) - expect(ChangeTracker.canCaptureCanvas(outgoing.changeTracker)).toBe(false) + expect(canCaptureCanvas(outgoing.changeTracker)).toBe(false) }) it('keeps the outgoing workflow able to capture across an awaiting beforeLoadGraph hook', async () => { @@ -563,22 +565,14 @@ describe('ComfyApp', () => { }) ) useWorkflowStore().activeWorkflow = outgoing - ChangeTracker.bindCanvasTracker(outgoing.changeTracker) - - // An extension hook that awaits real work crosses a task boundary, so a - // queued capture (the keydown rAF capture) can run here. The outgoing - // graph is still the one on the canvas, so that capture is legitimate: - // dropping it would let a failed target load repaint the retained - // workflow from an activeState missing its last change. + bindCanvasTracker(outgoing.changeTracker) let hookName: unknown let couldCaptureInsideHook: boolean | undefined mockExtensionService.invokeExtensionsAsync.mockImplementationOnce( async (hook: unknown) => { hookName = hook await Promise.resolve() - couldCaptureInsideHook = ChangeTracker.canCaptureCanvas( - outgoing.changeTracker - ) + couldCaptureInsideHook = canCaptureCanvas(outgoing.changeTracker) } ) @@ -586,7 +580,7 @@ describe('ComfyApp', () => { expect(hookName).toBe('beforeLoadGraph') expect(couldCaptureInsideHook).toBe(true) - expect(ChangeTracker.canCaptureCanvas(outgoing.changeTracker)).toBe(false) + expect(canCaptureCanvas(outgoing.changeTracker)).toBe(false) }) it('forwards clean and navigation intent to workflow navigation', async () => { diff --git a/src/scripts/app.ts b/src/scripts/app.ts index 5b798178638..73d81e201fc 100644 --- a/src/scripts/app.ts +++ b/src/scripts/app.ts @@ -19,7 +19,7 @@ import { resolveDynamicInputSpec } from '@/core/graph/widgets/dynamicInputSpec' import { setBackendNodeText, st, t } from '@/i18n' import { normalizeI18nKey } from '@/utils/formatUtil' import { ChangeTracker } from '@/scripts/changeTracker' -import { invalidateCanvasTracker } from '@/scripts/canvasTrackerOwnership' +import { invalidateCanvasTracker } from '@/platform/workflow/core/canvasTrackerOwnership' import { registerApp } from '@/scripts/appRegistry' import { clipspace, @@ -307,17 +307,6 @@ function createNodeOutputsMutationView( }) } -/** - * Run the pre-load workflow bookkeeping and the `beforeLoadGraph` hook, then - * invalidate canvas ownership. - * - * Ownership is invalidated last, immediately before the caller replaces the - * canvas graph. Invalidating before the awaited hook leaves a window in which - * the outgoing workflow is still active with its graph still on the canvas, so - * a capture there is legitimate but would be dropped — and a failed target load - * would then repaint the retained workflow from an activeState missing that - * last change. - */ async function beginGraphLoad(suppressWorkflowReset: boolean) { useWorkflowService().beforeLoadNewGraph(suppressWorkflowReset) await useExtensionService().invokeExtensionsAsync('beforeLoadGraph') diff --git a/src/scripts/canvasTrackerOwnership.ts b/src/scripts/canvasTrackerOwnership.ts deleted file mode 100644 index aeaf7898ba4..00000000000 --- a/src/scripts/canvasTrackerOwnership.ts +++ /dev/null @@ -1,30 +0,0 @@ -/** - * Identifies which workflow tracker owns the graph currently shown on the - * canvas. Kept outside ChangeTracker so workflow loading can consult ownership - * without importing the tracker implementation (and its navigation stores). - */ -let canvasTracker: object | null | false = null - -export function bindCanvasTracker(tracker: object): void { - canvasTracker = tracker -} - -export function invalidateCanvasTracker(): void { - canvasTracker = false -} - -export function isCanvasOwner(tracker: object): boolean { - return canvasTracker === tracker -} - -export function canCaptureCanvas(tracker: object): boolean { - return canvasTracker === null || canvasTracker === tracker -} - -export function isCanvasCaptureBlocked(): boolean { - return canvasTracker === false -} - -export function resetCanvasTrackerForTest(): void { - canvasTracker = null -} diff --git a/src/scripts/changeTracker.test.ts b/src/scripts/changeTracker.test.ts index 99804cc765e..26bf660e7ca 100644 --- a/src/scripts/changeTracker.test.ts +++ b/src/scripts/changeTracker.test.ts @@ -45,6 +45,10 @@ vi.mock(import('@/scripts/api')) import { app } from '@/scripts/app' import { api } from '@/scripts/api' import { ChangeTracker } from '@/scripts/changeTracker' +import { + bindCanvasTracker, + invalidateCanvasTracker +} from '@/platform/workflow/core/canvasTrackerOwnership' let nodeIdCounter = 0 let workflowPathCounter = 0 @@ -487,13 +491,10 @@ describe('ChangeTracker', () => { describe('canvas ownership', () => { it('does not copy the canvas graph into a workflow activated without a graph load', () => { - // Workflow A owns the canvas (afterLoadNewGraph bound it). const trackerA = createTracker(createState(2)) - ChangeTracker.bindCanvasTracker(trackerA) + bindCanvasTracker(trackerA) mockCanvasState(createState(2)) - // An extension calls useWorkflowStore().openWorkflow(B) directly: - // B becomes activeWorkflow but A's graph is still on the canvas. const originalB = createState(0) const trackerB = createTracker(originalB) @@ -509,7 +510,7 @@ describe('ChangeTracker', () => { it('does not persist the canvas graph via deactivate() into an unbound workflow', () => { const trackerA = createTracker(createState(2)) - ChangeTracker.bindCanvasTracker(trackerA) + bindCanvasTracker(trackerA) mockCanvasState(createState(2)) const originalB = createState(0) @@ -523,10 +524,10 @@ describe('ChangeTracker', () => { it('captures the canvas once the tracker is bound to the canvas', () => { const trackerA = createTracker(createState(2)) - ChangeTracker.bindCanvasTracker(trackerA) + bindCanvasTracker(trackerA) const trackerB = createTracker(createState(0)) - ChangeTracker.bindCanvasTracker(trackerB) + bindCanvasTracker(trackerB) const canvasState = createState(3) mockCanvasState(canvasState) @@ -549,7 +550,7 @@ describe('ChangeTracker', () => { it('silently skips capture while the canvas is being replaced', () => { const original = createState(0) const tracker = createTracker(original) - ChangeTracker.invalidateCanvasTracker() + invalidateCanvasTracker() mockCanvasState(createState(1)) tracker.captureCanvasState() @@ -717,7 +718,7 @@ describe('ChangeTracker', () => { tracker.captureCanvasState() mockCanvasState(lateState) - ChangeTracker.bindCanvasTracker(createTracker()) + bindCanvasTracker(createTracker()) useWorkflowStore().activeWorkflow = fromPartial({ changeTracker: tracker }) diff --git a/src/scripts/changeTracker.ts b/src/scripts/changeTracker.ts index f16ee5c1b59..d5d883fdc42 100644 --- a/src/scripts/changeTracker.ts +++ b/src/scripts/changeTracker.ts @@ -16,6 +16,11 @@ import { parseFlattenableSubgraphDefinitions } from '@/platform/workflow/core/utils/workflowFlattening' import type { ExecutedWsMessage } from '@/platform/remote/comfyui/execution/types' +import { + canCaptureCanvas, + isCanvasCaptureBlocked, + resetCanvasTrackerForTest +} from '@/platform/workflow/core/canvasTrackerOwnership' import { useDialogStore } from '@/stores/dialogStore' import { useExecutionStore } from '@/stores/executionStore' import { useNodeOutputStore } from '@/stores/nodeOutputStore' @@ -27,14 +32,6 @@ import { isSelectOnly } from '@/utils/litegraphUtil' import { isModalOpen } from '@/utils/modalUtil' import { api } from './api' -import { - bindCanvasTracker, - canCaptureCanvas, - invalidateCanvasTracker, - isCanvasCaptureBlocked, - isCanvasOwner, - resetCanvasTrackerForTest -} from './canvasTrackerOwnership' import { collectNodeHistoryWidgets, nodeHistoryValuesChanged, @@ -354,29 +351,6 @@ function reportCanvasMismatchCall(method: string, workflowPath: string) { export class ChangeTracker implements WorkflowChangeTracker { static MAX_HISTORY = 50 - // Ownership is identity only — these never call into the tracker — so they - // take the `WorkflowChangeTracker` contract a `ComfyWorkflow` exposes rather - // than the concrete class. - static bindCanvasTracker(tracker: WorkflowChangeTracker) { - bindCanvasTracker(tracker) - } - - static invalidateCanvasTracker() { - invalidateCanvasTracker() - } - - static isCanvasOwner(tracker: WorkflowChangeTracker): boolean { - return isCanvasOwner(tracker) - } - - static canCaptureCanvas(tracker: WorkflowChangeTracker): boolean { - return canCaptureCanvas(tracker) - } - - private static isCanvasCaptureBlocked(): boolean { - return isCanvasCaptureBlocked() - } - static resetCanvasTrackerForTest() { resetCanvasTrackerForTest() reportedCanvasMismatchCalls.clear() @@ -549,8 +523,8 @@ export class ChangeTracker implements WorkflowChangeTracker { reportInactiveTrackerCall('captureCanvasState', this.workflow.path) return } - if (ChangeTracker.isCanvasCaptureBlocked()) return - if (!ChangeTracker.canCaptureCanvas(this)) { + if (isCanvasCaptureBlocked()) return + if (!canCaptureCanvas(this)) { reportCanvasMismatchCall('captureCanvasState', this.workflow.path) return } @@ -585,7 +559,7 @@ export class ChangeTracker implements WorkflowChangeTracker { if ( this !== useWorkflowStore().activeWorkflow?.changeTracker || ChangeTracker.isLoadingGraph || - !ChangeTracker.canCaptureCanvas(this) + !canCaptureCanvas(this) ) return From b9b69ee9d9ae3e3b6f4b07025d37027ef1565f33 Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Sat, 17 Oct 2026 20:27:00 -0700 Subject: [PATCH 011/127] docs(architecture): claim canvas ownership state --- docs/architecture/domains/boundaries.json | 1 + .../domains/records/workflow-management.domain.json | 4 ++++ 2 files changed, 5 insertions(+) diff --git a/docs/architecture/domains/boundaries.json b/docs/architecture/domains/boundaries.json index 388d4bb4a63..615997e8fdb 100644 --- a/docs/architecture/domains/boundaries.json +++ b/docs/architecture/domains/boundaries.json @@ -3476,6 +3476,7 @@ "src/composables/useWorkflowActionsMenu.test.ts", "src/composables/useWorkflowActionsMenu.ts", "src/platform/workflow/core/services/**", + "src/platform/workflow/core/canvasTrackerOwnership.ts", "src/platform/workflow/core/utils/pendingWarnings.test.ts", "src/platform/workflow/core/utils/pendingWarnings.ts", "src/platform/workflow/core/utils/restoreDynamicGroupInputs.ts", diff --git a/docs/architecture/domains/records/workflow-management.domain.json b/docs/architecture/domains/records/workflow-management.domain.json index 983a980dcec..ffc9965bc96 100644 --- a/docs/architecture/domains/records/workflow-management.domain.json +++ b/docs/architecture/domains/records/workflow-management.domain.json @@ -63,6 +63,10 @@ "path": "src/platform/workflow/core/services/**", "role": "application" }, + { + "path": "src/platform/workflow/core/canvasTrackerOwnership.ts", + "role": "application" + }, { "path": "src/platform/workflow/core/utils/pendingWarnings.test.ts", "role": "application" From 9a360e1e324a007accb96f211c7fa57dad25100a Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Sat, 17 Oct 2026 20:30:42 -0700 Subject: [PATCH 012/127] refactor(workflow): sequence canvas replacement in service --- .../core/services/workflowService.test.ts | 11 +++ .../workflow/core/services/workflowService.ts | 2 + src/scripts/app.test.ts | 72 ++++++++----------- src/scripts/app.ts | 7 +- 4 files changed, 46 insertions(+), 46 deletions(-) diff --git a/src/platform/workflow/core/services/workflowService.test.ts b/src/platform/workflow/core/services/workflowService.test.ts index 0b59cc13dc5..04fedc83121 100644 --- a/src/platform/workflow/core/services/workflowService.test.ts +++ b/src/platform/workflow/core/services/workflowService.test.ts @@ -310,6 +310,17 @@ describe('useWorkflowService', () => { ).toHaveBeenCalledWith(true) }) + it('returns the canvas replacement transition', () => { + const tracker = createMockChangeTracker() + bindCanvasTracker(tracker) + + const replaceCanvas = useWorkflowService().beforeLoadNewGraph() + + expect(canCaptureCanvas(tracker)).toBe(true) + replaceCanvas() + expect(canCaptureCanvas(tracker)).toBe(false) + }) + it('stores a thumbnail of the active subgraph', () => { const activeWorkflow = createModeTestWorkflow() const subgraph = createTestSubgraph() diff --git a/src/platform/workflow/core/services/workflowService.ts b/src/platform/workflow/core/services/workflowService.ts index f95bc510054..41e0b9be950 100644 --- a/src/platform/workflow/core/services/workflowService.ts +++ b/src/platform/workflow/core/services/workflowService.ts @@ -27,6 +27,7 @@ import { useWorkflowThumbnail } from '@/renderer/core/thumbnail/useWorkflowThumb import { useApp } from '@/scripts/appInstance' import { bindCanvasTracker, + invalidateCanvasTracker, isCanvasOwner } from '@/platform/workflow/core/canvasTrackerOwnership' import { blankGraph, defaultGraph } from '@/scripts/defaultGraph' @@ -696,6 +697,7 @@ export const useWorkflowService = () => { // Save subgraph viewport before the canvas gets overwritten useSubgraphNavigationStore().saveCurrentViewport(suppressWorkflowReset) } + return invalidateCanvasTracker } /** diff --git a/src/scripts/app.test.ts b/src/scripts/app.test.ts index 0eac5739643..1c3fc2d4b09 100644 --- a/src/scripts/app.test.ts +++ b/src/scripts/app.test.ts @@ -53,10 +53,6 @@ import { } from '@/platform/workflow/management/stores/workflowStore' import type { LoadedComfyWorkflow } from '@/platform/workflow/management/stores/comfyWorkflow' import { useWorkflowService } from '@/platform/workflow/core/services/workflowService' -import { - bindCanvasTracker, - canCaptureCanvas -} from '@/platform/workflow/core/canvasTrackerOwnership' import type { useWorkflowValidation } from '@/platform/workflow/validation/composables/useWorkflowValidation' import { createMockChangeTracker } from '@/utils/__tests__/litegraphTestUtils' import { ChangeTracker } from '@/scripts/changeTracker' @@ -304,6 +300,7 @@ describe('ComfyApp', () => { vi.mocked(useWorkflowService).mockReturnValue( fromPartial(mockWorkflowService) ) + mockWorkflowService.beforeLoadNewGraph.mockReturnValue(vi.fn()) app = new ComfyApp() mockCanvas = createMockCanvas() as LGraphCanvas app.canvas = mockCanvas @@ -527,60 +524,49 @@ describe('ComfyApp', () => { expect(useToast().toasts).toEqual([]) }) - it('invalidates canvas ownership after deactivating the outgoing workflow', async () => { + it('replaces canvas ownership after preparing the outgoing workflow', async () => { app.canvasElRef.value = document.createElement('canvas') Reflect.set(app, 'rootGraphInternal', new LGraph()) - await useRealWorkflowService() mockWorkflowService.afterLoadNewGraph.mockResolvedValue() - const outgoing = markLoaded( - new ComfyWorkflow({ - path: 'workflows/outgoing.json', - modified: 0, - size: 0 - }) - ) - useWorkflowStore().activeWorkflow = outgoing - bindCanvasTracker(outgoing.changeTracker) - let couldCaptureDuringDeactivate = false - vi.mocked(outgoing.changeTracker.deactivate).mockImplementation(() => { - couldCaptureDuringDeactivate = canCaptureCanvas(outgoing.changeTracker) - }) + const replaceCanvas = vi.fn() + mockWorkflowService.beforeLoadNewGraph.mockReturnValue(replaceCanvas) await app.loadGraphData(createWorkflowGraphData()) - expect(couldCaptureDuringDeactivate).toBe(true) - expect(canCaptureCanvas(outgoing.changeTracker)).toBe(false) + expect(mockWorkflowService.beforeLoadNewGraph).toHaveBeenCalledOnce() + expect(replaceCanvas).toHaveBeenCalledOnce() + expect( + mockWorkflowService.beforeLoadNewGraph.mock.invocationCallOrder[0] + ).toBeLessThan(replaceCanvas.mock.invocationCallOrder[0]) }) - it('keeps the outgoing workflow able to capture across an awaiting beforeLoadGraph hook', async () => { + it('waits for the beforeLoadGraph hook before replacing canvas ownership', async () => { app.canvasElRef.value = document.createElement('canvas') Reflect.set(app, 'rootGraphInternal', new LGraph()) - await useRealWorkflowService() mockWorkflowService.afterLoadNewGraph.mockResolvedValue() - const outgoing = markLoaded( - new ComfyWorkflow({ - path: 'workflows/outgoing.json', - modified: 0, - size: 0 - }) - ) - useWorkflowStore().activeWorkflow = outgoing - bindCanvasTracker(outgoing.changeTracker) - let hookName: unknown - let couldCaptureInsideHook: boolean | undefined + const replaceCanvas = vi.fn() + mockWorkflowService.beforeLoadNewGraph.mockReturnValue(replaceCanvas) + let finishHook = () => {} + const hook = new Promise((resolve) => { + finishHook = resolve + }) mockExtensionService.invokeExtensionsAsync.mockImplementationOnce( - async (hook: unknown) => { - hookName = hook - await Promise.resolve() - couldCaptureInsideHook = canCaptureCanvas(outgoing.changeTracker) - } + async () => hook ) - await app.loadGraphData(createWorkflowGraphData()) + const load = app.loadGraphData(createWorkflowGraphData()) + await vi.waitFor(() => + expect(mockExtensionService.invokeExtensionsAsync).toHaveBeenCalledWith( + 'beforeLoadGraph' + ) + ) + + expect(replaceCanvas).not.toHaveBeenCalled() + + finishHook() + await load - expect(hookName).toBe('beforeLoadGraph') - expect(couldCaptureInsideHook).toBe(true) - expect(canCaptureCanvas(outgoing.changeTracker)).toBe(false) + expect(replaceCanvas).toHaveBeenCalledOnce() }) it('forwards clean and navigation intent to workflow navigation', async () => { diff --git a/src/scripts/app.ts b/src/scripts/app.ts index 73d81e201fc..f0295a74b42 100644 --- a/src/scripts/app.ts +++ b/src/scripts/app.ts @@ -19,7 +19,6 @@ import { resolveDynamicInputSpec } from '@/core/graph/widgets/dynamicInputSpec' import { setBackendNodeText, st, t } from '@/i18n' import { normalizeI18nKey } from '@/utils/formatUtil' import { ChangeTracker } from '@/scripts/changeTracker' -import { invalidateCanvasTracker } from '@/platform/workflow/core/canvasTrackerOwnership' import { registerApp } from '@/scripts/appRegistry' import { clipspace, @@ -308,9 +307,11 @@ function createNodeOutputsMutationView( } async function beginGraphLoad(suppressWorkflowReset: boolean) { - useWorkflowService().beforeLoadNewGraph(suppressWorkflowReset) + const replaceCanvas = useWorkflowService().beforeLoadNewGraph( + suppressWorkflowReset + ) await useExtensionService().invokeExtensionsAsync('beforeLoadGraph') - invalidateCanvasTracker() + replaceCanvas() } export class ComfyApp implements IComfyApp { From 3e950d6406bc8066964e9222420812acf5229a67 Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Thu, 22 Oct 2026 02:12:21 -0700 Subject: [PATCH 013/127] fix: skip preload capture for unowned canvas --- src/scripts/changeTracker.test.ts | 16 ++++++++++++++++ src/scripts/changeTracker.ts | 8 ++++++-- 2 files changed, 22 insertions(+), 2 deletions(-) diff --git a/src/scripts/changeTracker.test.ts b/src/scripts/changeTracker.test.ts index 26bf660e7ca..c7f8f57ac07 100644 --- a/src/scripts/changeTracker.test.ts +++ b/src/scripts/changeTracker.test.ts @@ -520,6 +520,7 @@ describe('ChangeTracker', () => { expect(trackerB.activeState).toBe(originalB) expect(app.rootGraph.serialize).not.toHaveBeenCalled() + expect(mockAssert).not.toHaveBeenCalled() }) it('captures the canvas once the tracker is bound to the canvas', () => { @@ -2143,6 +2144,21 @@ describe('ChangeTracker', () => { expect(app.rootGraph.serialize).not.toHaveBeenCalled() expect(tracker.activeState).toBe(original) }) + + it('does not capture when the active tracker does not own the canvas', () => { + const trackerA = createTracker(createState(2)) + bindCanvasTracker(trackerA) + mockCanvasState(createState(2)) + + const originalB = createState(0) + const trackerB = createTracker(originalB) + + trackerB.prepareForSave() + + expect(trackerB.activeState).toBe(originalB) + expect(app.rootGraph.serialize).not.toHaveBeenCalled() + expect(mockAssert).not.toHaveBeenCalled() + }) }) describe('checkState (deprecated)', () => { diff --git a/src/scripts/changeTracker.ts b/src/scripts/changeTracker.ts index d5d883fdc42..a8870c23204 100644 --- a/src/scripts/changeTracker.ts +++ b/src/scripts/changeTracker.ts @@ -432,7 +432,9 @@ export class ChangeTracker implements WorkflowChangeTracker { reportInactiveTrackerCall('deactivate', this.workflow.path) return } - if (!this._restoringState) this.captureCanvasState() + if (!this._restoringState && canCaptureCanvas(this)) { + this.captureCanvasState() + } this.store() } @@ -444,7 +446,9 @@ export class ChangeTracker implements WorkflowChangeTracker { * @internal Not part of the public extension API. */ prepareForSave() { - if (isActiveTracker(this)) this.captureCanvasState() + if (isActiveTracker(this) && canCaptureCanvas(this)) { + this.captureCanvasState() + } } restore() { From 1cc1e83b2bc3b98c9bdd63b2f560b211a834ad09 Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Thu, 29 Oct 2026 21:33:56 -0700 Subject: [PATCH 014/127] chore: prepare workflow ownership merge resolution --- docs/architecture/domains/boundaries.json | 2 +- .../records/workflow-management.domain.json | 8 ++++---- src/scripts/app.ts | 16 ++++++++-------- 3 files changed, 13 insertions(+), 13 deletions(-) diff --git a/docs/architecture/domains/boundaries.json b/docs/architecture/domains/boundaries.json index 48be653002a..c9fa0fa15b0 100644 --- a/docs/architecture/domains/boundaries.json +++ b/docs/architecture/domains/boundaries.json @@ -3466,10 +3466,10 @@ "src/composables/useWorkflowActionsMenu.test.ts", "src/composables/useWorkflowActionsMenu.ts", "src/platform/workflow/core/services/**", - "src/platform/workflow/core/canvasTrackerOwnership.ts", "src/platform/workflow/core/utils/pendingWarnings.test.ts", "src/platform/workflow/core/utils/pendingWarnings.ts", "src/platform/workflow/core/utils/restoreDynamicGroupInputs.ts", + "src/platform/workflow/core/canvasTrackerOwnership.ts", "src/platform/workflow/management/stores/**", "src/scripts/changeTracker.test.ts", "src/scripts/changeTracker.ts", diff --git a/docs/architecture/domains/records/workflow-management.domain.json b/docs/architecture/domains/records/workflow-management.domain.json index 40533e703b6..25c623deff7 100644 --- a/docs/architecture/domains/records/workflow-management.domain.json +++ b/docs/architecture/domains/records/workflow-management.domain.json @@ -63,10 +63,6 @@ "path": "src/platform/workflow/core/services/**", "role": "application" }, - { - "path": "src/platform/workflow/core/canvasTrackerOwnership.ts", - "role": "application" - }, { "path": "src/platform/workflow/core/utils/pendingWarnings.test.ts", "role": "application" @@ -143,6 +139,10 @@ "path": "src/types/workflowMenuItem.ts", "role": "domain" }, + { + "path": "src/platform/workflow/core/canvasTrackerOwnership.ts", + "role": "application" + }, { "path": "src/utils/syncUtil.ts", "role": "application" diff --git a/src/scripts/app.ts b/src/scripts/app.ts index f0295a74b42..ced8a566cdd 100644 --- a/src/scripts/app.ts +++ b/src/scripts/app.ts @@ -217,6 +217,14 @@ import { export { ANIM_PREVIEW_WIDGET } from '@/composables/node/useNodeAnimatedImage' +async function beginGraphLoad(suppressWorkflowReset: boolean) { + const replaceCanvas = useWorkflowService().beforeLoadNewGraph( + suppressWorkflowReset + ) + await useExtensionService().invokeExtensionsAsync('beforeLoadGraph') + replaceCanvas() +} + function isMeshModelFile(file: File): boolean { const name = file.name.toLowerCase() return SUPPORTED_MESH_EXTENSIONS.has(name.slice(name.lastIndexOf('.'))) @@ -306,14 +314,6 @@ function createNodeOutputsMutationView( }) } -async function beginGraphLoad(suppressWorkflowReset: boolean) { - const replaceCanvas = useWorkflowService().beforeLoadNewGraph( - suppressWorkflowReset - ) - await useExtensionService().invokeExtensionsAsync('beforeLoadGraph') - replaceCanvas() -} - export class ComfyApp implements IComfyApp { /** * List of entries to queue From b3969a3fc07f2c2fbc403d1363c1d66078b07445 Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Thu, 29 Oct 2026 21:36:28 -0700 Subject: [PATCH 015/127] docs: regenerate workflow architecture boundary --- docs/architecture/domains/boundaries.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/architecture/domains/boundaries.json b/docs/architecture/domains/boundaries.json index d7fcdaa733b..496a98823da 100644 --- a/docs/architecture/domains/boundaries.json +++ b/docs/architecture/domains/boundaries.json @@ -3402,12 +3402,12 @@ "src/platform/workflow/core/utils/pendingWarnings.ts", "src/platform/workflow/core/utils/pendingWarnings.test.ts", "src/platform/workflow/core/utils/restoreDynamicGroupInputs.ts", - "src/platform/workflow/core/canvasTrackerOwnership.ts", "src/platform/workflow/management/stores/**", "src/scripts/changeTracker.ts", "src/scripts/changeTracker.test.ts", "src/stores/workflowTabActivityStore.ts", "src/stores/workflowTabActivityStore.test.ts", + "src/platform/workflow/core/canvasTrackerOwnership.ts", "src/utils/syncUtil.ts" ] }, From 9a830022f2ec305da722329a77b257966e4b84df Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Sun, 1 Nov 2026 00:13:44 -0700 Subject: [PATCH 016/127] chore: keep graph-load resolution comment-free --- src/scripts/app.ts | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/scripts/app.ts b/src/scripts/app.ts index ca2538fb348..5179b2c62ec 100644 --- a/src/scripts/app.ts +++ b/src/scripts/app.ts @@ -2258,7 +2258,6 @@ export class ComfyApp implements IComfyApp { 'beforeLoadGraph' ) lifecycle.started = true - // false: final destination; no later load republishes the hash. const replaceCanvas = useWorkflowService().beforeLoadNewGraph(false) replaceCanvas() @@ -2455,7 +2454,6 @@ export class ComfyApp implements IComfyApp { try { await useExtensionService().invokeExtensionsAsync('beforeLoadGraph') lifecycleStarted = true - // false: no workflow load follows to republish the hash. const replaceCanvas = useWorkflowService().beforeLoadNewGraph(false) replaceCanvas() releaseCaptureSuppression = beginChangeCaptureSuppression() From f701b5d46d921b5f5348735bfea5d74251354e94 Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Sun, 1 Nov 2026 09:19:24 +0000 Subject: [PATCH 017/127] fix: do not mark unedited saved workflows unsaved after a reload (#22571) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## Summary Unedited saved workflows opened marked unsaved after a reload: the unsaved dot showed, the page title started with `*`, closing the tab asked to save, and reloading showed the browser's "Leave site?" prompt. Root cause: switching tabs writes a draft for the outgoing workflow even when it is unedited (`beforeLoadNewGraph` → `persistActiveWorkflowDraft`). After a reload, `ComfyWorkflow.load()` overlays that draft and set `isModified = true` whenever a draft existed, although the draft equals the saved file. Fix: when a draft is overlaid, mark the workflow modified only if the draft graph differs from the saved file, using the change tracker's existing `graphEqual` (which ignores the viewport). The draft is still overlaid, so a saved viewport is kept. This also clears the mark for drafts users already have in browser storage. The comparison is reached through the injected `WorkflowRuntime`, so the workflow model still does not import the change tracker. Not changed: tab switches still write drafts for unedited workflows. Skipping that write would conflict with #21440, which stores each tab's viewport in its draft. Linear: FRONT-3766. Reported in QA on testcloud cloud/1.59; it reproduces on cloud/1.58 too, so it is not a 1.59 regression. ## Verification - Red first, on CI: test-only head `ab1ed65e3d` failed both new `workflowStore.test.ts` cases (draft equal to the file; draft differing only by viewport) with `expected true to be false` (unit shard 4), and the new browser test failed at the restored-tab `isModified` check in chromium shard 16 (https://github.com/Comfy-Org/ComfyUI_frontend/actions/runs/41281652340/job/124775157225). The fix commit follows. - More unit cases: a draft that only changes app mode (`extra.linearMode`) stays marked modified. A draft or saved file with no `nodes` array stays marked modified and no longer throws; this case was red with a TypeError before the guard. - New browser test `Unedited saved workflows reopen as saved after a reload` in `workflowPersistence.spec.ts` follows the reported steps: save three workflows, visit each tab, reload, reopen the first two, and assert no unsaved mark and no `*` title. It also checks the tab that was active at the reload. - `vitest run src/platform/workflow src/scripts/changeTracker`: 125 files, 2423 passed. - `pnpm typecheck`, `pnpm typecheck:browser`, oxfmt, oxlint. ## Review notes An independent adversarial review (fresh Claude reviewer; cross-model was unavailable) raised: - comments in the changed function and tests: removed (repo rule). - `graphEqual` might treat swapped `widgets_values` as equal: checked, it does not. Only the top-level node array is compared unordered; arrays inside a node are compared in order. - a restored draft becomes the tracker's baseline in `activateLoadedWorkflow`, so editing and then reverting on a tab that had real draft edits can clear its unsaved mark. That is existing behaviour, not changed here; it is followed up separately. Known limits, followed up separately: a file that changes when it is loaded and serialized again (older frontend, external tool) can still reopen as modified. A viewport-only draft is restored once, then dropped like any unmodified draft (see #21440). --- .../fixtures/helpers/WorkflowHelper.ts | 10 +++ .../tests/workflowPersistence.spec.ts | 59 ++++++++++++++++ .../management/stores/comfyWorkflow.ts | 22 +++++- .../management/stores/workflowStore.test.ts | 67 +++++++++++++++++++ .../management/stores/workflowStore.ts | 1 + src/scripts/changeTrackerAccess.ts | 4 ++ 6 files changed, 160 insertions(+), 3 deletions(-) diff --git a/browser_tests/fixtures/helpers/WorkflowHelper.ts b/browser_tests/fixtures/helpers/WorkflowHelper.ts index 4657e723bb1..7ca3c40d017 100644 --- a/browser_tests/fixtures/helpers/WorkflowHelper.ts +++ b/browser_tests/fixtures/helpers/WorkflowHelper.ts @@ -288,6 +288,16 @@ export class WorkflowHelper { await this.waitForWorkflowIdle() } + /** A saved workflow's tab, opened and confirmed unmodified with no `*` title. */ + async expectTabOpensAsSaved(tabName: string): Promise { + await this.switchToTab(tabName) + await expect + .poll(() => this.comfyPage.menu.topbar.getActiveTabName()) + .toBe(tabName) + await expect.poll(() => this.isCurrentWorkflowModified()).toBe(false) + await expect.poll(() => this.comfyPage.page.title()).not.toMatch(/^\*/) + } + /** Node ids on the live graph, read from LiteGraph rather than the DOM. */ getGraphNodeIds(): Promise { return this.comfyPage.page.evaluate(() => diff --git a/browser_tests/tests/workflowPersistence.spec.ts b/browser_tests/tests/workflowPersistence.spec.ts index 978a7cc8b20..97e1fb3cfe3 100644 --- a/browser_tests/tests/workflowPersistence.spec.ts +++ b/browser_tests/tests/workflowPersistence.spec.ts @@ -1014,6 +1014,65 @@ test.describe('Workflow Persistence', () => { await expect(comfyPage.toast.toastErrors).toHaveCount(0) }) + test('Unedited saved workflows reopen as saved after a reload', async ({ + comfyPage + }) => { + test.info().annotations.push({ + type: 'regression', + description: + 'Switching tabs leaves a draft equal to the saved file; after a reload that draft marked the workflow unsaved' + }) + test.setTimeout(45_000) + + await comfyPage.settings.setSetting('Comfy.UseNewMenu', 'Top') + await comfyPage.settings.setSetting('Comfy.Workflow.Persist', true) + await comfyPage.settings.setSetting( + 'Comfy.Workflow.WorkflowTabsPosition', + 'Topbar' + ) + + const [first, second, third] = [ + generateUniqueFilename(), + generateUniqueFilename(), + generateUniqueFilename() + ] + await comfyPage.menu.topbar.saveWorkflow(first) + await comfyPage.menu.topbar.triggerTopbarCommand(['New']) + await comfyPage.menu.topbar.saveWorkflow(second) + await comfyPage.menu.topbar.triggerTopbarCommand(['New']) + await comfyPage.menu.topbar.saveWorkflow(third) + + await test.step('visit every tab without editing, leaving drafts behind', async () => { + await comfyPage.workflow.expectTabOpensAsSaved(first) + await comfyPage.workflow.expectTabOpensAsSaved(second) + await comfyPage.workflow.expectTabOpensAsSaved(third) + await waitForWorkflowTabState(comfyPage, 3) + await expect + .poll(async () => (await comfyPage.workflow.getDraftWorkflows()).length) + .toBeGreaterThanOrEqual(2) + }) + + await comfyPage.workflow.reloadAndWaitForApp() + + await test.step('the tab active at reload is restored as saved', async () => { + await expect + .poll(() => comfyPage.menu.topbar.getActiveTabName()) + .toBe(third) + await expect + .poll(() => comfyPage.workflow.isCurrentWorkflowModified()) + .toBe(false) + await expect.poll(() => comfyPage.page.title()).not.toMatch(/^\*/) + }) + + await test.step('the first restored tab reopens as saved', async () => { + await comfyPage.workflow.expectTabOpensAsSaved(first) + }) + + await test.step('the second restored tab reopens as saved', async () => { + await comfyPage.workflow.expectTabOpensAsSaved(second) + }) + }) + test('Flushes a pending draft edit before an immediate reload', async ({ comfyPage }) => { diff --git a/src/platform/workflow/management/stores/comfyWorkflow.ts b/src/platform/workflow/management/stores/comfyWorkflow.ts index 4b25bc33ab3..b06a610fec7 100644 --- a/src/platform/workflow/management/stores/comfyWorkflow.ts +++ b/src/platform/workflow/management/stores/comfyWorkflow.ts @@ -82,6 +82,8 @@ export interface WorkflowRuntime { workflow: ComfyWorkflow, initialState: ComfyWorkflowJSON ): WorkflowChangeTracker + /** `ChangeTracker.graphEqual`: the comparison that decides unsaved changes. */ + graphEqual(a: ComfyWorkflowJSON, b: ComfyWorkflowJSON): boolean getDraft(path: string): WorkflowDraft | null removeDraft(path: string): void markDraftUsed(path: string): void @@ -219,6 +221,18 @@ function readUsableDraft( } } +function draftMatchesSavedFile( + runtime: WorkflowRuntime, + saved: ComfyWorkflowJSON, + draft: ComfyWorkflowJSON +): boolean { + return ( + Array.isArray(saved.nodes) && + Array.isArray(draft.nodes) && + runtime.graphEqual(saved, draft) + ) +} + /** * The workflow object parsed from the stored text. Anything else (nothing * stored, empty text, JSON `null`, a number, an array) cannot back a change @@ -365,9 +379,11 @@ export class ComfyWorkflow extends UserFile { if (draft?.state && draft.content) { this.changeTracker.activeState = draft.state this.content = draft.content - this._isModified = true - // Saved-workflow draft overlay path; direct persisted-draft restores - // are touched in workflowDraftStoreV2.loadDraft(). + this._isModified = !draftMatchesSavedFile( + runtime, + initialState, + draft.state + ) runtime.markDraftUsed(this.path) } return this as this & LoadedComfyWorkflow diff --git a/src/platform/workflow/management/stores/workflowStore.test.ts b/src/platform/workflow/management/stores/workflowStore.test.ts index 11e33c44ef8..8eccba45f99 100644 --- a/src/platform/workflow/management/stores/workflowStore.test.ts +++ b/src/platform/workflow/management/stores/workflowStore.test.ts @@ -503,6 +503,73 @@ describe('useWorkflowStore', () => { expect(workflow.isModified).toBe(true) }) + describe('restoring a saved workflow over its draft', () => { + const loadWithDraft = async ( + draftData: string, + fileData = defaultGraphJSON + ) => { + enableWorkflowPersistence() + await syncRemoteWorkflowsWithMeta([ + { path: 'a.json', modified: 100, size: 1 } + ]) + const workflow = store.getWorkflowByPath('workflows/a.json')! + saveV2Draft(workflow.path, { data: draftData, name: 'a.json' }) + vi.mocked(api.getUserData).mockResolvedValue( + new Response(fileData, { status: 200 }) + ) + await workflow.load() + return workflow + } + + const draftWithExtra = (extra: ComfyWorkflowJSON['extra']) => { + const draftGraph: ComfyWorkflowJSON = structuredClone(defaultGraph) + draftGraph.extra = { ...draftGraph.extra, ...extra } + return JSON.stringify(draftGraph) + } + + it('does not mark it modified when the draft a tab switch left matches the file', async () => { + const workflow = await loadWithDraft(defaultGraphJSON) + + expect(workflow.activeState).toEqual(defaultGraph) + expect(workflow.isModified).toBe(false) + }) + + it('keeps the draft viewport without marking it modified', async () => { + const workflow = await loadWithDraft( + draftWithExtra({ ds: { scale: 2.5, offset: [40, -80] } }) + ) + + expect(workflow.activeState?.extra?.ds).toEqual({ + scale: 2.5, + offset: [40, -80] + }) + expect(workflow.isModified).toBe(false) + }) + + it('marks it modified when the draft only changes app mode', async () => { + const workflow = await loadWithDraft( + draftWithExtra({ linearMode: true }) + ) + + expect(workflow.activeState?.extra?.linearMode).toBe(true) + expect(workflow.isModified).toBe(true) + }) + + it('marks it modified when the draft has no node list to compare', async () => { + const workflow = await loadWithDraft('{"links":[]}') + + expect(workflow.activeState).toEqual({ links: [] }) + expect(workflow.isModified).toBe(true) + }) + + it('marks it modified when the saved file has no node list to compare', async () => { + const workflow = await loadWithDraft(defaultGraphJSON, '{"links":[]}') + + expect(workflow.activeState).toEqual(defaultGraph) + expect(workflow.isModified).toBe(true) + }) + }) + it('should discard a stale V2 draft when the remote workflow is newer', async () => { enableWorkflowPersistence() const remoteModifiedAt = Date.now() + 60_000 diff --git a/src/platform/workflow/management/stores/workflowStore.ts b/src/platform/workflow/management/stores/workflowStore.ts index 13b2c62b345..a1d636ed939 100644 --- a/src/platform/workflow/management/stores/workflowStore.ts +++ b/src/platform/workflow/management/stores/workflowStore.ts @@ -55,6 +55,7 @@ export { ComfyWorkflow, type LoadedComfyWorkflow } registerWorkflowRuntime({ createChangeTracker: (workflow, initialState) => new ChangeTrackerAccess(workflow, initialState), + graphEqual: (a, b) => ChangeTrackerAccess.graphEqual(a, b), getDraft: (path) => useWorkflowDraftStoreV2().getDraft(path), removeDraft: (path) => useWorkflowDraftStoreV2().removeDraft(path), markDraftUsed: (path) => useWorkflowDraftStoreV2().markDraftUsed(path), diff --git a/src/scripts/changeTrackerAccess.ts b/src/scripts/changeTrackerAccess.ts index 4f7e2119df2..a9802a41c57 100644 --- a/src/scripts/changeTrackerAccess.ts +++ b/src/scripts/changeTrackerAccess.ts @@ -10,6 +10,10 @@ interface ChangeTrackerClass { initialState: ComfyWorkflowJSON ): WorkflowChangeTracker readonly isLoadingGraph: boolean + graphEqual( + a: ComfyWorkflowJSON | null | undefined, + b: ComfyWorkflowJSON | null | undefined + ): boolean } /** `ChangeTracker` for the stores it imports, which cannot import it back. */ From e048fff282bbeb7de45077969224002a275289ab Mon Sep 17 00:00:00 2001 From: jaeone lee <89377375+jaeone94@users.noreply.github.com> Date: Sun, 1 Nov 2026 09:35:49 +0000 Subject: [PATCH 018/127] fix: show HDR dropdown previews for annotated output and temp values (#22330) ## ELI5 Picking or loading an HDR image (`.exr` or `.hdr`) in Load Image should show its stored preview. Three things got in the way. Values labelled with a folder, such as `sky.exr [output]`, were not recognised as HDR. A second write on load replaced the preview with an unrenderable placeholder. Files with the same name in different subfolders could also be confused with each other. All three are fixed here. ## Summary - `showHdrPreviewIfApplicable` in `useWidgetSelectActions.ts` ran `isHdrImageFilename` on the raw widget value. Annotated output and temp values end with ` [output]` or ` [temp]`, so only unannotated input values reached the preview. The value is now parsed with `parseImageWidgetValue` first. - `resolveWidgetValueAsset` looks in the value's own root (input vs output/temp) before falling back to the other. - Unhashed assets used to match on `name === filepath`. With hashing off (core's default), output rows are unhashed but carry a `preview_id`. That let `sky.exr [output]` take the preview of `renders/sky.exr`, and `renders/sky.exr [output]` matched nothing. They now match on subfolder plus name (`getAssetSubfolder`), with backslashes in the value normalised. - On workflow load or Insert as node, the image upload widget's deferred `setNodeOutputs` wrote the raw value over the preview the lookup had just resolved. `setNodeOutputs` now keeps an output that already holds a resolved preview for the same filename, subfolder and type. A different value still replaces it. Output EXRs missing from the dropdown's Generated tab are handled in #22471. - Part of #22196 ## Red-Green Verification | Commit | CI Status | Purpose | |--------|-----------|---------| | `test: cover HDR dropdown previews for annotated output and temp values` (`d877b45617`) | Red: [unit shard](https://github.com/Comfy-Org/ComfyUI_frontend/actions/runs/40983730198/job/123830638387), only the 2 new cases fail | Proves the test catches the bug | | `fix: check the parsed filename before showing an HDR dropdown preview` (`347cd90938`) | Green: [run 40984842588](https://github.com/Comfy-Org/ComfyUI_frontend/actions/runs/40984842588), all checks pass | Proves the fix resolves the bug | | `test: cover HDR previews overwritten by the widget path and unhashed subfolder lookups` (`3ce13176b6`) | Red: [shard 3](https://github.com/Comfy-Org/ComfyUI_frontend/actions/runs/41181102314/job/124479291558) and [shard 4](https://github.com/Comfy-Org/ComfyUI_frontend/actions/runs/41181102314/job/124479291570), only the 5 new cases fail | Proves the tests catch the overwrite and subfolder bugs | | `fix: keep a resolved HDR preview and match unhashed assets by subfolder` (`1acc26a3bd`) | Green: [unit](https://github.com/Comfy-Org/ComfyUI_frontend/actions/runs/41181798699/job/124482652044), all checks pass | Proves the fix resolves them | ## Provenance Authored by: agent-work loop. --- .../utils/resolveWidgetValueAsset.test.ts | 46 ++++++++++++ .../assets/utils/resolveWidgetValueAsset.ts | 22 ++++-- .../useWidgetSelectActions.test.ts | 71 +++++++++++-------- .../composables/useWidgetSelectActions.ts | 5 +- src/stores/nodeOutputStore.test.ts | 49 +++++++++++++ src/stores/nodeOutputStore.ts | 22 +++++- 6 files changed, 178 insertions(+), 37 deletions(-) diff --git a/src/platform/assets/utils/resolveWidgetValueAsset.test.ts b/src/platform/assets/utils/resolveWidgetValueAsset.test.ts index fce9a1dfdd9..3da2fc7282f 100644 --- a/src/platform/assets/utils/resolveWidgetValueAsset.test.ts +++ b/src/platform/assets/utils/resolveWidgetValueAsset.test.ts @@ -35,4 +35,50 @@ describe('resolveWidgetValueAsset', () => { expect(hashLookups[0].get('hash')).toBe(templateHash) expect(hashLookups[0].get('include_public')).toBe('true') }) + + it.for([ + { value: 'sky.exr', previewId: 'input-preview' }, + { value: 'sky.exr [output]', previewId: 'output-preview' }, + { value: 'sky.exr [temp]', previewId: 'output-preview' } + ])( + 'resolves $value from its own root when input and output share a name', + async ({ value, previewId }) => { + const store = useAssetsStore() + store.inputAssets = fromPartial({ + items: [{ name: 'sky.exr', preview_id: 'input-preview' }] + }) + store.outputAssets = fromPartial({ + items: [{ name: 'sky.exr', preview_id: 'output-preview' }] + }) + + const asset = await resolveWidgetValueAsset(value) + + expect(asset?.preview_id).toBe(previewId) + } + ) + + it.for([ + { value: 'sky.exr [output]', previewId: 'root-preview' }, + { value: 'renders/sky.exr [output]', previewId: 'renders-preview' }, + { value: 'renders\\sky.exr [output]', previewId: 'renders-preview' } + ])( + 'resolves unhashed $value by its subfolder', + async ({ value, previewId }) => { + const store = useAssetsStore() + store.outputAssets = fromPartial({ + items: [ + { + name: 'sky.exr', + user_metadata: { subfolder: 'renders' }, + preview_id: 'renders-preview' + }, + { name: 'sky.exr', preview_id: 'root-preview' } + ] + }) + + const asset = await resolveWidgetValueAsset(value) + + expect(asset?.preview_id).toBe(previewId) + } + ) }) diff --git a/src/platform/assets/utils/resolveWidgetValueAsset.ts b/src/platform/assets/utils/resolveWidgetValueAsset.ts index 0a51a31c494..1480a05f90b 100644 --- a/src/platform/assets/utils/resolveWidgetValueAsset.ts +++ b/src/platform/assets/utils/resolveWidgetValueAsset.ts @@ -3,27 +3,41 @@ import { toValue } from 'vue' import { useFeatureFlags } from '@/composables/useFeatureFlags' import { assetResponseSchema } from '@/platform/assets/schemas/assetSchema' import type { AssetItem } from '@/platform/assets/schemas/assetSchema' +import { getAssetSubfolder } from '@/platform/assets/utils/assetUrlUtil' import { api } from '@/scripts/api' import { useAssetsStore } from '@/stores/assetsStore' import { parseAnnotatedPath } from '@/utils/createAnnotatedPath' import { parseFilePath } from '@/utils/formatUtil' import { encodeParams } from '@/utils/requestUtil' +function getAssetRelativePath(asset: AssetItem): string { + const subfolder = getAssetSubfolder(asset) + return subfolder ? `${subfolder}/${asset.name}` : asset.name +} + /** Resolve a widget value to its asset: `null` when confirmed absent, `undefined` when unknown. */ export async function resolveWidgetValueAsset( widgetValue: string, { signal }: { signal?: AbortSignal } = {} ): Promise { - const { filepath } = parseAnnotatedPath(widgetValue) + const { filepath, rootFolder } = parseAnnotatedPath(widgetValue) const { filename: hashFilename } = parseFilePath( /[\\/]$/.test(filepath) ? '' : filepath ) + const relativePath = filepath.replaceAll('\\', '/') const assetMatches = (asset: AssetItem) => - asset.hash ? asset.hash === hashFilename : asset.name === filepath + asset.hash + ? asset.hash === hashFilename + : getAssetRelativePath(asset) === relativePath const assetsStore = useAssetsStore() + const inputItems = toValue(assetsStore.inputAssets.items) + const outputItems = toValue(assetsStore.outputAssets.items) + const [ownRootItems, otherRootItems] = + rootFolder === 'input' + ? [inputItems, outputItems] + : [outputItems, inputItems] const storedAsset = - toValue(assetsStore.inputAssets.items).find(assetMatches) ?? - toValue(assetsStore.outputAssets.items).find(assetMatches) + ownRootItems.find(assetMatches) ?? otherRootItems.find(assetMatches) if (storedAsset) return storedAsset if (!useFeatureFlags().flags.assetsEnabled) return undefined diff --git a/src/renderer/extensions/vueNodes/widgets/composables/useWidgetSelectActions.test.ts b/src/renderer/extensions/vueNodes/widgets/composables/useWidgetSelectActions.test.ts index a4f98ae1fbb..346e64b1be2 100644 --- a/src/renderer/extensions/vueNodes/widgets/composables/useWidgetSelectActions.test.ts +++ b/src/renderer/extensions/vueNodes/widgets/composables/useWidgetSelectActions.test.ts @@ -316,36 +316,47 @@ describe('useWidgetSelectActions', () => { }) describe('HDR preview', () => { - it('splits a backslash-separated value into subfolder and filename', async () => { - vi.mocked(resolveWidgetValueAsset).mockResolvedValue( - fromPartial({ preview_id: 'preview-1' }) - ) - const locatorId = fromPartial('7') - - useWidgetSelectActions({ - modelValue: ref('scenes\\sky.exr'), - dropdownItems: computed(() => []), - widget: () => - fromPartial>({ - name: 'image', - type: 'combo', - value: 'scenes\\sky.exr' - }), - uploadFolder: () => 'input', - uploadSubfolder: () => undefined, - locatorId: () => locatorId - }) + it.for([ + { + value: 'scenes\\sky.exr', + image: { filename: 'sky.exr', subfolder: 'scenes', type: 'input' } + }, + { + value: 'sky.exr [output]', + image: { filename: 'sky.exr', subfolder: '', type: 'output' } + }, + { + value: 'renders/sky.hdr [temp]', + image: { filename: 'sky.hdr', subfolder: 'renders', type: 'temp' } + } + ])( + 'previews $value from its root, subfolder and filename', + async ({ value, image }) => { + vi.mocked(resolveWidgetValueAsset).mockResolvedValue( + fromPartial({ preview_id: 'preview-1' }) + ) + const locatorId = fromPartial('7') + + useWidgetSelectActions({ + modelValue: ref(value), + dropdownItems: computed(() => []), + widget: () => + fromPartial>({ + name: 'image', + type: 'combo', + value + }), + uploadFolder: () => 'input', + uploadSubfolder: () => undefined, + locatorId: () => locatorId + }) - await vi.waitFor(() => - expect(useNodeOutputStore().nodeOutputs[locatorId]?.images).toEqual([ - { - filename: 'sky.exr', - subfolder: 'scenes', - preview_id: 'preview-1', - type: 'input' - } - ]) - ) - }) + await vi.waitFor(() => + expect(useNodeOutputStore().nodeOutputs[locatorId]?.images).toEqual([ + { ...image, preview_id: 'preview-1' } + ]) + ) + } + ) }) }) diff --git a/src/renderer/extensions/vueNodes/widgets/composables/useWidgetSelectActions.ts b/src/renderer/extensions/vueNodes/widgets/composables/useWidgetSelectActions.ts index 6d01682e5fa..8036700f250 100644 --- a/src/renderer/extensions/vueNodes/widgets/composables/useWidgetSelectActions.ts +++ b/src/renderer/extensions/vueNodes/widgets/composables/useWidgetSelectActions.ts @@ -78,12 +78,13 @@ export function useWidgetSelectActions(options: UseWidgetSelectActionsOptions) { const showHdrPreviewIfApplicable = wrapWithErrorHandlingAsync( async (widgetValue: string | undefined) => { - if (!widgetValue || !isHdrImageFilename(widgetValue)) return + if (!widgetValue) return + const { filename, subfolder, type } = parseImageWidgetValue(widgetValue) + if (!isHdrImageFilename(filename)) return const asset = await resolveWidgetValueAsset(widgetValue) if (!asset?.preview_id || modelValue.value !== widgetValue) return - const { filename, subfolder, type } = parseImageWidgetValue(widgetValue) setPreviewImage({ filename, preview_id: asset.preview_id, diff --git a/src/stores/nodeOutputStore.test.ts b/src/stores/nodeOutputStore.test.ts index 95b6841e93a..daa2509d40e 100644 --- a/src/stores/nodeOutputStore.test.ts +++ b/src/stores/nodeOutputStore.test.ts @@ -1086,6 +1086,55 @@ describe('nodeOutputStore setNodeOutputs (widget path)', () => { expect(node.images).not.toBe(store.nodeOutputs['5']?.images) }) + it.for([ + { + value: 'sky.exr', + preview: { filename: 'sky.exr', subfolder: '', type: 'input' as const } + }, + { + value: 'renders/sky.exr [output]', + preview: { + filename: 'sky.exr', + subfolder: 'renders', + type: 'output' as const + } + } + ])( + 'keeps the resolved preview of $value when the widget path writes it again', + ({ value, preview }) => { + const store = useNodeOutputStore() + const node = createMockNode({ id: 5 }) + const resolved = { ...preview, preview_id: 'preview-1' } + store.nodeOutputs['5'] = { images: [resolved] } + + store.setNodeOutputs(node, value) + + expect(store.nodeOutputs['5']?.images).toEqual([resolved]) + expect(app.nodeOutputs['5']?.images).toEqual([resolved]) + } + ) + + it('replaces a resolved preview when the widget path writes another value', () => { + const store = useNodeOutputStore() + const node = createMockNode({ id: 5 }) + store.nodeOutputs['5'] = { + images: [ + { filename: 'sky.exr', subfolder: '', type: 'output', preview_id: 'p' } + ] + } + + store.setNodeOutputs(node, 'other.exr [output]') + + const previewUrl = new URL( + store.getNodeImageUrls(node)?.[0] ?? '', + window.location.origin + ) + expect(store.nodeOutputs['5']?.images).toHaveLength(1) + expect(store.nodeOutputs['5']?.images?.[0]?.preview_id).toBeUndefined() + expect(previewUrl.searchParams.get('filename')).toBe('other.exr') + expect(previewUrl.searchParams.get('type')).toBe('output') + }) + it('should skip empty array of filenames after createOutputs', () => { const store = useNodeOutputStore() const node = createMockNode({ id: 5 }) diff --git a/src/stores/nodeOutputStore.ts b/src/stores/nodeOutputStore.ts index b519a1fdc52..047e9722768 100644 --- a/src/stores/nodeOutputStore.ts +++ b/src/stores/nodeOutputStore.ts @@ -31,6 +31,7 @@ import { executionIdToNodeLocatorId, getNodeByLocatorId } from '@/utils/graphTraversalUtil' +import { parseImageWidgetValue } from '@/utils/imageUtil' import { isAnimatedOutput, isVideoNode, @@ -60,6 +61,21 @@ const createOutputs = ( } } +function isResolvedPreviewOf( + output: ExecutedWsMessage['output'] | undefined, + widgetValue: string +): boolean { + const images = output?.images ?? [] + if (images.length !== 1 || !images[0].preview_id) return false + const [image] = images + const { filename, subfolder, type } = parseImageWidgetValue(widgetValue) + return ( + image.filename === filename && + (image.subfolder ?? '') === subfolder && + image.type === type + ) +} + const isResultItem = ( image: ResultItem | null | undefined ): image is ResultItem => image != null @@ -252,9 +268,13 @@ export const useNodeOutputStore = defineStore('nodeOutput', () => { const locatorId = nodeToNodeLocatorId(node) if (!locatorId) return if (typeof filenames === 'string') { + const existingOutput = nodeOutputs.value[locatorId] + const outputs = createOutputs([filenames], folder, isAnimated) setOutputsByLocatorId( locatorId, - createOutputs([filenames], folder, isAnimated) + isResolvedPreviewOf(existingOutput, filenames) + ? { ...outputs, images: existingOutput?.images } + : outputs ) } else if (!Array.isArray(filenames)) { setOutputsByLocatorId(locatorId, filenames) From 070eb3eaed1a0f476a1cc009ff28b1c34a4282bd Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Sun, 1 Nov 2026 09:56:37 +0000 Subject: [PATCH 019/127] fix(telemetry): stop paging when page-evaluated code runs an unknown command (#22409) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## Summary Sentry paged [CLOUD-FRONTEND-PROD-361](https://comfy-org.sentry.io/issues/7819207108/) on `Command Comfy.CloseWorkflow not found`. Nothing is broken for users: the ID has never existed in this repo, and the real command is `Workspace.CloseWorkflow`. This keeps the event in Sentry and tags it so it stops paging. A bad ID reached from our own code still pages. ## What the event shows - One event, one user, on 1.58.0. `custom_node_count` was 0. - Stack, oldest first: `:1:38` → Pinia `wrappedAction` → `commandStore.execute`. There is no first-party caller. - Reproduced in Chromium: with CDP `Runtime.evaluate`, `window.app?.extensionManager.command.execute('Comfy.CloseWorkflow')` throws from exactly `:1:38`. Other strings could land on that column, so that is consistent with a one-line page script, not proof of who ran it. `app.extensionManager.command.execute` is public and takes any string. The rejection comes from `commandStore`, so the top frame looks first-party. ## Change `tagSentryEvaluatedCommandCaller` sets `error_origin: third_party` when the last exception is `Command not found` and its direct caller is code evaluated in the page. That means a frame named `` with a line number; engine builtins share the name but have no line number. The `Send a notification for high priority issues` alert already skips `error_origin: third_party`, so no rule change is needed. Public behaviour is unchanged: `execute` still rejects, and the event is retained. ## Relation to #22403 [#22403](https://github.com/Comfy-Org/ComfyUI_frontend/pull/22403) sets the same tag from the top stack frame, which is `commandStore` here, so it treats this event as first-party. This PR adds its own file plus one line in `sentryBeforeSend`, so whichever lands second has a one-line rebase. ## Not changed - The 3 older `Command … not found` issues (`Comfy.ExportWorkflow`, `Comfy.ExportWorkflowAPI`, `Comfy.User.OpenSignInDialog`, all on `/cloud/login`) would keep paging: their callers are bundled code, and a test uses that shape. - A caller inside a custom extension file also keeps paging. No such event exists yet. - Datadog RUM classifies by the first `/assets/` line, so it still reads this as first-party. That only labels the error; it pages nobody. - No `Comfy.CloseWorkflow` alias: one event does not justify one. ## Testing - Red first: `sentryEvaluatedCommandCaller.test.ts` failed on the untagged event, then passed with the change. - `defaultStackParser` runs on the stack lines from the real Sentry events, so the frame shape is not hand-written. - `vitest` on `sentryBeforeSend`, `thirdPartyErrorNoise`, `initSentry` and the new file: 41 passed. No UI change. --------- Co-authored-by: Alexander Brown --- src/platform/telemetry/sentryBeforeSend.ts | 7 +- .../sentryEvaluatedCommandCaller.test.ts | 86 +++++++++++++++++++ .../telemetry/sentryEvaluatedCommandCaller.ts | 19 ++++ 3 files changed, 110 insertions(+), 2 deletions(-) create mode 100644 src/platform/telemetry/sentryEvaluatedCommandCaller.test.ts create mode 100644 src/platform/telemetry/sentryEvaluatedCommandCaller.ts diff --git a/src/platform/telemetry/sentryBeforeSend.ts b/src/platform/telemetry/sentryBeforeSend.ts index a849d10c664..bff18fb0418 100644 --- a/src/platform/telemetry/sentryBeforeSend.ts +++ b/src/platform/telemetry/sentryBeforeSend.ts @@ -2,6 +2,7 @@ import type { ErrorEvent, EventHint } from '@sentry/vue' import { WorkspaceApiError } from '@/platform/remote/ingest/ingestApiError' +import { tagSentryEvaluatedCommandCaller } from './sentryEvaluatedCommandCaller' import { sentryThirdPartyErrorFilter, tagSentryNonFirstPartyOrigin @@ -46,8 +47,10 @@ export function sentryBeforeSend( return ( kept && groupWorkspaceApiError( - tagSentryNonFirstPartyOrigin( - tagSentryStaleChunkCause(addVueDirectiveDiagnostics(kept, hint)) + tagSentryEvaluatedCommandCaller( + tagSentryNonFirstPartyOrigin( + tagSentryStaleChunkCause(addVueDirectiveDiagnostics(kept, hint)) + ) ), hint ) diff --git a/src/platform/telemetry/sentryEvaluatedCommandCaller.test.ts b/src/platform/telemetry/sentryEvaluatedCommandCaller.test.ts new file mode 100644 index 00000000000..a92205e4f83 --- /dev/null +++ b/src/platform/telemetry/sentryEvaluatedCommandCaller.test.ts @@ -0,0 +1,86 @@ +import type { ErrorEvent } from '@sentry/vue' +import { defaultStackParser } from '@sentry/vue' +import { describe, expect, it } from 'vitest' + +import { sentryBeforeSend } from './sentryBeforeSend' + +const STORE_FRAME = + 'at Proxy.execute (https://cloud.comfy.org/assets/commandStore-Dy_oX36E.js:1:8533)' +const PINIA_FRAME = + 'at wrappedAction (https://cloud.comfy.org/assets/vendor-vue-core-Dx3pCY9M.js:4:16131)' + +function commandErrorEvent( + value: string, + ...callerLines: string[] +): ErrorEvent { + const stack = [`Error: ${value}`, STORE_FRAME, PINIA_FRAME, ...callerLines] + return { + type: undefined, + exception: { + values: [ + { + type: 'Error', + value, + stacktrace: { frames: defaultStackParser(stack.join('\n')) } + } + ] + } + } +} + +const UNKNOWN_COMMAND = 'Command Comfy.CloseWorkflow not found' + +describe('Sentry origin of a rejected unknown command', () => { + it.for([ + UNKNOWN_COMMAND, + 'Command not found', + 'Command missing command not found' + ])('marks code evaluated in the page as third party: %s', (value) => { + const event = commandErrorEvent(value, 'at :1:38') + + expect(sentryBeforeSend(event, {})?.tags?.error_origin).toBe('third_party') + }) + + it.for([ + { + name: 'a bundled caller', + caller: + 'at HTMLButtonElement.onclick (https://cloud.comfy.org/assets/settingStore-C3KhBREl.js:207:137197)' + }, + { + name: 'an engine builtin called by the bundle', + caller: 'at Array.forEach ()' + } + ])('keeps paging for $name', ({ caller }) => { + const event = commandErrorEvent(UNKNOWN_COMMAND, caller) + + expect(sentryBeforeSend(event, {})).toEqual(event) + }) + + it('does not reclassify other errors thrown under evaluated code', () => { + const event = commandErrorEvent('Graph not ready', 'at :1:38') + + expect(sentryBeforeSend(event, {})).toEqual(event) + }) + + it('keeps an unknown command with no stack', () => { + const event: ErrorEvent = { + type: undefined, + exception: { values: [{ type: 'Error', value: UNKNOWN_COMMAND }] } + } + + expect(sentryBeforeSend(event, {})).toEqual(event) + }) + + it('preserves existing tags', () => { + const event = { + ...commandErrorEvent(UNKNOWN_COMMAND, 'at :1:38'), + tags: { surface: 'platform' } + } + + expect(sentryBeforeSend(event, {})?.tags).toEqual({ + surface: 'platform', + error_origin: 'third_party' + }) + }) +}) diff --git a/src/platform/telemetry/sentryEvaluatedCommandCaller.ts b/src/platform/telemetry/sentryEvaluatedCommandCaller.ts new file mode 100644 index 00000000000..5238b1cca84 --- /dev/null +++ b/src/platform/telemetry/sentryEvaluatedCommandCaller.ts @@ -0,0 +1,19 @@ +import type { ErrorEvent } from '@sentry/vue' + +const UNKNOWN_COMMAND = /^Command .* not found$/s +const COMMAND_STORE_FRAME_DEPTH = 2 + +function isCalledFromEvaluatedCode(event: ErrorEvent): boolean { + const exception = event.exception?.values?.at(-1) + if (!UNKNOWN_COMMAND.test(exception?.value ?? '')) return false + + const caller = exception?.stacktrace?.frames?.at( + -(COMMAND_STORE_FRAME_DEPTH + 1) + ) + return caller?.filename === '' && caller.lineno !== undefined +} + +export function tagSentryEvaluatedCommandCaller(event: ErrorEvent): ErrorEvent { + if (!isCalledFromEvaluatedCode(event)) return event + return { ...event, tags: { ...event.tags, error_origin: 'third_party' } } +} From 7520340c4555e55a7907f27a17bca160dd6bc04d Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Sun, 1 Nov 2026 10:00:09 +0000 Subject: [PATCH 020/127] fix: let the tracked .amp/services.yaml be staged again (#22575) ## Summary `.gitignore` ignores the whole `.amp` directory, but `.amp/services.yaml` is tracked (added in #14823). Git refuses to stage a path under an ignored directory, so `git add .amp/services.yaml` fails with "The following paths are ignored by one of your .gitignore files". lint-staged re-stages the files it formats, so any commit or merge that touches `.amp/services.yaml` fails in the pre-commit hook. This blocked a main merge into #14358. ## Changes - Ignore the contents of `.amp/` instead of the directory, and re-include `.amp/services.yaml`. Other local Amp state under `.amp/` stays ignored. ## Verification - Before: editing `.amp/services.yaml` then running `git add .amp/services.yaml` exits 1 with the "paths are ignored" error. - After: the same `git add` succeeds, and a new untracked `.amp/scratch.json` still shows as ignored (`git status --ignored`). --- .gitignore | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 526c5371bf5..48e07a8fc9a 100644 --- a/.gitignore +++ b/.gitignore @@ -107,7 +107,9 @@ vitest.config.*.timestamp* # Weekly docs check output /output.txt -.amp +# Amp local state stays ignored; the tracked orb service config must stay addable +.amp/* +!.amp/services.yaml # Registry census working tree (scripts/registry-census) - corpus, lockfile, results .census/ # Ecosystem matrix fixture (scripts/registry-census/build_matrix.py) - generated per-pack specs From df42cac525871fb44bdb18dbe7e47dc6f82c39a1 Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Sun, 1 Nov 2026 10:00:17 +0000 Subject: [PATCH 021/127] fix: restore the latest workflow tabs after a reload on Cloud (#22574) ## Summary On Comfy Cloud, reloading sometimes restores the workflow tabs as they were one reload earlier: a tab closed with Close Tabs to the Right comes back, or an older tab order returns. Reported in release QA on cloud/1.59 and reproduced on cloud/1.58, so it is not a 1.59 regression. Linear: FRONT-3767 ## Cause Cloud assigns a new client id on every page load (local ComfyUI keeps its id across reloads through `window.name`, so it is not affected). Until the socket connects, a page reads and writes its tab pointers under the previous page's id (`api.initialClientId`); after it connects, writes go under the new id. One browser tab's `sessionStorage` can then hold two `OpenPaths` / `ActivePath` pointers for the same workspace. On the next reload the new id has no entry, and `findAndMigratePointer` takes whichever matching pointer it finds first, often the older one. ## Fix `writeOpenPaths` and `writeActivePath` now write the session pointer and then drop this workspace's pointers under other client ids. `sessionStorage` belongs to one browser tab, so those pointers are only earlier page loads of the same tab. Pointers for other workspaces are kept. The `localStorage` copies are unchanged. When the current client id has no pointer, the read now tries the previous page load's id (`api.initialClientId`) before scanning. That covers a browser tab that already holds several pointers from before this change, and keeps restore correct if some future write path skips the pruning. ## Tests Red first on `main`: in `storageIO.test.ts` ("when the client id changes on every page load") the write-then-reload and leftover-pointer cases for open tabs and the active tab failed by restoring the older pointer, and `useWorkflowTabState.test.ts` failed the same way with a new client id; the other-workspace control passed. Green after the fix. `src/platform/workflow/persistence/` and `src/scripts/` unit suites pass locally (821 tests). An independent adversarial review found no correctness blocker; its suggestions (read-side preference, reuse the pointer type guards, no comments) are in the second commit. An end-to-end reload test would need a server that assigns a new client id per load (Cloud behaviour); the local test server reuses it, so this is covered at the storage layer. ## Backports `cloud/1.59` and `cloud/1.58` (the pointer-write code is identical there). Core trains are not affected because local ComfyUI keeps the client id across reloads. --- .../persistence/base/storageIO.test.ts | 160 ++++++++++++++++++ .../workflow/persistence/base/storageIO.ts | 142 ++++++++++++---- .../composables/useWorkflowTabState.test.ts | 28 +++ .../composables/useWorkflowTabState.ts | 4 +- 4 files changed, 297 insertions(+), 37 deletions(-) diff --git a/src/platform/workflow/persistence/base/storageIO.test.ts b/src/platform/workflow/persistence/base/storageIO.test.ts index 0bc75173e79..c93275f0b00 100644 --- a/src/platform/workflow/persistence/base/storageIO.test.ts +++ b/src/platform/workflow/persistence/base/storageIO.test.ts @@ -2,6 +2,7 @@ import { beforeEach, describe, expect, it, vi } from 'vitest' import type { DraftIndexV2, DraftPayloadV2 } from './draftTypes' import { + clearActivePath, clearAllWorkspaceStorage, clearAllWorkflowStorage, clearWorkflowRestoreState, @@ -275,6 +276,165 @@ describe('storageIO', () => { ) expect(JSON.parse(raw!).workspaceId).toBe('ws-B') }) + + describe('when the client id changes on every page load', () => { + const workspaceId = 'ws-reload' + + it('restores the open tabs written last, not an older list', () => { + writeOpenPaths('load-1', { + workspaceId, + paths: ['workflows/a.json', 'workflows/b.json', 'workflows/c.json'], + activeIndex: 0 + }) + + const latest = { + workspaceId, + paths: ['workflows/c.json', 'workflows/a.json'], + activeIndex: 0 + } + writeOpenPaths('load-2', latest) + + expect(readOpenPaths('load-3', workspaceId)).toEqual(latest) + }) + + it('restores the active tab written last, not an older one', () => { + writeActivePath('load-1', { workspaceId, path: 'workflows/a.json' }) + writeActivePath('load-2', { workspaceId, path: 'workflows/c.json' }) + + expect(readActivePath('load-3', workspaceId)).toEqual({ + workspaceId, + path: 'workflows/c.json' + }) + }) + + it('prefers the previous page load’s tabs over older leftovers', () => { + const older = { + workspaceId, + paths: ['workflows/a.json', 'workflows/b.json'], + activeIndex: 0 + } + const latest = { + workspaceId, + paths: ['workflows/b.json'], + activeIndex: 0 + } + sessionStorage.setItem( + 'Comfy.Workflow.OpenPaths:load-1', + JSON.stringify(older) + ) + sessionStorage.setItem( + 'Comfy.Workflow.OpenPaths:load-2', + JSON.stringify(latest) + ) + + expect(readOpenPaths('load-3', workspaceId, 'load-2')).toEqual(latest) + }) + + it('prefers the previous page load’s active tab over older leftovers', () => { + sessionStorage.setItem( + 'Comfy.Workflow.ActivePath:load-1', + JSON.stringify({ workspaceId, path: 'workflows/a.json' }) + ) + sessionStorage.setItem( + 'Comfy.Workflow.ActivePath:load-2', + JSON.stringify({ workspaceId, path: 'workflows/b.json' }) + ) + + expect(readActivePath('load-3', workspaceId, 'load-2')).toEqual({ + workspaceId, + path: 'workflows/b.json' + }) + }) + + it('drops every older tab list for the workspace when writing', () => { + sessionStorage.setItem( + 'Comfy.Workflow.OpenPaths:load-1', + JSON.stringify({ + workspaceId, + paths: ['workflows/load-1.json'], + activeIndex: 0 + }) + ) + sessionStorage.setItem( + 'Comfy.Workflow.OpenPaths:load-2', + JSON.stringify({ + workspaceId, + paths: ['workflows/load-2.json'], + activeIndex: 0 + }) + ) + sessionStorage.setItem( + 'Comfy.Workflow.OpenPaths:load-3', + JSON.stringify({ + workspaceId, + paths: ['workflows/load-3.json'], + activeIndex: 0 + }) + ) + const latest = { + workspaceId, + paths: ['workflows/latest.json'], + activeIndex: 0 + } + writeOpenPaths('load-4', latest) + + expect( + sessionStorage.getItem('Comfy.Workflow.OpenPaths:load-1') + ).toBeNull() + expect( + sessionStorage.getItem('Comfy.Workflow.OpenPaths:load-2') + ).toBeNull() + expect( + sessionStorage.getItem('Comfy.Workflow.OpenPaths:load-3') + ).toBeNull() + expect(readOpenPaths('load-5', workspaceId)).toEqual(latest) + }) + + it('restores the latest saved tabs when the session copy cannot be written', () => { + writeOpenPaths('load-1', { + workspaceId, + paths: ['workflows/old.json'], + activeIndex: 0 + }) + const latest = { + workspaceId, + paths: ['workflows/latest.json'], + activeIndex: 0 + } + const setItem = vi + .spyOn(sessionStorage, 'setItem') + .mockImplementation(() => { + throw new DOMException('full', 'QuotaExceededError') + }) + writeOpenPaths('load-2', latest) + setItem.mockRestore() + + expect(readOpenPaths('load-3', workspaceId)).toEqual(latest) + }) + + it('forgets the active tab saved under the previous page load’s id', () => { + writeActivePath('load-1', { workspaceId, path: 'workflows/a.json' }) + clearActivePath('load-2', workspaceId) + + expect(readActivePath('load-3', workspaceId)).toBeNull() + }) + + it('keeps another workspace’s tabs when writing this one', () => { + const other = { + workspaceId: 'ws-other', + paths: ['workflows/other.json'], + activeIndex: 0 + } + writeOpenPaths('load-1', other) + writeOpenPaths('load-2', { + workspaceId, + paths: ['workflows/a.json'], + activeIndex: 0 + }) + + expect(readOpenPaths('load-3', 'ws-other')).toEqual(other) + }) + }) }) describe('clearAllWorkflowStorage', () => { diff --git a/src/platform/workflow/persistence/base/storageIO.ts b/src/platform/workflow/persistence/base/storageIO.ts index 8c4ca4d49bf..0d66fd5953c 100644 --- a/src/platform/workflow/persistence/base/storageIO.ts +++ b/src/platform/workflow/persistence/base/storageIO.ts @@ -237,49 +237,38 @@ export function deleteOrphanPayloads( return deleted } -/** - * Searches sessionStorage for a pointer matching the target workspaceId - * when the exact clientId key has no entry (e.g. clientId changed after reload). - * Migrates the found pointer to the new clientId key. - */ function findAndMigratePointer( newKey: string, prefix: string, targetWorkspaceId: string, - isValid: (value: unknown) => value is T + isValid: (value: unknown) => value is T, + previousKey: string | null ): T | null { + const candidateKeys = previousKey ? [previousKey] : [] for (let i = 0; i < sessionStorage.length; i++) { const storageKey = sessionStorage.key(i) - if (!storageKey?.startsWith(prefix) || storageKey === newKey) continue - - const json = sessionStorage.getItem(storageKey) - if (!json) continue - - try { - const pointer: unknown = JSON.parse(json) - if (isValid(pointer) && pointer.workspaceId === targetWorkspaceId) { - sessionStorage.setItem(newKey, json) - sessionStorage.removeItem(storageKey) - return pointer - } - } catch { - continue + if (storageKey?.startsWith(prefix) && storageKey !== previousKey) { + candidateKeys.push(storageKey) } } + + for (const storageKey of candidateKeys) { + if (storageKey === newKey) continue + const pointer = readSessionValue(storageKey, isValid) + if (pointer?.workspaceId !== targetWorkspaceId) continue + sessionStorage.setItem(newKey, JSON.stringify(pointer)) + sessionStorage.removeItem(storageKey) + return pointer + } return null } -/** - * Reads a session pointer by clientId with workspace-based fallback. - * Validates workspace on exact match and removes stale cross-workspace pointers. - * If no valid entry exists, searches for any pointer matching the target - * workspaceId and migrates it to the new key. - */ function readSessionPointer( key: string, prefix: string, targetWorkspaceId: string | undefined, - isValid: (value: unknown) => value is T + isValid: (value: unknown) => value is T, + previousKey: string | null ): T | null { try { const json = sessionStorage.getItem(key) @@ -298,7 +287,13 @@ function readSessionPointer( } if (targetWorkspaceId) { - return findAndMigratePointer(key, prefix, targetWorkspaceId, isValid) + return findAndMigratePointer( + key, + prefix, + targetWorkspaceId, + isValid, + previousKey + ) } return null @@ -307,6 +302,63 @@ function readSessionPointer( } } +function writeSessionPointer( + key: string, + prefix: string, + pointer: T, + isValid: (value: unknown) => value is T +): void { + if (!isStorageAvailable()) return + + let saved = true + try { + sessionStorage.setItem(key, JSON.stringify(pointer)) + } catch { + saved = false + } + removeSessionPointers( + prefix, + pointer.workspaceId, + isValid, + saved ? key : null + ) +} + +function removeSessionPointers( + prefix: string, + workspaceId: string, + isValid: (value: unknown) => value is { workspaceId: string }, + keepKey: string | null +): void { + try { + const staleKeys: string[] = [] + for (let i = 0; i < sessionStorage.length; i++) { + const storageKey = sessionStorage.key(i) + if (!storageKey?.startsWith(prefix) || storageKey === keepKey) continue + if (readSessionValue(storageKey, isValid)?.workspaceId === workspaceId) { + staleKeys.push(storageKey) + } + } + for (const storageKey of staleKeys) sessionStorage.removeItem(storageKey) + } catch { + return + } +} + +function readSessionValue( + key: string, + isValid: (value: unknown) => value is T +): T | null { + const json = sessionStorage.getItem(key) + if (!json) return null + try { + const value: unknown = JSON.parse(json) + return isValid(value) ? value : null + } catch { + return null + } +} + /** * Reads the active path pointer from sessionStorage. * Falls back to workspace-based search when clientId changes after reload, @@ -314,7 +366,8 @@ function readSessionPointer( */ export function readActivePath( clientId: string | null, - targetWorkspaceId?: string + targetWorkspaceId?: string, + previousClientId: string | null = null ): ActivePathPointer | null { return ( (clientId @@ -322,7 +375,8 @@ export function readActivePath( StorageKeys.activePath(clientId), StorageKeys.prefixes.activePath, targetWorkspaceId, - isValidActivePathPointer + isValidActivePathPointer, + previousClientId ? StorageKeys.activePath(previousClientId) : null ) : null) ?? (targetWorkspaceId @@ -343,7 +397,12 @@ export function writeActivePath( pointer: ActivePathPointer ): void { const json = JSON.stringify(pointer) - writeStorage(sessionStorage, StorageKeys.activePath(clientId), json) + writeSessionPointer( + StorageKeys.activePath(clientId), + StorageKeys.prefixes.activePath, + pointer, + isValidActivePathPointer + ) writeStorage( localStorage, StorageKeys.lastActivePath(pointer.workspaceId), @@ -357,8 +416,14 @@ export function clearActivePath(clientId: string, workspaceId: string): void { sessionStorage.removeItem(StorageKeys.activePath(clientId)) localStorage.removeItem(StorageKeys.lastActivePath(workspaceId)) } catch { - // Storage access can throw in private-mode browsers; nothing to undo. + return } + removeSessionPointers( + StorageKeys.prefixes.activePath, + workspaceId, + isValidActivePathPointer, + null + ) } /** @@ -368,7 +433,8 @@ export function clearActivePath(clientId: string, workspaceId: string): void { */ export function readOpenPaths( clientId: string | null, - targetWorkspaceId?: string + targetWorkspaceId?: string, + previousClientId: string | null = null ): OpenPathsPointer | null { return ( (clientId @@ -376,7 +442,8 @@ export function readOpenPaths( StorageKeys.openPaths(clientId), StorageKeys.prefixes.openPaths, targetWorkspaceId, - isValidOpenPathsPointer + isValidOpenPathsPointer, + previousClientId ? StorageKeys.openPaths(previousClientId) : null ) : null) ?? (targetWorkspaceId @@ -397,7 +464,12 @@ export function writeOpenPaths( pointer: OpenPathsPointer ): void { const json = JSON.stringify(pointer) - writeStorage(sessionStorage, StorageKeys.openPaths(clientId), json) + writeSessionPointer( + StorageKeys.openPaths(clientId), + StorageKeys.prefixes.openPaths, + pointer, + isValidOpenPathsPointer + ) writeStorage( localStorage, StorageKeys.lastOpenPaths(pointer.workspaceId), diff --git a/src/platform/workflow/persistence/composables/useWorkflowTabState.test.ts b/src/platform/workflow/persistence/composables/useWorkflowTabState.test.ts index ae7285228ca..eb70935c2dd 100644 --- a/src/platform/workflow/persistence/composables/useWorkflowTabState.test.ts +++ b/src/platform/workflow/persistence/composables/useWorkflowTabState.test.ts @@ -132,4 +132,32 @@ describe('useWorkflowTabState', () => { activeIndex: 1 }) }) + + it('restores the previous page load’s tabs when Cloud assigns a new client id', async () => { + sessionStorage.setItem( + 'Comfy.Workflow.OpenPaths:older-load', + JSON.stringify({ + workspaceId: 'personal', + paths: ['workflows/a.json', 'workflows/b.json'], + activeIndex: 0 + }) + ) + sessionStorage.setItem( + 'Comfy.Workflow.OpenPaths:previous-load', + JSON.stringify({ + workspaceId: 'personal', + paths: ['workflows/b.json'], + activeIndex: 0 + }) + ) + const { api } = await import('@/scripts/api') + api.clientId = 'this-load' + api.initialClientId = 'previous-load' + const { useWorkflowTabState } = await import('./useWorkflowTabState') + + expect(useWorkflowTabState().getOpenPaths()).toEqual({ + paths: ['workflows/b.json'], + activeIndex: 0 + }) + }) }) diff --git a/src/platform/workflow/persistence/composables/useWorkflowTabState.ts b/src/platform/workflow/persistence/composables/useWorkflowTabState.ts index 0d39d6fb0d9..020edd51dbe 100644 --- a/src/platform/workflow/persistence/composables/useWorkflowTabState.ts +++ b/src/platform/workflow/persistence/composables/useWorkflowTabState.ts @@ -39,7 +39,7 @@ export function useWorkflowTabState() { const clientId = getClientId() const workspaceId = getWorkspaceId() - const pointer = readActivePath(clientId, workspaceId) + const pointer = readActivePath(clientId, workspaceId, api.initialClientId) return pointer?.path ?? null } @@ -74,7 +74,7 @@ export function useWorkflowTabState() { const clientId = getClientId() const workspaceId = getWorkspaceId() - const pointer = readOpenPaths(clientId, workspaceId) + const pointer = readOpenPaths(clientId, workspaceId, api.initialClientId) if (!pointer) return null return { paths: pointer.paths, activeIndex: pointer.activeIndex } From ba8840487840203adb281f0c2f643ce75ee61e38 Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Sun, 1 Nov 2026 10:11:05 +0000 Subject: [PATCH 022/127] fix(agent): make the tour's workflow card match what the panel does (#22560) ## Summary #22269 changed tour card 2 to "Each chat works on one workflow". That is not what the panel does. I ran the panel and recorded what happens, then rewrote the card to match. New card 2: > **The agent edits one workflow at a time** > That workflow is named at the top of the message box. Click the name to pick another. Clicking a workflow tab can open its latest chat, unless the message box has a draft. Card 2 after the change, from the CI golden: ![Tour card 2 next to the message box](https://raw.githubusercontent.com/Comfy-Org/ComfyUI_frontend/6787a2a86c/browser_tests/tests/agent/agentOnboarding.spec.ts-snapshots/agent-tour-workflow-card-cloud-linux.png) ## What the running panel does Local cloud build of `main` at 69de892d6d, served by ComfyUI, agent server mocked by the tab-activation e2e fixture: | Action | What happened | Old card | New card | | --- | --- | --- | --- | | Open a chat, then click the workflow name at the top of the message box and pick another open workflow | Same chat, now editing the other workflow. The panel says "It works on 1 workflow at a time, and you can switch workflows during chat." | Wrong ("each chat works on one workflow") | Covered ("Click the name to pick another") | | Switch to a tab whose workflow has a chat | That workflow's latest chat opens | Right | Right | | Switch to a new unsaved tab (no chat) | Open chat stays and keeps its workflow; the panel shows "You're viewing a different workflow from the target" | Right ("if it has one") | Right ("a tab that has a chat") | | Type a message, then switch tabs | Open chat and draft stay | Missing | Covered ("unless the message box has a draft") | | New empty chat, then switch tabs | Target follows the visible tab (existing notice); switching to a tab with a chat opens that chat | Not contradicted | Not contradicted | ## Tests - `AgentPanelRoot.test.ts`: the tour card cases failed on the old copy and pass on the new copy. - `agentTabActivationFollowsChat.spec.ts`: new case pins the card's claim that picking another name in the message box points the open chat at that workflow. Passed locally against the cloud build. - `agentOnboarding.spec.ts`: new golden `agent-tour-workflow-card.png` frames card 2 with the message box. It is generated in CI by `/update-playwright`. Other languages still show older card 2 text. The release locale step retranslates changed English strings (`scripts/i18n/update-locales.ts` compares against `.source-manifest.json`). Linear: https://linear.app/comfyorg/issue/PM-2396 Thread: https://comfy-organization.slack.com/archives/C0A8Z4U7Y1K/p1792786860191779 --------- Co-authored-by: github-actions --- .../tests/agent/agentOnboarding.spec.ts | 6 ++++ .../agent-tour-workflow-card-cloud-linux.png | Bin 0 -> 37633 bytes .../agentTabActivationFollowsChat.spec.ts | 29 ++++++++++++++++++ src/locales/en/main.json | 4 +-- .../extensions/agent/AgentPanelRoot.test.ts | 6 ++-- 5 files changed, 40 insertions(+), 5 deletions(-) create mode 100644 browser_tests/tests/agent/agentOnboarding.spec.ts-snapshots/agent-tour-workflow-card-cloud-linux.png diff --git a/browser_tests/tests/agent/agentOnboarding.spec.ts b/browser_tests/tests/agent/agentOnboarding.spec.ts index ae68ad33c3d..f3acdaa036e 100644 --- a/browser_tests/tests/agent/agentOnboarding.spec.ts +++ b/browser_tests/tests/agent/agentOnboarding.spec.ts @@ -161,6 +161,12 @@ test.describe('Agent onboarding tour', { tag: ['@cloud', '@ui'] }, () => { '2 of 3' ) await expect(agentPanel.tourSkipButton(workflow)).toHaveCount(1) + await expectRegionScreenshot( + page, + [workflow, page.locator('#agent-composer')], + 'agent-tour-workflow-card.png', + { padding: 16 } + ) await workflow.getByRole('button', { name: enMessages.g.next }).click() const history = await agentPanel.expectTourCard( diff --git a/browser_tests/tests/agent/agentOnboarding.spec.ts-snapshots/agent-tour-workflow-card-cloud-linux.png b/browser_tests/tests/agent/agentOnboarding.spec.ts-snapshots/agent-tour-workflow-card-cloud-linux.png new file mode 100644 index 0000000000000000000000000000000000000000..1fa21abeb4134f610cbac593473c62e83a7d7857 GIT binary patch literal 37633 zcmb5WWmuKL8a4__cXxL;(v7qd??vO?Vq#G&e?h>TCL6FXG*!$bpIp^o$ z7Z+=-_g(MIGxOXvM5rpuq9PF?K|w*G%F9WsLqWZog@S_SMR*1NQsf&+4F!b(B`+5+Mq1#g7Yzi@s1ZF;%ndL@Jj>y?^xe8e?goUkbY+9O|*X%7U;Kfqe^t))u$;llY95UV9 z+%|IS>+9?4lBf~72#$}BNl8ihs~Q`%8E{6NK6&3)Ws?aB#bmi(>$xkIN>-0fs_`FB z-qv*o*4Ea}f0fzP)7KyTfJiewW>B(*0HLUWF3Bw_B6fT)i8v`yqAA%B0HyZf1ETS( zis zHkn?)9U}}-Kff?wz9F=M1aJFtq}7VG2oz~(fDA%P~!98Tk_l$Gi&{rwPrrB8uvW@(!+yTV~m*!@i`nG$5u@DrH~%HGP_x{LN3 zR1p}l>gsBQFVqNBezZ`x|D^DEi~b^?DqEd z`ue()lM{)LPrt5=iV(?H{%6PHdF~}fZ!U;h};&XCNx3+>iF>IM3TCnhrVGF%0D+Uf; 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 { + await tabChats.openChatFromHistory('Landscape chat') + await tabChats.openChatFromHistory('Portrait chat') + const composer = tabChats.panel.root.getByTestId('agent-composer') + await expect(tabChats.panel.workflowPicker).toContainText(PORTRAIT_NAME) + await expect( + composer.getByRole('button', { name: enMessages.agent.switchWorkflow }) + ).toBeVisible() + + await tabChats.panel.workflowPicker.click() + await tabChats.panel.root + .page() + .getByRole('menuitemradio', { name: LANDSCAPE_NAME }) + .click() + await tabChats.waitForFollowToSettle() + + await expect(tabChats.panel.workflowPicker).toContainText(LANDSCAPE_NAME) + await expect( + tabChats.topbar + .getWorkflowTab(LANDSCAPE_NAME) + .and(tabChats.topbar.getActiveTab()) + ).toBeVisible() + await expect(tabChats.panel.userMessageBubbles).toHaveText([ + PORTRAIT_REQUEST + ]) + }) + test('keeps a chat hidden when its workflow cannot be restored', async ({ tabChats }) => { diff --git a/src/locales/en/main.json b/src/locales/en/main.json index 167f9f06681..e8bc334ba38 100644 --- a/src/locales/en/main.json +++ b/src/locales/en/main.json @@ -6251,8 +6251,8 @@ "coachProgress": "{current} of {total}", "coachTitle": "Meet your Comfy Agent", "coachBody": "Describe your ideas, ask it to build and run workflows. It sees your canvas and files.", - "coachWorkflowTitle": "Each chat works on one workflow", - "coachWorkflowBody": "The workflow it's editing is named above the message box. Switching tabs brings up that workflow's latest chat, if it has one.", + "coachWorkflowTitle": "The agent edits one workflow at a time", + "coachWorkflowBody": "That workflow is named at the top of the message box. Click the name to pick another. Clicking a workflow tab can open its latest chat, unless the message box has a draft.", "coachHistoryTitle": "Pick up where you left off", "coachHistoryBody": "Previous chats are saved here. Open one to review it or continue working with the agent.", "coachHoldNotice": "Your message will send when you finish or skip the tour.", diff --git a/src/workbench/extensions/agent/AgentPanelRoot.test.ts b/src/workbench/extensions/agent/AgentPanelRoot.test.ts index 6c7258a5d2c..fd8144b4666 100644 --- a/src/workbench/extensions/agent/AgentPanelRoot.test.ts +++ b/src/workbench/extensions/agent/AgentPanelRoot.test.ts @@ -1026,9 +1026,9 @@ describe('AgentPanelRoot onboarding', () => { 'Describe your ideas, ask it to build and run workflows. It sees your canvas and files.' }, { - title: 'Each chat works on one workflow', + title: 'The agent edits one workflow at a time', description: - "The workflow it's editing is named above the message box. Switching tabs brings up that workflow's latest chat, if it has one." + 'That workflow is named at the top of the message box. Click the name to pick another. Clicking a workflow tab can open its latest chat, unless the message box has a draft.' }, { title: 'Pick up where you left off', @@ -9199,7 +9199,7 @@ describe('AgentPanelRoot workflow binding', () => { await user.click( within( await screen.findByRole('dialog', { - name: 'Each chat works on one workflow' + name: 'The agent edits one workflow at a time' }) ).getByRole('button', { name: 'Next' }) ) From 08fa386a41bffe2d3d0047af9f28db350b209ada Mon Sep 17 00:00:00 2001 From: Matt Miller Date: Sun, 1 Nov 2026 10:50:33 +0000 Subject: [PATCH 023/127] fix(billing): render usage-log tooltips from an explicit param allowlist (#17858) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## ELI5 The usage log has a little (i) icon whose tooltip printed *every* field the billing feed happened to attach to an event. That feed's field list is open-ended, so anything the backend starts storing shows up in a customer's tooltip for free — today that includes our internal provider-cost numbers and, on the workspace-scoped feed, other members' prompts. This PR replaces "print everything" with "print these twelve fields", so the tooltip can only ever show what we chose to show. The agent usage charge is still shown, as credits. ## Summary `getTooltipContent` now renders a fixed allowlist of `params` keys instead of iterating the object, as plain-text `Key: value` lines that `UsageLogsTable.vue` passes to the design-system tooltip. `hasAdditionalInfo` is derived from that same list, so the icon is only shown when the tooltip has something to say. ## Changes - **What**: a new pure module `src/services/customerEventParams.ts` holds `TOOLTIP_PARAM_ALLOWLIST` (`credits_used`, `amount`, `model`, `api_name`, `endpoint`, `subscription_id`, `gpu_seconds`, `duration`, plus the agent usage keys `charge_micro_usd`, `input_tokens`, `output_tokens`, `cached_input_tokens` that main's #21251 renders and its browser test asserts). `getTooltipContent` renders only allowlisted keys with a non-null, non-empty value, one `Key: value` line each. A numeric `charge_micro_usd` renders as `Charge: N Credits`, or `Charge: <1 Credits` for a non-zero charge under one credit (#21251's formatting and #22470's sub-credit rule from the component, now done inside `getTooltipContent`). Main's tooltip migration (#16325) made the tooltip plain text, so values are no longer HTML and need no escaping; the table now calls `getTooltipContent` instead of its own unfiltered `additionalInfoTooltip`. `hasAdditionalInfo` uses the same present-key filter, minus the keys the Details column already shows for that event type (`credit_added` → `amount`, `api_usage_completed` → `api_name`/`model`, matching `UsageLogsTable.vue`), so a shown icon always has a non-empty tooltip. The service and its manual mock (`src/services/__mocks__/customerEventsService.ts`) both use this module, so component tests see production filtering. - **Breaking**: user-visible narrowing. A params key outside the allowlist is no longer rendered, and a row whose only extra params are outside it no longer shows an info icon. That is the intended effect, not a regression. - Tests: `customerEventsService.test.ts` now asserts the allowlist directly, including a case built from a params object carrying `prompt`, `credits` and `final_unit_deduction` alongside a legitimate key — the output is exactly the legitimate key. The old tests asserted the leaky behaviour (they used `extra_param`, `transaction_id` and `status` as examples of things that *should* render), so they were rewritten rather than extended. ## Review Focus **Why a frontend allowlist and not just a backend strip.** The generated ingest schema in this repo types the field as an open map — `packages/ingest-types/src/zod.gen.ts:3655` has `params: z.record(z.string(), z.unknown()).optional()`, with no named keys at all. There is no contract here saying which keys arrive, which is precisely why a denylist or a backend-only fix can be silently re-opened by the next thing the backend decides to store. An allowlist at the render site cannot be. **Both rails are covered.** `UsageLogsTable.vue` feeds rows from either `customerEventService.getMyEvents()` (legacy) or the workspace read (`billingApi.getBillingEvents()` or the billing rail's `readEvents`) into the same `hasAdditionalInfo` / `getTooltipContent` pair, so the workspace-scope prompt exposure is closed by the same change. I grepped for other consumers: `usePendingTopup` reads `event_type` / `createdAt` only and never touches `params`, and `UsageLogsTable.vue` is the only renderer. No other call site. **Red-then-green was checked, not assumed.** I ran the new service tests against the unmodified implementation: 4 failed, and the failure output printed the leak verbatim (`Prompt: a private prompt…
Credits: 500,000,000
Final Unit Deduction: 12,345`). With the fix applied, 45 pass. **Judgment call worth a look.** `hasAdditionalInfo` leaves out the keys the Details column already prints for that event type, so the icon doesn't light up on rows with nothing new to say. The guarantee runs one way: if the icon is shown, the tooltip is non-empty. The reverse doesn't hold: an `api_usage_completed` row with only `model` has tooltip content but no icon. Event types whose Details column shows none of these keys (`api_node_usage`, `gpu_usage`, `topup_completed`) show the icon for any allowlisted key. Rendering order is now the allowlist's order rather than the backend's object-key order. Deterministic either way; flagging it because it is a visible diff in the tooltip for multi-key rows. ## Residual **The backend still stores and returns these fields.** This PR is the defence-in-depth half only. The upstream feed continues to persist the raw properties map and return it whole, so any *other* consumer of that endpoint — now or later — still receives the provider-cost keys and the prompt. The server-side strip is tracked separately and deliberately not blocked on this change. **Benign fields were narrowed away too.** Keys such as `transaction_id` and `status` appeared in this repo's own prior tests as things the tooltip rendered. They are not on the allowlist and so are now dropped. If any of them is load-bearing for support workflows, the allowlist is the one place to add it back — but it should be added deliberately, and the additions should stay in sync with the sibling surface below. **Unexercised artifacts.** (1) The sibling module that this allowlist is meant to match is not in this repository — grep finds no `auditLogDisplay` anywhere in this checkout. The original eight keys were transcribed from the specification of this change, not read from that module's source, so a reviewer with access to it should confirm the list is still identical. (2) I made no live or staging call to the billing events endpoint from this environment, so *which* keys real events actually carry is unverified from here; the only in-repo evidence is the open-map schema cited above (which names no keys) and the single E2E mock in `browser_tests/fixtures/apiKeyAuthFixture.ts:153`, which sends `params: { amount }` only. That mock's row shows no info icon before or after this change, so E2E behaviour is unchanged — but it also means nothing in this repo can demonstrate a populated tooltip end to end. Concretely: if the live feed turns out to use different names for these concepts, this change would render an empty tooltip rather than a wrong one, and the icon would correctly not appear — a fail-closed outcome, but one that would go unnoticed until someone looks at a real usage log. **Out of scope by design.** Whether a workspace owner should be able to read other members' prompts *at all* is a product and privacy-posture question about the feed's workspace scope, not a rendering decision. This PR only stops this surface from displaying them. ## Provenance - **Authored by:** agent-work loop - **Verified:** - Merged `main` at `63b649ef70` (the 10 later `main` commits touch none of these files and merge cleanly): the table now uses main's telemetry and icon changes, and #22470's `<1` charge rule moved into `getTooltipContent`. Its charge cases moved from `UsageLogsTable.test.ts` to `customerEventsService.test.ts`, because the component test mocks the service. - `vitest run` on `customerEventsService.test.ts` and `UsageLogsTable.test.ts` at the current head: 99 passed, including the sub-credit charge cases and the component case that keeps a `prompt` param out of the tooltip. - `pnpm typecheck`, `pnpm knip`, eslint and oxfmt on the touched files: clean. `pnpm architecture:check`: passes, with a non-blocking warning that `customerEventParams.ts` is unclaimed by a domain, one of 324 such warnings. - The browser test `usageLogsChargeTooltip.spec.ts`, including its sub-credit screenshot, was not run locally; CI's required `e2e-status` check passes on the current head. - **Deviations:** - The allowlist tests live mainly in `customerEventsService.test.ts` because `UsageLogsTable.test.ts` mocks the whole service module; the mock shares the filter module, so the component case above exercises the real filtering. - Main's new `no-circular` rule flagged a type-only import from `customerEventParams.ts` back to the service. That import and its `satisfies` key check were removed; the `hasAdditionalInfo` tests still pin the event-type keys. - The agent usage token counts were allowlisted to keep #21251's tooltip contents. - Review findings asking to restore `transaction_id`/`status`/`payment_method` were deferred as a product decision. --------- Co-authored-by: Claude Opus 5.5 --- .../settings/UsageLogsTable.test.ts | 66 +++--- .../components/settings/UsageLogsTable.vue | 42 +--- .../__mocks__/customerEventsService.ts | 17 +- src/services/customerEventParams.ts | 45 +++++ src/services/customerEventsService.test.ts | 190 ++++++++++++++---- src/services/customerEventsService.ts | 47 ++++- 6 files changed, 284 insertions(+), 123 deletions(-) create mode 100644 src/services/customerEventParams.ts diff --git a/src/platform/billing/components/settings/UsageLogsTable.test.ts b/src/platform/billing/components/settings/UsageLogsTable.test.ts index 9727cf861b7..d84a9d098ad 100644 --- a/src/platform/billing/components/settings/UsageLogsTable.test.ts +++ b/src/platform/billing/components/settings/UsageLogsTable.test.ts @@ -290,12 +290,9 @@ describe('UsageLogsTable', () => { expect(infoButtons.length).toBeGreaterThan(0) }) - it('shows each event param on its own tooltip line', async () => { - vi.mocked(useCustomerEventsService().formatJsonKey).mockImplementation( - (key) => `key(${key})` - ) - vi.mocked(useCustomerEventsService().formatJsonValue).mockImplementation( - (value) => `value(${String(value)})` + it('shows the service tooltip content with one param per line', async () => { + vi.mocked(useCustomerEventsService().getTooltipContent).mockReturnValue( + 'Amount: 1,000\nModel: test-model' ) await renderLoaded() @@ -305,43 +302,36 @@ describe('UsageLogsTable', () => { await userEvent.hover(firstInfoButton) expect((await screen.findByRole('tooltip')).textContent).toBe( - 'key(amount): value(1000)\nkey(transaction_id): value(txn-123)' + 'Amount: 1,000\nModel: test-model' ) }) - it.for([ - { charge: 33_044, expected: 'Charge: 7 Credits' }, - { charge: '36209', expected: 'Charge: 8 Credits' }, - { charge: 10_000_000_000, expected: 'Charge: 2,110,000 Credits' }, - { charge: 0, expected: 'Charge: 0 Credits' }, - { charge: 1, expected: 'Charge: <1 Credits' }, - { charge: 1_000, expected: 'Charge: <1 Credits' }, - { charge: 3_318, expected: 'Charge: <1 Credits' }, - { charge: 4_740, expected: 'Charge: 1 Credits' }, - { charge: 6_636, expected: 'Charge: 1 Credits' }, - { charge: 'n/a', expected: 'charge_micro_usd: n/a' } - ])( - 'shows charge_micro_usd $charge as $expected', - async ({ charge, expected }) => { - vi.mocked(useCustomerEventsService().getMyEvents).mockResolvedValue( - makeEventsResponse([ - { - event_id: 'agent-1', - event_type: 'agent_usage', - params: { charge_micro_usd: charge }, - createdAt: '2024-01-03T10:00:00Z' - } - ]) - ) - await renderLoaded() + it('keeps params outside the allowlist out of the tooltip', async () => { + vi.mocked(useCustomerEventsService().getMyEvents).mockResolvedValue( + makeEventsResponse([ + { + event_id: 'event-4', + event_type: EventType.API_USAGE_COMPLETED, + params: { + api_name: 'Chat', + model: 'test-model', + input_tokens: 42, + prompt: 'secret prompt text' + }, + createdAt: '2024-01-01T10:00:00Z' + } + ]) + ) + await renderLoaded() - await userEvent.hover( - screen.getByRole('button', { name: 'Additional Info' }) - ) + await userEvent.hover( + screen.getByRole('button', { name: 'Additional Info' }) + ) - expect((await screen.findByRole('tooltip')).textContent).toBe(expected) - } - ) + const tooltip = await screen.findByRole('tooltip') + expect(tooltip).toHaveTextContent('input_tokens: 42') + expect(tooltip).not.toHaveTextContent('secret prompt text') + }) it('does not render info buttons when no additional info', async () => { vi.mocked(useCustomerEventsService().hasAdditionalInfo).mockReturnValue( diff --git a/src/platform/billing/components/settings/UsageLogsTable.vue b/src/platform/billing/components/settings/UsageLogsTable.vue index a75a9550875..d59c7147063 100644 --- a/src/platform/billing/components/settings/UsageLogsTable.vue +++ b/src/platform/billing/components/settings/UsageLogsTable.vue @@ -63,7 +63,7 @@