From 98b020eb899b32e3c0457a576622820624bd40f7 Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Sat, 24 Oct 2026 08:03:50 +0000 Subject: [PATCH] refactor(workflow): report user-initiated tab activations (#21791) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Extracted from #21512 so the shared workflow and topbar paths can be reviewed without the 6,400-line Agent feature attached. **Nothing user-visible changes in this PR.** Two related changes to the workflow service: 1. **An explicit `initiator: 'user'` option** on `openWorkflow`, `loadNextOpenedWorkflow`, `loadPreviousOpenedWorkflow` and the new `closeWorkflows`, plus a `workflowStore.onUserActivation` event hook that fires only for those calls. The nine call sites that are genuinely a user clicking a tab, a menu item or a keybinding now pass it. Programmatic activations — including the page-hash restore on first load, which is retargeted from `'route'` to a new `'restore'` intent source — deliberately do not. **Nothing subscribes to the hook yet**, so it is inert until #21512 lands on top. 2. **`workflowService.closeWorkflows()`**, which absorbs the close-many loop that `WorkflowTabs.vue` and `BaseWorkflowsSidebarTab.vue` each reimplemented (break on the first close that returns false). Doing it in the service is what makes the batch report *at most one* user activation: `closeWorkflow` reports the replacement tab it opened through a new `onReplacementOpened` callback, and `closeWorkflows` reports only the replacement still active once the whole batch settles. The `closeWorkflows` consolidation is not a drive-by tidy-up. A per-tab close loop in the caller cannot tell "the user closed four tabs and landed on tab five" from "the user activated five tabs in a row", because each intermediate `closeWorkflow` opens a replacement. Moving the loop into the service is the only place that sees the whole batch, so the activation semantics and the consolidation have to land together. - `workflowService.ts` — the `closeWorkflows` `try`/`finally`, specifically that the `initiator === 'user' && workflowStore.isActive(replacement)` guard is what suppresses the superseded intermediate replacements. - `subgraphNavigationStore.ts` — the `'route'` → `'restore'` split on the initial-load intent. This is the one behavioural judgement call here: a restored page hash opens a workflow, and that is not a user activation. Explanatory comments in `workflowService.ts` and `subgraphNavigationStore.ts` that #21512 dropped are preserved here. - **Unit tests:** 235 passing across the 5 changed suites, including a new `describe('user activations')` block in `workflowService.test.ts` (+177) covering: a user-initiated open reports; a failed load does not report; a batch close reports once; a tab something else activated mid-close does not report; a superseded replacement does not report; and an earlier close's tab is still reported when a later close throws. New `subgraphNavigationStore` case asserts a restored page hash opens the workflow *without* `initiator: 'user'`. - **No-regression sweep:** 1,291 further tests passing across the 24 other suites that exercise `openWorkflow`/`closeWorkflow`, including the Agent suites (`AgentPanelRoot.test.ts`, 647 tests) that mock the service. - **Commit gates:** app typecheck, scoped type-aware oxlint, eslint, stylelint, oxfmt, server-facts — all clean. Push gates: Fallow changed-line audit clean on all 15 files. - Base at verification: `479cecf9ac9c98ad65b6aca186775793a7d30bc6`. - **#21512 is the dependent.** It carries the Agent tab→chat follow feature (PM-1270, PM-1257) that consumes `onUserActivation`. These hunks will drop out of its diff when it rebases after this merges. - No new user-facing strings, no i18n change, no Agent paths touched. --------- Co-authored-by: christian-byrne --- .../sidebar/tabs/BaseWorkflowsSidebarTab.vue | 7 +- .../topbar/WorkflowOverflowMenu.test.ts | 2 +- .../topbar/WorkflowOverflowMenu.vue | 2 +- src/components/topbar/WorkflowTab.test.ts | 15 +- src/components/topbar/WorkflowTab.vue | 23 +- src/components/topbar/WorkflowTabs.test.ts | 58 +++- src/components/topbar/WorkflowTabs.vue | 19 +- src/composables/useCoreCommands.ts | 9 +- .../useWorkflowActionsMenu.test.ts | 6 +- src/composables/useWorkflowActionsMenu.ts | 2 +- .../services/__mocks__/workflowService.ts | 1 + .../core/services/workflowService.test.ts | 269 +++++++++++++++++- .../workflow/core/services/workflowService.ts | 69 ++++- .../management/stores/workflowStore.ts | 18 ++ .../extensions/linearMode/MobileDisplay.vue | 3 +- ...raphNavigationStore.navigateToHash.test.ts | 33 ++- src/stores/subgraphNavigationStore.ts | 19 +- 17 files changed, 472 insertions(+), 83 deletions(-) diff --git a/src/components/sidebar/tabs/BaseWorkflowsSidebarTab.vue b/src/components/sidebar/tabs/BaseWorkflowsSidebarTab.vue index 4f51866d633..aaee080eae6 100644 --- a/src/components/sidebar/tabs/BaseWorkflowsSidebarTab.vue +++ b/src/components/sidebar/tabs/BaseWorkflowsSidebarTab.vue @@ -238,8 +238,9 @@ const dummyExpandedKeys = ref>({}) const handleCloseWorkflow = async (workflow?: ComfyWorkflow) => { if (workflow) { - await workflowService.closeWorkflow(workflow, { - warnIfUnsaved: !workspaceStore.shiftDown + await workflowService.closeWorkflows([workflow], { + warnIfUnsaved: !workspaceStore.shiftDown, + initiator: 'user' }) } } @@ -342,7 +343,7 @@ const renderTreeNode = ( e: MouseEvent ) { if (this.leaf && workflow) { - await workflowService.openWorkflow(workflow) + await workflowService.openWorkflow(workflow, { initiator: 'user' }) } else { toggleNodeOnEvent(e, this) } diff --git a/src/components/topbar/WorkflowOverflowMenu.test.ts b/src/components/topbar/WorkflowOverflowMenu.test.ts index 165e38787da..5e737d1d3f2 100644 --- a/src/components/topbar/WorkflowOverflowMenu.test.ts +++ b/src/components/topbar/WorkflowOverflowMenu.test.ts @@ -64,5 +64,5 @@ it('marks the agent target separately from the active overflow workflow', async ).toBeNull() await user.click(targetItem) - expect(openWorkflow).toHaveBeenCalledWith(target) + expect(openWorkflow).toHaveBeenCalledWith(target, { initiator: 'user' }) }) diff --git a/src/components/topbar/WorkflowOverflowMenu.vue b/src/components/topbar/WorkflowOverflowMenu.vue index 14f348662aa..df42a5449e0 100644 --- a/src/components/topbar/WorkflowOverflowMenu.vue +++ b/src/components/topbar/WorkflowOverflowMenu.vue @@ -46,7 +46,7 @@ const menuItems = computed(() => icon: props.activeWorkflow?.key === workflow.key ? 'pi pi-check' : undefined, command: () => { - void workflowService.openWorkflow(workflow) + void workflowService.openWorkflow(workflow, { initiator: 'user' }) } })) ) diff --git a/src/components/topbar/WorkflowTab.test.ts b/src/components/topbar/WorkflowTab.test.ts index f20ed6236b9..ab9cb11c0d3 100644 --- a/src/components/topbar/WorkflowTab.test.ts +++ b/src/components/topbar/WorkflowTab.test.ts @@ -306,15 +306,16 @@ describe('WorkflowTab - close button', () => { ) }) - it('delegates close to workflow service with the tab workflow', async () => { + it('delegates close to workflow service as a user action', async () => { renderTab() const user = userEvent.setup() await user.click(screen.getByTestId('close-workflow-button')) - expect(useWorkflowService().closeWorkflow).toHaveBeenCalledWith( - expect.objectContaining({ key: 'test-key' }), - expect.anything() + expect(useWorkflowService().closeWorkflows).toHaveBeenCalledWith( + [expect.objectContaining({ key: 'test-key' })], + expect.objectContaining({ initiator: 'user' }) ) + expect(useWorkflowService().closeWorkflow).not.toHaveBeenCalled() }) }) @@ -419,9 +420,9 @@ describe('WorkflowTab - Agent target', () => { expect(screen.getByRole('img', { name: targetLabel })).toBeVisible() expect(screen.getByTestId('workflow-dirty-indicator')).toBeVisible() await userEvent.setup().click(screen.getByTestId('close-workflow-button')) - expect(useWorkflowService().closeWorkflow).toHaveBeenCalledWith( - workflowOption.workflow, - expect.anything() + expect(useWorkflowService().closeWorkflows).toHaveBeenCalledWith( + [workflowOption.workflow], + expect.objectContaining({ initiator: 'user' }) ) }) }) diff --git a/src/components/topbar/WorkflowTab.vue b/src/components/topbar/WorkflowTab.vue index 7e15554254e..d7e2d9f3f72 100644 --- a/src/components/topbar/WorkflowTab.vue +++ b/src/components/topbar/WorkflowTab.vue @@ -299,23 +299,12 @@ const handleClick = (event: Event) => { popoverRef.value?.togglePopover(event) } -const closeWorkflows = async (options: WorkflowOption[]) => { - for (const opt of options) { - if ( - !(await useWorkflowService().closeWorkflow(opt.workflow, { - warnIfUnsaved: !workspaceStore.shiftDown, - hint: t('sideToolbar.workflowTab.dirtyCloseHint') - })) - ) { - // User cancelled, or the replacement load failed - break - } - } -} - -const onCloseWorkflow = async (option: WorkflowOption) => { - await closeWorkflows([option]) -} +const onCloseWorkflow = (option: WorkflowOption) => + useWorkflowService().closeWorkflows([option.workflow], { + warnIfUnsaved: !workspaceStore.shiftDown, + hint: t('sideToolbar.workflowTab.dirtyCloseHint'), + initiator: 'user' + }) const commandStore = useCommandStore() const workflow = computed(() => workflowOption.workflow) diff --git a/src/components/topbar/WorkflowTabs.test.ts b/src/components/topbar/WorkflowTabs.test.ts index 6b52730ab13..83e75f23b39 100644 --- a/src/components/topbar/WorkflowTabs.test.ts +++ b/src/components/topbar/WorkflowTabs.test.ts @@ -120,12 +120,20 @@ vi.mock(import('./WorkflowTab.vue'), () => ({ required: true } }, + emits: ['closeOthers'], render() { - return h( - TabsTrigger, - { value: this.workflowOption.workflow.path }, - () => this.workflowOption.workflow.filename - ) + return [ + h( + TabsTrigger, + { value: this.workflowOption.workflow.path }, + () => this.workflowOption.workflow.filename + ), + h( + 'button', + { type: 'button', onClick: () => this.$emit('closeOthers') }, + `Close tabs other than ${this.workflowOption.workflow.filename}` + ) + ] } }) })) @@ -498,7 +506,10 @@ describe('WorkflowTabs selection and overflow', () => { expect(useWorkflowService().openWorkflow).toHaveBeenCalledOnce() expect(useWorkflowService().openWorkflow).toHaveBeenCalledWith( - firstWorkflow + firstWorkflow, + { + initiator: 'user' + } ) expect(screen.getByRole('tab', { name: 'First workflow' })).toHaveAttribute( 'aria-selected', @@ -513,7 +524,10 @@ describe('WorkflowTabs selection and overflow', () => { expect(useWorkflowService().openWorkflow).toHaveBeenCalledOnce() expect(useWorkflowService().openWorkflow).toHaveBeenCalledWith( - secondWorkflow + secondWorkflow, + { + initiator: 'user' + } ) }) @@ -526,7 +540,10 @@ describe('WorkflowTabs selection and overflow', () => { expect(useWorkflowService().openWorkflow).toHaveBeenCalledOnce() expect(useWorkflowService().openWorkflow).toHaveBeenCalledWith( - secondWorkflow + secondWorkflow, + { + initiator: 'user' + } ) }) @@ -539,8 +556,31 @@ describe('WorkflowTabs selection and overflow', () => { expect(useWorkflowService().openWorkflow).toHaveBeenCalledOnce() expect(useWorkflowService().openWorkflow).toHaveBeenCalledWith( - firstWorkflow + firstWorkflow, + { + initiator: 'user' + } + ) + }) + + it('closes the other tabs as one user action', async () => { + const thirdWorkflow = await useWorkflowStore() + .createTemporary('Third workflow.json') + .load() + useWorkflowStore().attachWorkflow(thirdWorkflow, 2) + const { user } = renderComponent() + + await user.click( + screen.getByRole('button', { + name: 'Close tabs other than Second workflow' + }) + ) + + expect(useWorkflowService().closeWorkflows).toHaveBeenCalledExactlyOnceWith( + [thirdWorkflow, firstWorkflow], + { warnIfUnsaved: true, initiator: 'user' } ) + expect(useWorkflowService().closeWorkflow).not.toHaveBeenCalled() }) it('keeps the real workflow selected when another workflow fails to load', async () => { diff --git a/src/components/topbar/WorkflowTabs.vue b/src/components/topbar/WorkflowTabs.vue index 3808d4cccac..db267614b04 100644 --- a/src/components/topbar/WorkflowTabs.vue +++ b/src/components/topbar/WorkflowTabs.vue @@ -215,21 +215,14 @@ const options = computed(() => async function openWorkflowByPath(path: string | number) { const option = options.value.find(({ value }) => value === path) if (!option) return - await workflowService.openWorkflow(option.workflow) + await workflowService.openWorkflow(option.workflow, { initiator: 'user' }) } -const closeWorkflows = async (options: WorkflowOption[]) => { - for (const opt of options) { - if ( - !(await workflowService.closeWorkflow(opt.workflow, { - warnIfUnsaved: !workspaceStore.shiftDown - })) - ) { - // User cancelled, or the replacement load failed - break - } - } -} +const closeWorkflows = (options: WorkflowOption[]) => + workflowService.closeWorkflows( + options.map(({ workflow }) => workflow), + { warnIfUnsaved: !workspaceStore.shiftDown, initiator: 'user' } + ) const onCloseWorkflow = async (option: WorkflowOption) => { await closeWorkflows([option]) diff --git a/src/composables/useCoreCommands.ts b/src/composables/useCoreCommands.ts index 9b7d672061b..a3f1926b4a7 100644 --- a/src/composables/useCoreCommands.ts +++ b/src/composables/useCoreCommands.ts @@ -637,7 +637,7 @@ export function useCoreCommands(): ComfyCommand[] { label: 'Next Opened Workflow', versionAdded: '1.3.9', function: async () => { - await workflowService.loadNextOpenedWorkflow() + await workflowService.loadNextOpenedWorkflow({ initiator: 'user' }) } }, { @@ -646,7 +646,7 @@ export function useCoreCommands(): ComfyCommand[] { label: 'Previous Opened Workflow', versionAdded: '1.3.9', function: async () => { - await workflowService.loadPreviousOpenedWorkflow() + await workflowService.loadPreviousOpenedWorkflow({ initiator: 'user' }) } }, { @@ -874,7 +874,10 @@ export function useCoreCommands(): ComfyCommand[] { versionAdded: '1.7.3', function: async () => { if (workflowStore.activeWorkflow) - await workflowService.closeWorkflow(workflowStore.activeWorkflow) + await workflowService.closeWorkflows([workflowStore.activeWorkflow], { + warnIfUnsaved: true, + initiator: 'user' + }) } }, { diff --git a/src/composables/useWorkflowActionsMenu.test.ts b/src/composables/useWorkflowActionsMenu.test.ts index ca469aef2c7..f7947b79993 100644 --- a/src/composables/useWorkflowActionsMenu.test.ts +++ b/src/composables/useWorkflowActionsMenu.test.ts @@ -423,7 +423,8 @@ describe('useWorkflowActionsMenu', () => { await findItem(menuItems.value, 'g.rename').command?.() expect(useWorkflowService().openWorkflow).toHaveBeenCalledWith( - customWorkflow.value + customWorkflow.value, + { initiator: 'user' } ) expect(startRename).toHaveBeenCalled() }) @@ -450,7 +451,8 @@ describe('useWorkflowActionsMenu', () => { ).command?.() expect(useWorkflowService().openWorkflow).toHaveBeenCalledWith( - customWorkflow.value + customWorkflow.value, + { initiator: 'user' } ) expect( lazyDeployToComfyApiDialog.openDeployToComfyApiDialog diff --git a/src/composables/useWorkflowActionsMenu.ts b/src/composables/useWorkflowActionsMenu.ts index d6aa6f7ebe8..0e492a4bba7 100644 --- a/src/composables/useWorkflowActionsMenu.ts +++ b/src/composables/useWorkflowActionsMenu.ts @@ -69,7 +69,7 @@ export function useWorkflowActionsMenu( /** Switch to the target workflow tab if it's not already active */ const ensureWorkflowActive = async (wf: ComfyWorkflow | null) => { if (!wf || wf === workflowStore.activeWorkflow) return true - return await workflowService.openWorkflow(wf) + return await workflowService.openWorkflow(wf, { initiator: 'user' }) } const menuItems = computed(() => { diff --git a/src/platform/workflow/core/services/__mocks__/workflowService.ts b/src/platform/workflow/core/services/__mocks__/workflowService.ts index f514e35acb9..18fe4e650f5 100644 --- a/src/platform/workflow/core/services/__mocks__/workflowService.ts +++ b/src/platform/workflow/core/services/__mocks__/workflowService.ts @@ -11,6 +11,7 @@ const workflowService: ReturnType = { reloadCurrentWorkflow: vi.fn(async () => {}), openWorkflow: vi.fn(async () => true), closeWorkflow: vi.fn(async () => true), + closeWorkflows: vi.fn(async () => {}), renameWorkflow: vi.fn(async () => {}), deleteWorkflow: vi.fn(async () => true), insertWorkflow: vi.fn(async () => {}), diff --git a/src/platform/workflow/core/services/workflowService.test.ts b/src/platform/workflow/core/services/workflowService.test.ts index 637e2d3655c..53ead71e5a1 100644 --- a/src/platform/workflow/core/services/workflowService.test.ts +++ b/src/platform/workflow/core/services/workflowService.test.ts @@ -99,7 +99,9 @@ vi.mock( () => ({ useWorkflowThumbnail: () => ({ storeThumbnail: storeThumbnailMock, - getThumbnail: vi.fn() + getThumbnail: vi.fn(), + clearThumbnail: vi.fn(), + moveWorkflowThumbnail: vi.fn() }) }) ) @@ -1813,6 +1815,271 @@ describe('useWorkflowService', () => { }) }) + describe('user activations', () => { + function activateOnLoad(): void { + vi.mocked(app.loadGraphData).mockImplementation( + async (_data, _clean, _restore, workflow) => { + useWorkflowStore().activeWorkflow = workflow as LoadedComfyWorkflow + return true + } + ) + } + + it('reports a tab only when a user action activates it', async () => { + const workflowStore = useWorkflowStore() + const restored = createWorkflow(null, { + loadable: true, + path: 'workflows/restored.json' + }) + const clicked = createWorkflow(null, { + loadable: true, + path: 'workflows/clicked.json' + }) + activateOnLoad() + const activated = vi.fn() + workflowStore.onUserActivation(activated) + const service = useWorkflowService() + + await service.openWorkflow(restored) + await service.openWorkflow(clicked, { initiator: 'user' }) + + expect(workflowStore.activeWorkflow?.path).toBe(clicked.path) + expect(activated.mock.calls).toEqual([[clicked]]) + }) + + it('does not report a user activation whose load fails', async () => { + const workflowStore = useWorkflowStore() + const clicked = createWorkflow(null, { + loadable: true, + path: 'workflows/clicked.json' + }) + vi.mocked(app.loadGraphData).mockResolvedValueOnce(false) + const activated = vi.fn() + workflowStore.onUserActivation(activated) + + await expect( + useWorkflowService().openWorkflow(clicked, { initiator: 'user' }) + ).resolves.toBe(false) + + expect(activated).not.toHaveBeenCalled() + }) + + function openThreeTabs(): { + byName: (name: string) => ComfyWorkflow + activated: ReturnType + } { + const workflowStore = useWorkflowStore() + const names = ['first', 'second', 'third'] + const tabs = names.map((name, index) => { + const tab = createWorkflow(null, { + loadable: true, + path: `workflows/${name}.json` + }) + Object.defineProperty(tab, 'unload', { value: vi.fn() }) + workflowStore.attachWorkflow(tab, index) + return tab + }) + workflowStore.activeWorkflow = tabs[0] as LoadedComfyWorkflow + vi.spyOn(workflowStore, 'getMostRecentWorkflow').mockImplementation( + () => + workflowStore.openWorkflows.find( + (tab) => !workflowStore.isActive(tab) + ) ?? null + ) + activateOnLoad() + const activated = vi.fn() + workflowStore.onUserActivation(activated) + return { byName: (name) => tabs[names.indexOf(name)], activated } + } + + it.for([ + { closed: 'the active tab', closing: ['first'], left: 'second' }, + { + closed: 'several tabs', + closing: ['first', 'second'], + left: 'third' + } + ])( + 'reports once, for the tab left active, when a user closes $closed', + async ({ closing, left }) => { + const { byName, activated } = openThreeTabs() + + await useWorkflowService().closeWorkflows(closing.map(byName), { + warnIfUnsaved: false, + initiator: 'user' + }) + + expect(useWorkflowStore().activeWorkflow?.path).toBe(byName(left).path) + expect(activated.mock.calls).toEqual([[byName(left)]]) + } + ) + + it('does not report a tab something else activated while a close waited', async () => { + const { byName, activated } = openThreeTabs() + const dirty = byName('second') + Object.assign(dirty, { isModified: true }) + let answer!: (choice: boolean | null) => void + vi.mocked(useDialogService().confirm).mockReturnValueOnce( + new Promise((resolve) => (answer = resolve)) + ) + const closing = useWorkflowService().closeWorkflows([dirty], { + warnIfUnsaved: true, + initiator: 'user' + }) + await vi.waitFor(() => + expect(useDialogService().confirm).toHaveBeenCalled() + ) + + await useWorkflowService().openWorkflow(byName('third')) + answer(false) + await closing + + expect(useWorkflowStore().activeWorkflow?.path).toBe(byName('third').path) + expect(activated).not.toHaveBeenCalled() + }) + + it('does not report a replacement superseded while a later close waits', async () => { + const { byName, activated } = openThreeTabs() + const workflowStore = useWorkflowStore() + const third = byName('third') + Object.assign(third, { isModified: true }) + let answer!: (choice: boolean | null) => void + vi.mocked(useDialogService().confirm).mockReturnValueOnce( + new Promise((resolve) => (answer = resolve)) + ) + const service = useWorkflowService() + const closing = service.closeWorkflows([byName('first'), third], { + warnIfUnsaved: true, + initiator: 'user' + }) + await vi.waitFor(() => + expect(useDialogService().confirm).toHaveBeenCalled() + ) + expect(workflowStore.activeWorkflow?.path).toBe(byName('second').path) + expect(workflowStore.openWorkflows.map((tab) => tab.path)).toEqual([ + byName('second').path, + third.path + ]) + + await service.openWorkflow(third) + answer(null) + await closing + + expect(workflowStore.activeWorkflow?.path).toBe(third.path) + expect(activated).not.toHaveBeenCalled() + }) + + it('reports the tab an earlier close activated when a later close throws', async () => { + const { byName, activated } = openThreeTabs() + const failure = new Error('load failed') + vi.mocked(app.loadGraphData).mockImplementation( + async (_data, _clean, _restore, workflow) => { + const loading = workflow as ComfyWorkflow + if (loading.path === byName('third').path) throw failure + useWorkflowStore().activeWorkflow = loading as LoadedComfyWorkflow + return true + } + ) + + await expect( + useWorkflowService().closeWorkflows( + [byName('first'), byName('second')], + { warnIfUnsaved: false, initiator: 'user' } + ) + ).rejects.toBe(failure) + + expect(activated.mock.calls).toEqual([[byName('second')]]) + }) + + it.for([ + { + name: 'reports the default workflow left active after a user close', + options: { warnIfUnsaved: false, initiator: 'user' as const }, + expectedPaths: ['Unsaved Workflow.json'] + }, + { + name: 'does not report the default workflow for a non-user close', + options: { warnIfUnsaved: false }, + expectedPaths: [] + } + ])('$name', async ({ options, expectedPaths }) => { + const workflowStore = useWorkflowStore() + const only = createWorkflow(null, { + loadable: true, + path: 'workflows/only.json' + }) + Object.defineProperty(only, 'unload', { value: vi.fn() }) + workflowStore.attachWorkflow(only, 0) + workflowStore.activeWorkflow = only as LoadedComfyWorkflow + vi.spyOn(workflowStore, 'getMostRecentWorkflow').mockReturnValue(null) + const fallback = createWorkflow(null, { + loadable: true, + path: 'Unsaved Workflow.json' + }) + vi.mocked(app.loadGraphData).mockImplementation(async (data) => { + if (data === defaultGraph) + useWorkflowStore().activeWorkflow = fallback as LoadedComfyWorkflow + return true + }) + const activated = vi.fn() + workflowStore.onUserActivation(activated) + + await useWorkflowService().closeWorkflows([only], options) + + expect(app.loadGraphData).toHaveBeenCalledWith(defaultGraph) + expect(activated.mock.calls.map(([workflow]) => workflow.path)).toEqual( + expectedPaths + ) + }) + + it.for([ + { + name: 'reports the tab a user lands on after a direct deletion', + silent: false, + expectedPaths: ['workflows/second.json'] + }, + { + name: 'does not report a tab activation for an internal deletion', + silent: true, + expectedPaths: [] + } + ])('$name', async ({ silent, expectedPaths }) => { + const { byName, activated } = openThreeTabs() + Object.defineProperty(byName('first'), 'delete', { + value: vi.fn(async () => {}) + }) + + await expect( + useWorkflowService().deleteWorkflow(byName('first'), silent) + ).resolves.toBe(true) + + expect(activated.mock.calls.map(([workflow]) => workflow.path)).toEqual( + expectedPaths + ) + }) + + it('keeps a throwing listener from failing the tab switch', async () => { + const workflowStore = useWorkflowStore() + const clicked = createWorkflow(null, { + loadable: true, + path: 'workflows/clicked.json' + }) + activateOnLoad() + workflowStore.onUserActivation(() => { + throw new Error('subscriber blew up') + }) + const settled = vi.fn() + workflowStore.onUserActivation(settled) + + await expect( + useWorkflowService().openWorkflow(clicked, { initiator: 'user' }) + ).resolves.toBe(true) + + expect(workflowStore.activeWorkflow?.path).toBe(clicked.path) + expect(settled).toHaveBeenCalledWith(clicked) + }) + }) + describe('openWorkflow deferred warnings', () => { let workflowStore: ReturnType diff --git a/src/platform/workflow/core/services/workflowService.ts b/src/platform/workflow/core/services/workflowService.ts index f3b03d27fb6..621c46eb3a3 100644 --- a/src/platform/workflow/core/services/workflowService.ts +++ b/src/platform/workflow/core/services/workflowService.ts @@ -430,6 +430,7 @@ export const useWorkflowService = () => { force?: boolean navigationIntentId?: number isCurrent?: () => boolean + initiator?: 'user' } = {} ): Promise => { if (options.isCurrent?.() === false) return Promise.resolve(false) @@ -485,6 +486,8 @@ export const useWorkflowService = () => { showPendingWarnings(undefined, { silent: !loadFromRemote && !options.force }) + if (options.initiator === 'user') + workflowStore.reportUserActivation(workflow) return true } catch (error) { // A failed load's intent must not stay newest (suppresses the survivor's hash). @@ -503,7 +506,11 @@ export const useWorkflowService = () => { */ const closeWorkflow = async ( workflow: ComfyWorkflow, - options: { warnIfUnsaved: boolean; hint?: string } = { + options: { + warnIfUnsaved: boolean + hint?: string + onReplacementOpened?: (workflow: ComfyWorkflow) => void + } = { warnIfUnsaved: true } ): Promise => { @@ -525,6 +532,13 @@ export const useWorkflowService = () => { } } + const loadDefaultAsReplacement = async (): Promise => { + if ((await loadDefaultWorkflow()) === false) return false + const opened = workflowStore.activeWorkflow + if (opened) options.onReplacementOpened?.(opened) + return true + } + // Captured once: a mid-close rename mutates workflow.path in place. const closingPath = workflow.path const closing = closingKey(workflow) @@ -572,8 +586,9 @@ export const useWorkflowService = () => { // path); a rejection still propagates as before. if (replacementWorkflow) { if (!(await openWorkflow(replacementWorkflow))) return false + options.onReplacementOpened?.(replacementWorkflow) } else { - if ((await loadDefaultWorkflow()) === false) return false + if (!(await loadDefaultAsReplacement())) return false } } else if ( // Read live, post-drain: the awaits above can change the answer. @@ -582,7 +597,7 @@ export const useWorkflowService = () => { closingWorkflowCounts.has(closingKey(open)) ) ) { - if ((await loadDefaultWorkflow()) === false) return false + if (!(await loadDefaultAsReplacement())) return false } await workflowStore.closeWorkflow(workflow) @@ -633,10 +648,11 @@ export const useWorkflowService = () => { } if (workflowStore.isOpen(workflow)) { - const closed = await closeWorkflow(workflow, { - warnIfUnsaved: !confirmed + await closeWorkflows([workflow], { + warnIfUnsaved: !confirmed, + initiator: silent ? undefined : 'user' }) - if (!closed) return false + if (workflowStore.isOpen(workflow)) return false } await workflowStore.deleteWorkflow(workflow) if (!silent) { @@ -868,17 +884,49 @@ export const useWorkflowService = () => { canvas._deserializeItems(items, options) } - const loadNextOpenedWorkflow = async () => { + const closeWorkflows = async ( + workflows: ComfyWorkflow[], + { + initiator, + ...options + }: { warnIfUnsaved: boolean; hint?: string; initiator?: 'user' } + ): Promise => { + const opened: { replacement?: ComfyWorkflow } = {} + const onReplacementOpened = (replacement: ComfyWorkflow) => { + opened.replacement = replacement + } + try { + for (const workflow of workflows) + if ( + !(await closeWorkflow(workflow, { ...options, onReplacementOpened })) + ) + break + } finally { + const { replacement } = opened + if ( + initiator === 'user' && + replacement !== undefined && + workflowStore.isActive(replacement) + ) + workflowStore.reportUserActivation(replacement) + } + } + + const loadNextOpenedWorkflow = async ( + options: { initiator?: 'user' } = {} + ) => { const nextWorkflow = workflowStore.openedWorkflowIndexShift(1) if (nextWorkflow) { - await openWorkflow(nextWorkflow) + await openWorkflow(nextWorkflow, options) } } - const loadPreviousOpenedWorkflow = async () => { + const loadPreviousOpenedWorkflow = async ( + options: { initiator?: 'user' } = {} + ) => { const previousWorkflow = workflowStore.openedWorkflowIndexShift(-1) if (previousWorkflow) { - await openWorkflow(previousWorkflow) + await openWorkflow(previousWorkflow, options) } } @@ -957,6 +1005,7 @@ export const useWorkflowService = () => { reloadCurrentWorkflow, openWorkflow, closeWorkflow, + closeWorkflows, renameWorkflow, deleteWorkflow, insertWorkflow, diff --git a/src/platform/workflow/management/stores/workflowStore.ts b/src/platform/workflow/management/stores/workflowStore.ts index 90766a12eba..18cf472c794 100644 --- a/src/platform/workflow/management/stores/workflowStore.ts +++ b/src/platform/workflow/management/stores/workflowStore.ts @@ -472,6 +472,14 @@ export const useWorkflowStore = defineStore('workflow', () => { /** A filesystem operation is currently in progress (e.g. save, rename, delete) */ const isBusy = ref(false) const workflowRenamed = createEventHook() + const userActivation = createEventHook() + function reportActivationError(error: unknown) { + return reportError(error, { + surface: 'graph', + errorType: 'user_activation_listener_failure', + level: 'warning' + }) + } const { moveWorkflowThumbnail, clearThumbnail } = useWorkflowThumbnail() const renameWorkflow = async (workflow: ComfyWorkflow, newPath: string) => { @@ -723,6 +731,16 @@ export const useWorkflowStore = defineStore('workflow', () => { createNewTemporary, renameWorkflow, onWorkflowRenamed: workflowRenamed.on, + onUserActivation: (listener: (workflow: ComfyWorkflow) => unknown) => + userActivation.on(async (workflow) => { + try { + await listener(workflow) + } catch (error) { + reportActivationError(error) + } + }), + reportUserActivation: (workflow: ComfyWorkflow) => + void userActivation.trigger(workflow), deleteWorkflow, saveAs, saveWorkflow, diff --git a/src/renderer/extensions/linearMode/MobileDisplay.vue b/src/renderer/extensions/linearMode/MobileDisplay.vue index 3f4d0b875e4..51f6c91ccf0 100644 --- a/src/renderer/extensions/linearMode/MobileDisplay.vue +++ b/src/renderer/extensions/linearMode/MobileDisplay.vue @@ -89,7 +89,8 @@ const activeWorkflowPath = computed({ get: () => workflowStore.activeWorkflow?.path ?? '', set: (path: string) => { const workflow = workflowStore.getWorkflowByPath(path) - if (workflow) void workflowService.openWorkflow(workflow) + if (workflow) + void workflowService.openWorkflow(workflow, { initiator: 'user' }) } }) diff --git a/src/stores/subgraphNavigationStore.navigateToHash.test.ts b/src/stores/subgraphNavigationStore.navigateToHash.test.ts index 02ca1d0f827..0da2a451529 100644 --- a/src/stores/subgraphNavigationStore.navigateToHash.test.ts +++ b/src/stores/subgraphNavigationStore.navigateToHash.test.ts @@ -124,7 +124,6 @@ describe('useSubgraphNavigationStore - navigateToHash validation', () => { app.canvas.subgraph = undefined app.canvas.graph = app.rootGraph useCanvasStore().currentGraph = app.rootGraph - Object.assign(useWorkflowStore(), { openWorkflows: [] }) useWorkflowStore().activeSubgraph = undefined routeHashRef.value = '' routerMocks.history.state = {} @@ -484,6 +483,22 @@ describe('useSubgraphNavigationStore - navigateToHash validation', () => { expect(useWorkflowStore().activeSubgraph).toBe(subgraph) }) + it('opens the workflow of a restored page hash without calling it a user change', async () => { + const workflow = fromPartial({ + path: 'restored-workflow.json', + activeState: { id: ids.deletedSubgraph, definitions: { subgraphs: [] } } + }) + useWorkflowStore().attachWorkflow(workflow, 0) + routeHashRef.value = `#${ids.deletedSubgraph}` + + await useSubgraphNavigationStore().updateHash() + + expect(workflowServiceMocks.openWorkflow).toHaveBeenCalledExactlyOnceWith( + workflow, + { navigationIntentId: expect.any(Number) } + ) + }) + it('uses the emitted graph during a synchronous graph-change event', async () => { const subgraph = makeSubgraph(ids.validSubgraph) const navigationStore = useSubgraphNavigationStore() @@ -538,7 +553,7 @@ describe('useSubgraphNavigationStore - navigateToHash validation', () => { }) expect(workflowServiceMocks.openWorkflow).toHaveBeenCalledWith( targetWorkflow, - { navigationIntentId: expect.any(Number) } + { navigationIntentId: expect.any(Number), initiator: 'user' } ) }) @@ -593,7 +608,7 @@ describe('useSubgraphNavigationStore - navigateToHash validation', () => { expect(routeHashRef.value).toBe(`#${targetSubgraph.id}`) expect(workflowServiceMocks.openWorkflow).toHaveBeenCalledWith( originalWorkflow, - { navigationIntentId: expect.any(Number) } + { navigationIntentId: expect.any(Number), initiator: 'user' } ) }) @@ -691,7 +706,7 @@ describe('useSubgraphNavigationStore - navigateToHash validation', () => { await vi.waitFor(() => expect(workflowServiceMocks.openWorkflow).toHaveBeenCalledWith( routeWorkflow, - { navigationIntentId: expect.any(Number) } + { navigationIntentId: expect.any(Number), initiator: 'user' } ) ) resolveFirstPush?.() @@ -743,7 +758,7 @@ describe('useSubgraphNavigationStore - navigateToHash validation', () => { await vi.waitFor(() => expect(workflowServiceMocks.openWorkflow).toHaveBeenCalledWith( firstWorkflow, - { navigationIntentId: expect.any(Number) } + { navigationIntentId: expect.any(Number), initiator: 'user' } ) ) app.canvas.graph = secondRoot @@ -793,7 +808,7 @@ describe('useSubgraphNavigationStore - navigateToHash validation', () => { await vi.waitFor(() => expect(workflowServiceMocks.openWorkflow).toHaveBeenCalledWith( firstWorkflow, - { navigationIntentId: expect.any(Number) } + { navigationIntentId: expect.any(Number), initiator: 'user' } ) ) routeHashRef.value = `#${secondId}` @@ -802,7 +817,7 @@ describe('useSubgraphNavigationStore - navigateToHash validation', () => { await vi.waitFor(() => { expect(workflowServiceMocks.openWorkflow).toHaveBeenLastCalledWith( secondWorkflow, - { navigationIntentId: expect.any(Number) } + { navigationIntentId: expect.any(Number), initiator: 'user' } ) expect(app.canvas.graph?.id).toBe(secondId) }) @@ -843,7 +858,7 @@ describe('useSubgraphNavigationStore - navigateToHash validation', () => { await vi.waitFor(() => expect(workflowServiceMocks.openWorkflow).toHaveBeenCalledWith( firstWorkflow, - { navigationIntentId: expect.any(Number) } + { navigationIntentId: expect.any(Number), initiator: 'user' } ) ) routeHashRef.value = `#${secondId}` @@ -855,7 +870,7 @@ describe('useSubgraphNavigationStore - navigateToHash validation', () => { await vi.waitFor(() => { expect(workflowServiceMocks.openWorkflow).toHaveBeenLastCalledWith( secondWorkflow, - { navigationIntentId: expect.any(Number) } + { navigationIntentId: expect.any(Number), initiator: 'user' } ) expect(app.canvas.graph?.id).toBe(secondId) }) diff --git a/src/stores/subgraphNavigationStore.ts b/src/stores/subgraphNavigationStore.ts index dbb5f8ad249..26abb9887f8 100644 --- a/src/stores/subgraphNavigationStore.ts +++ b/src/stores/subgraphNavigationStore.ts @@ -216,7 +216,7 @@ export const useSubgraphNavigationStore = defineStore( type GraphNavigationIntent = { id: number hash: string - source: 'graph' | 'route' + source: 'graph' | 'route' | 'restore' } type NavigationIntent = | GraphNavigationIntent @@ -297,7 +297,11 @@ export const useSubgraphNavigationStore = defineStore( } } - async function navigateToHash(newHash: string, navigationId: number) { + async function navigateToHash( + newHash: string, + navigationId: number, + initiator?: 'user' + ) { const root = useApp().rootGraph const locatorId = newHash.slice(1) || root.id const canvas = canvasStore.getCanvas() @@ -330,7 +334,8 @@ export const useSubgraphNavigationStore = defineStore( await withNavBlocked( () => useWorkflowService().openWorkflow(workflow, { - navigationIntentId: navigationId + navigationIntentId: navigationId, + initiator }), newHash ) @@ -419,7 +424,11 @@ export const useSubgraphNavigationStore = defineStore( } async function applyNavigationIntent(intent: GraphNavigationIntent) { - await navigateToHash(intent.hash, intent.id) + await navigateToHash( + intent.hash, + intent.id, + intent.source === 'route' ? 'user' : undefined + ) if (blockNavDepth > 0) return const deferredIntent = deferredNavigationIntent @@ -511,7 +520,7 @@ export const useSubgraphNavigationStore = defineStore( initialLoad = false if (!routeHash.value) return Promise.resolve() return applyNavigationIntent( - createNavigationIntent(routeHash.value, 'route') + createNavigationIntent(routeHash.value, 'restore') ).then(() => { const activeGraph = canvasStore.getCanvas().graph if (isSubgraph(activeGraph)) {