diff --git a/src/components/graph/GraphCanvas.test.ts b/src/components/graph/GraphCanvas.test.ts index acf0397487e..e563692ac12 100644 --- a/src/components/graph/GraphCanvas.test.ts +++ b/src/components/graph/GraphCanvas.test.ts @@ -192,7 +192,10 @@ function setRootGraph(graph: LGraph | undefined) { ;(app as unknown as { rootGraph: LGraph | undefined }).rootGraph = graph } -async function mountGraphCanvas(stubs: Record = {}) { +async function mountGraphCanvas( + stubs: Record = {}, + errorHandler?: (error: unknown) => void +) { // Handed to the component rather than left to the active-Pinia fallback, so // the readiness gates below are set on the instance startup actually reads. const pinia = getActivePinia()! @@ -214,7 +217,8 @@ async function mountGraphCanvas(stubs: Record = {}) { pinia, createI18n({ legacy: false, locale: 'en', missingWarn: false }) ], - stubs + stubs, + config: errorHandler ? { errorHandler } : {} } } as RenderOptions) @@ -246,6 +250,17 @@ describe('GraphCanvas first-run tour wiring', () => { ).toBeGreaterThan(mocks.handleStartupOutcome.mock.invocationCallOrder[0]) }) + it('settles tab restoration when startup fails before restoring tabs', async () => { + const failure = new Error('init failed') + mocks.initializeWorkflow.mockRejectedValue(failure) + const errors: unknown[] = [] + + await mountGraphCanvas({}, (error) => errors.push(error)) + + expect(errors).toEqual([failure]) + expect(useWorkflowStore().tabsRestored).toBe(true) + }) + it('offers the tour over a workflow that arrived from the URL', async () => { await mountGraphCanvas() diff --git a/src/components/graph/GraphCanvas.vue b/src/components/graph/GraphCanvas.vue index 406730364ac..1dda4995b59 100644 --- a/src/components/graph/GraphCanvas.vue +++ b/src/components/graph/GraphCanvas.vue @@ -603,6 +603,7 @@ onMounted(async () => { await useFirstRunEntry().handleStartupOutcome(startupOutcome) bootstrapOutcome = 'completed' } finally { + workflowStore.markTabsRestored() workspaceStore.spinner = false bootstrapTracer.complete(bootstrapOutcome) } diff --git a/src/platform/workflow/management/stores/workflowStore.ts b/src/platform/workflow/management/stores/workflowStore.ts index aa4bd9a621f..0e3afe4ab5e 100644 --- a/src/platform/workflow/management/stores/workflowStore.ts +++ b/src/platform/workflow/management/stores/workflowStore.ts @@ -563,6 +563,11 @@ export const useWorkflowStore = defineStore('workflow', () => { } } + const tabsRestored = ref(false) + const markTabsRestored = () => { + tabsRestored.value = true + } + /** @see WorkflowStore.isSubgraphActive */ const isSubgraphActive = ref(false) @@ -757,6 +762,8 @@ export const useWorkflowStore = defineStore('workflow', () => { isSyncLoading, loadWorkflows, + tabsRestored: computed(() => tabsRestored.value), + markTabsRestored, isSubgraphActive, activeSubgraph, updateActiveGraph, diff --git a/src/platform/workflow/management/stores/workflowStoreTypes.ts b/src/platform/workflow/management/stores/workflowStoreTypes.ts index 6f3ba0b40de..639afa33093 100644 --- a/src/platform/workflow/management/stores/workflowStoreTypes.ts +++ b/src/platform/workflow/management/stores/workflowStoreTypes.ts @@ -43,6 +43,15 @@ export interface WorkflowStore { loadWorkflows: () => Promise reorderWorkflows: (from: number, to: number) => void + /** + * `true` once startup has finished restoring the previous session's open + * tabs, including unsaved drafts recreated from local storage. Until then, + * a workflow with no open tab may simply not have been restored yet. + */ + tabsRestored: boolean + /** Called once startup tab restoration settles, including when startup fails first. */ + markTabsRestored: () => void + /** `true` if any subgraph is currently being viewed. */ isSubgraphActive: boolean activeSubgraph: Subgraph | undefined diff --git a/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.test.ts b/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.test.ts index 9f30a260c2c..f1c0b60bb29 100644 --- a/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.test.ts +++ b/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.test.ts @@ -387,10 +387,13 @@ describe('useWorkflowPersistenceV2', () => { expect(loadWorkflowsSpy).toHaveBeenCalledOnce() expect(openWorkflowMock).not.toHaveBeenCalled() + expect(workflowStore.tabsRestored).toBe(false) + gate.resolve() await pending expect(openWorkflowMock).toHaveBeenCalledWith(workflowB) + expect(workflowStore.tabsRestored).toBe(true) }) it('falls back to the default workflow when metadata loading fails', async () => { @@ -405,6 +408,7 @@ describe('useWorkflowPersistenceV2', () => { expect(loadBlankWorkflowMock).toHaveBeenCalled() expect(openWorkflowMock).not.toHaveBeenCalled() + expect(workflowStore.tabsRestored).toBe(true) }) it('activates the correct workflow at storedActiveIndex', async () => { diff --git a/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.ts b/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.ts index 22579fa0fff..d79ae23458d 100644 --- a/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.ts +++ b/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.ts @@ -353,6 +353,14 @@ export function useWorkflowPersistenceV2() { * GraphCanvas must call this during startup when workflow persistence is enabled. */ const restoreWorkflowTabsState = async () => { + try { + await restoreSavedTabs() + } finally { + workflowStore.markTabsRestored() + } + } + + const restoreSavedTabs = async () => { if (!workflowPersistenceEnabled.value) { tabStateRestored = true return diff --git a/src/workbench/extensions/agent/AgentPanelRoot.test.ts b/src/workbench/extensions/agent/AgentPanelRoot.test.ts index 20bc3ee30e6..01d43b65a85 100644 --- a/src/workbench/extensions/agent/AgentPanelRoot.test.ts +++ b/src/workbench/extensions/agent/AgentPanelRoot.test.ts @@ -306,6 +306,7 @@ function syncFakeSelection() { } beforeEach(() => { + useWorkflowStore().markTabsRestored() let clientMessageIds = 0 nextClientMessageId.mockImplementation( () => `client-message-${++clientMessageIds}` diff --git a/src/workbench/extensions/agent/composables/agent/useAgentWorkflowSelection.test.ts b/src/workbench/extensions/agent/composables/agent/useAgentWorkflowSelection.test.ts index 9b7c7b5d0dc..959f152301e 100644 --- a/src/workbench/extensions/agent/composables/agent/useAgentWorkflowSelection.test.ts +++ b/src/workbench/extensions/agent/composables/agent/useAgentWorkflowSelection.test.ts @@ -1,11 +1,13 @@ import { render, waitFor } from '@testing-library/vue' import type { WorkflowResponse } from '@comfyorg/ingest-types' +import { getActivePinia } from 'pinia' import { assert, beforeEach, describe, expect, it, vi } from 'vitest' -import { defineComponent } from 'vue' +import { defineComponent, nextTick } from 'vue' import { i18n } from '@/i18n' import { useWorkflowService } from '@/platform/workflow/core/services/workflowService' import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore' +import { blankGraph } from '@/scripts/defaultGraph' import { createMockLoadedWorkflow } from '@/utils/__tests__/litegraphTestUtils' import type { CloudWorkflowEntry } from '../../schemas/agentApiSchema' @@ -18,8 +20,9 @@ import { useAgentWorkflowSelection } from './useAgentWorkflowSelection' vi.mock(import('@/platform/workflow/core/services/workflowService')) -function setup() { +function setup({ tabsRestored = true }: { tabsRestored?: boolean } = {}) { const workflows = useWorkflowStore() + if (tabsRestored) workflows.markTabsRestored() const bindings = useAgentWorkflowTabBindingStore() const panel = useAgentPanelStore() panel.beginWorkflowRestoration() @@ -654,6 +657,138 @@ describe('historical workflow restoration', () => { expect(warnRestoreFailed).not.toHaveBeenCalled() }) + const draftPath = 'workflows/Agent draft.json' + const draftGraphId = '3d4d7f1e-3c8b-4a0a-9a3c-1d2e3f4a5b6c' + + async function bindDraftThenReload(): Promise { + const beforeReload = useWorkflowStore() + const draft = beforeReload.createTemporary('Agent draft.json', { + ...blankGraph, + id: draftGraphId + }) + beforeReload.openWorkflowsInBackground({ right: [draft.path] }) + const bindingsBeforeReload = useAgentWorkflowTabBindingStore() + bindingsBeforeReload.bind('wf-draft', draft.path) + await nextTick() + bindingsBeforeReload.$dispose() + delete getActivePinia()?.state.value[bindingsBeforeReload.$id] + await beforeReload.closeWorkflow(draft) + } + + function restoreDraftTab(workflows: ReturnType) { + const restored = workflows.createTemporary('Agent draft.json', { + ...blankGraph, + id: draftGraphId + }) + workflows.openWorkflowsInBackground({ right: [restored.path] }) + workflows.markTabsRestored() + return restored + } + + it('PM-2332 waits for a page reload to restore the unsaved draft tab before calling the chat target unavailable', async () => { + await bindDraftThenReload() + const { + selection, + workflows, + panel, + listCloudWorkflows, + getCloudWorkflow, + warnRestoreFailed + } = setup({ tabsRestored: false }) + + const restoration = selection.restoreTarget('wf-draft', () => true) + await vi.waitFor(() => expect(listCloudWorkflows).toHaveBeenCalled()) + await new Promise((resolve) => setTimeout(resolve, 0)) + + expect(panel.targetUnavailable).toBe(false) + + const restored = restoreDraftTab(workflows) + + expect(await restoration).toBe(true) + expect(restored.path).toBe(draftPath) + expect(getCloudWorkflow).toHaveBeenCalledWith('wf-draft') + expect(panel.targetUnavailable).toBe(false) + expect(panel.selectedWorkflow?.path).toBe(draftPath) + expect(workflows.activeWorkflow?.path).toBe(draftPath) + expect(warnRestoreFailed).not.toHaveBeenCalled() + }) + + it('waits for the reloaded draft tab even when the listing is incomplete', async () => { + await bindDraftThenReload() + const { + selection, + workflows, + panel, + listCloudWorkflows, + warnRestoreFailed + } = setup({ tabsRestored: false }) + listCloudWorkflows.mockImplementationOnce(async () => + listing([{ id: 'wf-saved', name: 'saved' }], false) + ) + + const restoration = selection.restoreTarget('wf-draft', () => true) + await vi.waitFor(() => expect(listCloudWorkflows).toHaveBeenCalled()) + await new Promise((resolve) => setTimeout(resolve, 0)) + expect(workflows.syncWorkflows).not.toHaveBeenCalled() + expect(warnRestoreFailed).not.toHaveBeenCalled() + + restoreDraftTab(workflows) + + expect(await restoration).toBe(true) + expect(panel.selectedWorkflow?.path).toBe(draftPath) + expect(panel.targetUnavailable).toBe(false) + expect(warnRestoreFailed).not.toHaveBeenCalled() + }) + + it('calls the target unavailable when startup never finishes restoring tabs', async () => { + vi.useFakeTimers() + try { + const { selection, panel, listCloudWorkflows, getCloudWorkflow } = setup({ + tabsRestored: false + }) + let settled = false + const restoration = selection + .restoreTarget('wf-deleted', () => true) + .finally(() => { + settled = true + }) + await vi.waitFor(() => expect(listCloudWorkflows).toHaveBeenCalled()) + + await vi.advanceTimersByTimeAsync(14_000) + expect(settled).toBe(false) + expect(panel.targetUnavailable).toBe(false) + + await vi.advanceTimersByTimeAsync(1_000) + expect(settled).toBe(true) + expect(await restoration).toBe(true) + expect(panel.targetUnavailable).toBe(true) + expect(getCloudWorkflow).not.toHaveBeenCalled() + } finally { + vi.useRealTimers() + } + }) + + it('still calls the target unavailable once a reload restores no tab for it', async () => { + const { + selection, + panel, + getCloudWorkflow, + listCloudWorkflows, + workflows + } = setup({ tabsRestored: false }) + + const restoration = selection.restoreTarget('wf-deleted', () => true) + await vi.waitFor(() => expect(listCloudWorkflows).toHaveBeenCalled()) + await new Promise((resolve) => setTimeout(resolve, 0)) + expect(panel.targetUnavailable).toBe(false) + + workflows.markTabsRestored() + + expect(await restoration).toBe(true) + expect(panel.targetUnavailable).toBe(true) + expect(getCloudWorkflow).not.toHaveBeenCalled() + }) + it('does not mark a superseded restoration unavailable when its listing omits the workflow', async () => { const { selection, panel, current, listCloudWorkflows, warnRestoreFailed } = setup() diff --git a/src/workbench/extensions/agent/composables/agent/useAgentWorkflowSelection.ts b/src/workbench/extensions/agent/composables/agent/useAgentWorkflowSelection.ts index ea356acb7b6..86cd6be500a 100644 --- a/src/workbench/extensions/agent/composables/agent/useAgentWorkflowSelection.ts +++ b/src/workbench/extensions/agent/composables/agent/useAgentWorkflowSelection.ts @@ -1,5 +1,6 @@ +import { until } from '@vueuse/core' import { storeToRefs } from 'pinia' -import { computed, onScopeDispose, ref } from 'vue' +import { computed, nextTick, onScopeDispose, ref } from 'vue' import { useI18n } from 'vue-i18n' import { useToast } from '@/components/ui/toast/toastStore' @@ -25,6 +26,8 @@ type RestorationOutcome = | { outcome: 'deleted' } | { outcome: 'superseded' } +const STARTUP_TAB_RESTORE_TIMEOUT_MS = 15_000 + function restorationOutcomeFor( lifecycle: CloudWorkflowLifecycle, target: ComfyWorkflow | null @@ -243,17 +246,35 @@ export function useAgentWorkflowSelection({ ): Promise { const listed = await refreshCloudWorkflowIds() if (!isCurrent()) return { outcome: 'superseded' } - const target = - boundOrOpenWorkflowFor(workflowId) ?? storedWorkflowFor(workflowId) + let target = localOwnerFor(workflowId) + if (target === null) { + if (!(await startupTabsRestored(isCurrent))) + return { outcome: 'superseded' } + target = localOwnerFor(workflowId) + } if (!listed || !cloudListingOmits(workflowId)) return { outcome: 'open', target } if (target === null) return { outcome: 'deleted' } const lifecycle = await cloudWorkflowLifecycle(workflowId) if (!isCurrent()) return { outcome: 'superseded' } - return restorationOutcomeFor( - lifecycle, - boundOrOpenWorkflowFor(workflowId) ?? storedWorkflowFor(workflowId) - ) + return restorationOutcomeFor(lifecycle, localOwnerFor(workflowId)) + } + + function localOwnerFor(workflowId: string): ComfyWorkflow | null { + return boundOrOpenWorkflowFor(workflowId) ?? storedWorkflowFor(workflowId) + } + + async function startupTabsRestored( + isCurrent: () => boolean + ): Promise { + if (!workflowStore.tabsRestored) { + await until(() => workflowStore.tabsRestored).toBe(true, { + timeout: STARTUP_TAB_RESTORE_TIMEOUT_MS, + throwOnTimeout: false + }) + await nextTick() + } + return isCurrent() } async function onWorkflowRestored(