diff --git a/browser_tests/fixtures/workflowLinkFixture.ts b/browser_tests/fixtures/workflowLinkFixture.ts new file mode 100644 index 00000000000..081a43fc150 --- /dev/null +++ b/browser_tests/fixtures/workflowLinkFixture.ts @@ -0,0 +1,200 @@ +import type { Page, Route } from '@playwright/test' + +import type { UserDataFullInfo } from '@/types' +import type { + ErrorResponse, + WorkflowSidebarFileResponse +} from '@comfyorg/ingest-types' + +import enMessages from '@/locales/en/main.json' with { type: 'json' } +import type { RemoteConfig } from '@/platform/remoteConfig/types' +import type { operations } from '@/types/comfyRegistryTypes' + +import linkedWorkflow from '@e2e/assets/nodes/note_nodes.json' with { type: 'json' } +import { + cloudAppExpect, + cloudAppFixture, + waitForCloudApp +} from '@e2e/fixtures/cloudAppFixture' +import { + CLOUD_SELF_EMAIL, + CloudAuthHelper +} from '@e2e/fixtures/helpers/CloudAuthHelper' +import { + bootCloud, + mockCloudBoot, + preselectCloudUser +} from '@e2e/fixtures/utils/cloudBootMocks' +import { jsonRoute } from '@e2e/fixtures/utils/jsonRoute' +import type { WorkspaceStore } from '@e2e/types/globals' + +const APP_URL = process.env.PLAYWRIGHT_TEST_URL || 'http://localhost:8188' +const BOOT_FEATURES = {} satisfies RemoteConfig +const BOOT_SETTINGS = { + 'Comfy.TutorialCompleted': true, + 'Comfy.Workflow.Persist': true +} + +type CreateCustomerResponse = + operations['createCustomer']['responses']['201']['content']['application/json'] + +export const workflowLinkScenario = { + workflowId: '82b98188-0c8f-41d2-9b91-617b9152b809', + path: 'workflows/links/linked-workflow.json', + tabName: 'linked-workflow', + notOpenedToast: enMessages.toastMessages.linkedWorkflowNotOpened +} as const + +const linkedWorkflowBody = JSON.stringify(linkedWorkflow) + +const listedFile: UserDataFullInfo = { + path: workflowLinkScenario.path.slice('workflows/'.length), + size: linkedWorkflowBody.length, + modified: 1_793_000_000_000 +} + +const sidebarFile: WorkflowSidebarFileResponse = { + ...listedFile, + path: workflowLinkScenario.path +} + +const outOfSync: ErrorResponse = { + code: 'WORKFLOW_OUT_OF_SYNC', + message: 'The workflow record does not match its sidebar file.', + details: { reason: 'content_mismatch' } +} + +function userdataFile(route: Route): string { + const { pathname } = new URL(route.request().url()) + return decodeURIComponent(pathname.split('/userdata/')[1] ?? '') +} + +class WorkflowLinkHelper { + readonly linkUrl = `${APP_URL}/?workflowId=${workflowLinkScenario.workflowId}` + private readonly savedPaths: string[] = [] + + constructor(private readonly page: Page) {} + + async mockSignedIn(): Promise { + await this.mockBoot() + await bootCloud(this.page) + } + + async mockSignedOut(): Promise { + await this.mockBoot() + await preselectCloudUser(this.page) + await this.page.route('**/customers', (route) => { + if (route.request().method() !== 'POST') return route.fallback() + return route.fulfill({ + status: 201, + json: { id: 'test-customer-e2e' } satisfies CreateCustomerResponse + }) + }) + await new CloudAuthHelper(this.page).mockLiveEmailSignIn() + } + + async serveLinkedFile(): Promise { + await this.page.route(this.sidebarFileUrl(), (route) => + route.fulfill(jsonRoute(sidebarFile)) + ) + await this.serveWorkflowsFolder() + } + + async refuseLinkedFile(): Promise { + await this.page.route(this.sidebarFileUrl(), (route) => + route.fulfill({ status: 409, json: outOfSync }) + ) + } + + async open(url: string): Promise { + await this.page.goto(url) + await waitForCloudApp(this.page) + } + + async openWithRestoredTabs(): Promise { + await this.open(APP_URL) + await this.page.reload() + await waitForCloudApp(this.page) + } + + async signInWithEmail(): Promise { + await cloudAppExpect( + this.page.getByRole('heading', { name: 'Log in to your account' }) + ).toBeVisible() + await this.page.getByRole('button', { name: 'Use email instead' }).click() + await this.page.locator('#cloud-sign-in-email').fill(CLOUD_SELF_EMAIL) + await this.page + .locator('#cloud-sign-in-password') + .fill('correct-horse-battery-staple') + await this.page.locator('#cloud-sign-in-password').blur() + await this.page.getByRole('button', { name: 'Sign in' }).click() + await waitForCloudApp(this.page) + } + + getActiveWorkflowPath(): Promise { + return this.page.evaluate( + () => + (window.app!.extensionManager as WorkspaceStore).workflow.activeWorkflow + ?.path + ) + } + + hasLinkInUrl(): boolean { + return new URL(this.page.url()).searchParams.has('workflowId') + } + + getSavedWorkflowPaths(): string[] { + return [...this.savedPaths] + } + + private sidebarFileUrl(): string { + return `**/api/workflows/${workflowLinkScenario.workflowId}/sidebar-file` + } + + private async mockBoot(): Promise { + await mockCloudBoot(this.page, { + features: BOOT_FEATURES, + settings: BOOT_SETTINGS + }) + } + + private async serveWorkflowsFolder(): Promise { + await this.page.route('**/api/userdata?*', (route) => { + const request = route.request() + const url = new URL(request.url()) + if (request.method() !== 'GET') return route.fallback() + if (url.searchParams.get('dir') !== 'workflows') return route.fallback() + return route.fulfill(jsonRoute([listedFile])) + }) + + await this.page.route('**/api/userdata/*', (route) => { + const method = route.request().method() + const file = userdataFile(route) + if (method === 'GET' && file === workflowLinkScenario.path) + return route.fulfill({ + contentType: 'application/json', + body: linkedWorkflowBody + }) + if ( + method !== 'POST' || + !file.startsWith('workflows/') || + file === 'workflows/.index.json' + ) + return route.fallback() + this.savedPaths.push(file) + return route.fulfill( + jsonRoute({ ...listedFile, path: file } satisfies UserDataFullInfo) + ) + }) + } +} + +export const workflowLinkFixture = cloudAppFixture.extend<{ + workflowLink: WorkflowLinkHelper +}>({ + workflowLink: async ({ page }, use) => { + await use(new WorkflowLinkHelper(page)) + } +}) + +export { cloudAppExpect as expect } diff --git a/browser_tests/tests/workflow/cloudWorkflowLink.spec.ts b/browser_tests/tests/workflow/cloudWorkflowLink.spec.ts new file mode 100644 index 00000000000..059502a4bf7 --- /dev/null +++ b/browser_tests/tests/workflow/cloudWorkflowLink.spec.ts @@ -0,0 +1,87 @@ +import { Topbar } from '@e2e/fixtures/components/Topbar' +import { + expect, + workflowLinkFixture as test, + workflowLinkScenario +} from '@e2e/fixtures/workflowLinkFixture' + +test.describe('Cloud workflow-id link', { tag: '@cloud' }, () => { + test.describe('when Cloud finds the sidebar file', () => { + test.beforeEach(async ({ workflowLink }) => { + await workflowLink.mockSignedIn() + await workflowLink.serveLinkedFile() + }) + + test('opens the file, clears the link and saves back to the same file', async ({ + page, + workflowLink + }) => { + const topbar = new Topbar(page) + + await workflowLink.open(workflowLink.linkUrl) + + await expect + .poll(() => workflowLink.getActiveWorkflowPath()) + .toBe(workflowLinkScenario.path) + await expect(topbar.getActiveTab()).toContainText( + workflowLinkScenario.tabName + ) + await expect.poll(() => workflowLink.hasLinkInUrl()).toBe(false) + + await topbar.triggerTopbarCommand(['File', 'Save']) + + await expect + .poll(() => workflowLink.getSavedWorkflowPaths()) + .toEqual([workflowLinkScenario.path]) + }) + }) + + test.describe('when Cloud refuses the link', () => { + test.beforeEach(async ({ workflowLink }) => { + await workflowLink.mockSignedIn() + await workflowLink.refuseLinkedFile() + }) + + test('shows the error and leaves the restored tabs as they were', async ({ + page, + toast, + workflowLink + }) => { + const topbar = new Topbar(page) + await workflowLink.openWithRestoredTabs() + await expect(topbar.tabs.first()).toBeVisible() + const restoredTabs = await topbar.getTabNames() + const restoredActiveTab = await topbar.getActiveTabName() + + await workflowLink.open(workflowLink.linkUrl) + + await expect( + toast.withText(workflowLinkScenario.notOpenedToast) + ).toBeVisible() + await expect.poll(() => topbar.getTabNames()).toEqual(restoredTabs) + expect(await topbar.getActiveTabName()).toBe(restoredActiveTab) + await expect.poll(() => workflowLink.hasLinkInUrl()).toBe(false) + }) + }) + + test.describe('when the visitor is signed out', () => { + test.beforeEach(async ({ workflowLink }) => { + await workflowLink.mockSignedOut() + await workflowLink.serveLinkedFile() + }) + + test('keeps the link through sign-in and opens the file after it', async ({ + page, + workflowLink + }) => { + await page.goto(workflowLink.linkUrl) + + await workflowLink.signInWithEmail() + + await expect + .poll(() => workflowLink.getActiveWorkflowPath()) + .toBe(workflowLinkScenario.path) + await expect.poll(() => workflowLink.hasLinkInUrl()).toBe(false) + }) + }) +}) diff --git a/docs/adr/WORKFLOW-LINKS-0053-open-workflow-links-through-the-sidebar-file.md b/docs/adr/WORKFLOW-LINKS-0053-open-workflow-links-through-the-sidebar-file.md new file mode 100644 index 00000000000..55da21059b4 --- /dev/null +++ b/docs/adr/WORKFLOW-LINKS-0053-open-workflow-links-through-the-sidebar-file.md @@ -0,0 +1,76 @@ +# ADR-WORKFLOW-LINKS-0053: Open Workflow Links Through the Sidebar File + +Date: 2026-11-09 + +## Status + +Proposed + +## Context + +A Cloud link of the form `?workflowId=` names one workflow. Cloud +keeps two copies of a saved workflow: the sidebar file, which the editor opens +and saves, and a workflow record with its own id, copied from that file on each +save. The copy is best effort, so the record can fall behind the file. Folder +links cannot name one file, and a path in the link breaks when the file is +renamed. + +## Decision + +Ask Cloud for the record's sidebar file with +`GET /api/workflows/{workflow_id}/sidebar-file`. Cloud answers with the file's +path only after it has checked that the file exists, that exactly one record +has that name, and that the file's bytes match the record's newest version. +Open that path through the existing workflow service, so Save writes back to +the same sidebar file. + +Fail closed. A 404 or any 409 `WORKFLOW_OUT_OF_SYNC` shows "Couldn't open this +workflow" and opens nothing. The editor never falls back to a folder link or to +the record's own content, and restored tabs stay as they were. + +Preserve the query through sign-in and onboarding. Defer the lookup while a +deployment or workspace link can reload the page, then resolve it after those +loaders finish. A workflow-id link takes precedence over a folder link, even +when it cannot be opened. Final handling clears both intents, and only for the +link it handled. A link the loader has not settled, such as a newer link the +browser navigated to meanwhile, stays in the URL and the stash. Nothing opens +it until the next page load. A workflow that opened stays open when another +navigation cancels that cleanup; the final URL-action sweep clears the link it +left. Only a reload in flight stops the URL actions. A link that is not settled +does not stop them: the other loaders run, and the final sweep removes their +params but leaves `workflowId` and its stash. A navigation guard can hold a +newer link in the stash while the URL still shows the old one. While the URL +and the stash name different links, the loader treats the stash as a navigation +still in flight: it makes no replace and clears neither carrier, even for a +link it already opened. An empty `?workflowId=` clears the stash when the +router captures it, so an older stashed link cannot keep the empty one from +being rejected as invalid. While the stash holds a link the loader never started +and the URL does not show, the sweep makes no replace either, so that link's +navigation is not cancelled. + +The reply and the 409 body are validated with the generated +`@comfyorg/ingest-types` schemas. The spec types the 409 as `ErrorResponse` and +lists the `details.reason` values only in prose, saying the set may grow. The +loader keeps its list of known reasons as a telemetry classification and +records any other value as `unknown`. + +Error reports for the link carry a fixed message, the error type and the +failing error's class name. They never carry the caught error or its message: +a failed file read names the file, and a parser error quotes the reply. + +## Alternatives considered + +- Open the record's own content: rejected because Save would write to a file + the record may not match, and an out-of-date copy would open without notice. +- Link by a new id on the sidebar file: rejected because Cloud's existing + `/api/workflows/{workflow_id}` routes already name a workflow by the record's + id, and a second id for the same workflow would need its own storage. +- Extend the folder loader: rejected because folder filtering and a single + checked lookup have different failure and selection rules. + +## Consequences + +The link resolves the current sidebar path at open time. Workflow state stays +path based after opening. PostHog records the result, the 409 reason and the +workspace, never a workflow name, path or id. A record that has fallen behind +its file cannot be opened from a link until the next save copies it again. diff --git a/packages/ingest-types/src/index.ts b/packages/ingest-types/src/index.ts index cb4f795ef0c..2adf22e2cff 100644 --- a/packages/ingest-types/src/index.ts +++ b/packages/ingest-types/src/index.ts @@ -1042,6 +1042,11 @@ export type { GetWorkflowErrors, GetWorkflowResponse, GetWorkflowResponses, + GetWorkflowSidebarFileData, + GetWorkflowSidebarFileError, + GetWorkflowSidebarFileErrors, + GetWorkflowSidebarFileResponse, + GetWorkflowSidebarFileResponses, GetWorkflowTemplatesData, GetWorkflowTemplatesResponse, GetWorkflowTemplatesResponses, @@ -1641,6 +1646,7 @@ export type { WorkflowListResponse, WorkflowPublishInfo, WorkflowResponse, + WorkflowSidebarFileResponse, WorkflowUploadUrlRequest, WorkflowVersionContentResponse, WorkflowVersionResponse, diff --git a/packages/ingest-types/src/types.gen.ts b/packages/ingest-types/src/types.gen.ts index 9fd50f26720..9eb7b3efef9 100644 --- a/packages/ingest-types/src/types.gen.ts +++ b/packages/ingest-types/src/types.gen.ts @@ -284,6 +284,24 @@ export type WorkflowVersionContentResponse = { } } +/** + * The sidebar file a workflow was copied from, when the two agree. No content and no userdata id: open the path through the userdata API. + */ +export type WorkflowSidebarFileResponse = { + /** + * UNIX timestamp of the last modification in milliseconds, the same unit as GET /api/userdata?full_info=true. + */ + modified: number + /** + * The userdata path, `workflows/.json`. + */ + path: string + /** + * File size in bytes. + */ + size: number +} + /** * Workflow metadata captured at mint time. The subsequent PUT body is the * raw workflow JSON document and nothing else, so everything that would @@ -19524,6 +19542,58 @@ export type ForkWorkflowResponses = { export type ForkWorkflowResponse = ForkWorkflowResponses[keyof ForkWorkflowResponses] +export type GetWorkflowSidebarFileData = { + body?: never + path: { + /** + * The UUID of the workflow. Parsed by the handler, so a malformed id answers 404. + */ + workflow_id: string + } + query?: never + url: '/api/workflows/{workflow_id}/sidebar-file' +} + +export type GetWorkflowSidebarFileErrors = { + /** + * `code` is `workspace_id_invalid`: the `X-Comfy-Workspace-ID` header or `workspace_id` query value is malformed, or conflicts with another value or with the workspace the credential resolves to. Answered only while `web_session_enabled` is on for the user. See the `WebSessionAuth` scheme. + */ + 400: ErrorResponse + /** + * Unauthorized + */ + 401: ErrorResponse + /** + * A refused request. For a web session, `code` is `workspace_access_denied` (the selected workspace is unknown, deleted, or the user is not a member; the three look the same), `no_workspace_access` (the account has no personal workspace and is a member of no live workspace), `origin_not_allowed` or `cross_site_request`; see the `WebSessionAuth` scheme. For any credential, `sso_required` means an SSO organization holds the account (its email is on the organization's verified domains) and the credential is not an SSO sign-in, or the workspace is an SSO organization's and the account is not on its domains or the credential is not an SSO sign-in; `organization_id`, when present, names the organization to sign in with. `account_outside_organization` means the workspace is an SSO organization's and the account is on none of its domains, so no sign-in admits it; `organization_id` names the workspace's organization. `personal_workspace_disabled` means the workspace is the account's personal one and an SSO organization holds the account, so it cannot use it; `organization_id` names that organization. `FORBIDDEN` is the route's own authorization check failing, such as an unverified email. On `GET /api/billing/churnkey/auth`, `NOT_ORIGINAL_OWNER` means the caller is not the workspace's creator; it is returned only when the rollout mode is `creator`. A credential this route does not take gets AuthTypeNotAllowedError instead, and so does the session while `web_session_enabled` is off for the user, unless the operation says it takes the session whatever `web_session_enabled` says. + */ + 403: ForbiddenError + /** + * `code` is `NOT_FOUND`: no live workflow with this id that the caller created in this workspace. + */ + 404: ErrorResponse + /** + * `code` is `WORKFLOW_OUT_OF_SYNC` and `details.reason` is one of `no_sidebar_path`, `name_ambiguous`, `file_missing` or `content_mismatch`. Clients open nothing on this answer. The set of reasons may grow, and clients treat an unknown reason as out of sync. + */ + 409: ErrorResponse + /** + * Internal server error + */ + 500: ErrorResponse +} + +export type GetWorkflowSidebarFileError = + GetWorkflowSidebarFileErrors[keyof GetWorkflowSidebarFileErrors] + +export type GetWorkflowSidebarFileResponses = { + /** + * The workflow and its sidebar file agree. + */ + 200: WorkflowSidebarFileResponse +} + +export type GetWorkflowSidebarFileResponse = + GetWorkflowSidebarFileResponses[keyof GetWorkflowSidebarFileResponses] + export type CreateWorkflowVersionData = { body: CreateWorkflowVersionRequest path: { diff --git a/packages/ingest-types/src/zod.gen.ts b/packages/ingest-types/src/zod.gen.ts index 902239e776d..7706daf4539 100644 --- a/packages/ingest-types/src/zod.gen.ts +++ b/packages/ingest-types/src/zod.gen.ts @@ -176,6 +176,22 @@ export const zWorkflowVersionContentResponse = z.object({ workflow_json: z.record(z.string(), z.unknown()) }) +/** + * The sidebar file a workflow was copied from, when the two agree. No content and no userdata id: open the path through the userdata API. + */ +export const zWorkflowSidebarFileResponse = z.object({ + modified: z.coerce + .bigint() + .min(BigInt('-9223372036854775808'), { + error: 'Invalid value: Expected int64 to be >= -9223372036854775808' + }) + .max(BigInt('9223372036854775807'), { + error: 'Invalid value: Expected int64 to be <= 9223372036854775807' + }), + path: z.string(), + size: z.int() +}) + /** * Workflow metadata captured at mint time. The subsequent PUT body is the * raw workflow JSON document and nothing else, so everything that would @@ -7554,6 +7570,15 @@ export const zForkWorkflowPath = z.object({ */ export const zForkWorkflowResponse = zWorkflowResponse +export const zGetWorkflowSidebarFilePath = z.object({ + workflow_id: z.string() +}) + +/** + * The workflow and its sidebar file agree. + */ +export const zGetWorkflowSidebarFileResponse = zWorkflowSidebarFileResponse + export const zCreateWorkflowVersionBody = zCreateWorkflowVersionRequest export const zCreateWorkflowVersionPath = z.object({ diff --git a/src/composables/sweptWorkflowLinkParams.ts b/src/composables/sweptWorkflowLinkParams.ts new file mode 100644 index 00000000000..492c29f2645 --- /dev/null +++ b/src/composables/sweptWorkflowLinkParams.ts @@ -0,0 +1,25 @@ +import type { LocationQuery } from 'vue-router' + +import type { useWorkflowLinkUrlLoader } from '@/composables/useWorkflowLinkUrlLoader' +import { + clearPreservedQuery, + getPreservedQueryParam +} from '@/platform/navigation/preservedQueryManager' +import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQueryNamespaces' + +/** The settled workflow-id params the deep-link sweep may drop; clears a settled stash. */ +export function sweptWorkflowLinkParams( + loader: ReturnType | null, + query: LocationQuery +): string[] { + if (!loader) return [] + const stashed = getPreservedQueryParam( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + 'workflowId' + ) + if (stashed !== undefined && loader.isLinkSettled(stashed)) + clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID) + return 'workflowId' in query && loader.isLinkSettled(query.workflowId) + ? ['workflowId'] + : [] +} diff --git a/src/composables/useLinkedWorkflowUrlLoader.ts b/src/composables/useLinkedWorkflowUrlLoader.ts new file mode 100644 index 00000000000..93ea0707896 --- /dev/null +++ b/src/composables/useLinkedWorkflowUrlLoader.ts @@ -0,0 +1,21 @@ +import { useWorkflowLinkUrlLoader } from '@/composables/useWorkflowLinkUrlLoader' +import { useFolderWorkflowsUrlLoader } from '@/platform/workflow/management/composables/useFolderWorkflowsUrlLoader' + +/** Opens the workflow a boot URL links to: a workflow id first, else a folder. */ +export function useLinkedWorkflowUrlLoader() { + const workflowLinkUrlLoader = useWorkflowLinkUrlLoader() + const folderWorkflowsUrlLoader = useFolderWorkflowsUrlLoader() + + async function openLinkedWorkflowFromUrl(): Promise< + 'opened' | 'pending' | 'none' + > { + const status = await workflowLinkUrlLoader.openWorkflowLinkFromUrl() + if (status === 'absent') { + const opened = await folderWorkflowsUrlLoader.openFolderWorkflowsFromUrl() + return opened ? 'opened' : 'none' + } + return status === 'failed' ? 'none' : status + } + + return { openLinkedWorkflowFromUrl } +} diff --git a/src/composables/useUrlActionLoaders.test.ts b/src/composables/useUrlActionLoaders.test.ts index df17a4332d3..4a37346fe01 100644 --- a/src/composables/useUrlActionLoaders.test.ts +++ b/src/composables/useUrlActionLoaders.test.ts @@ -9,6 +9,7 @@ import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQuery import { useSubscriptionDialog } from '@/platform/billing/subscription/composables/useSubscriptionDialog' import { useUrlActionLoaders } from './useUrlActionLoaders' +import type { useWorkflowLinkUrlLoader } from '@/composables/useWorkflowLinkUrlLoader' const mockIsCloud = vi.hoisted(() => ({ value: true })) vi.mock(import('@/platform/distribution/types'), () => ({ @@ -17,6 +18,21 @@ vi.mock(import('@/platform/distribution/types'), () => ({ } })) +const workflowLinkUrlLoader = vi.hoisted(() => ({ + openWorkflowLinkFromUrl: vi.fn< + ReturnType['openWorkflowLinkFromUrl'] + >(async () => 'absent'), + isLinkSettled: vi.fn< + ReturnType['isLinkSettled'] + >(() => false), + hasLinkInFlight: vi.fn< + ReturnType['hasLinkInFlight'] + >(() => false) +})) +vi.mock(import('@/composables/useWorkflowLinkUrlLoader'), () => ({ + useWorkflowLinkUrlLoader: () => workflowLinkUrlLoader +})) + const mocks = vi.hoisted(() => ({ reportError: vi.fn(), loadDeployment: vi.fn(async (): Promise => false), @@ -344,6 +360,212 @@ describe('useUrlActionLoaders', () => { ).toBeUndefined() }) + it.for(['deployment', 'workspace'] as const)( + 'preserves the workflow-id link across a %s reload without opening it', + async (kind) => { + await router.replace({ + query: { workflowId: 'workflow-id', workflows: 'ignored' } + }) + capturePreservedQuery( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + { workflowId: 'workflow-id' }, + ['workflowId'] + ) + const loader = + kind === 'deployment' ? mocks.loadDeployment : mocks.loadWorkspace + loader.mockResolvedValueOnce(true) + + await useUrlActionLoaders().runUrlActionLoaders() + + expect( + workflowLinkUrlLoader.openWorkflowLinkFromUrl + ).not.toHaveBeenCalled() + expect(router.currentRoute.value.query.workflowId).toBe('workflow-id') + expect( + getPreservedQueryParam( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + 'workflowId' + ) + ).toBe('workflow-id') + } + ) + + it('finishes the workflow-id link after navigation and clears the URL and stash', async () => { + await router.replace({ query: { workflowId: 'workflow-id', keep: 'yes' } }) + workflowLinkUrlLoader.isLinkSettled.mockReturnValue(true) + capturePreservedQuery( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + { workflowId: 'workflow-id' }, + ['workflowId'] + ) + + await useUrlActionLoaders().runUrlActionLoaders() + + expect( + workflowLinkUrlLoader.openWorkflowLinkFromUrl + ).toHaveBeenCalledExactlyOnceWith(true) + expect( + workflowLinkUrlLoader.openWorkflowLinkFromUrl.mock.invocationCallOrder[0] + ).toBeGreaterThan(mocks.loadWorkspace.mock.invocationCallOrder[0]) + expect(router.currentRoute.value.query).toEqual({ keep: 'yes' }) + expect( + getPreservedQueryParam( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + 'workflowId' + ) + ).toBeUndefined() + }) + + it('leaves a workflow-id link the browser navigated to after the settled one', async () => { + await router.replace({ query: { workflowId: 'workflow-a', keep: 'yes' } }) + workflowLinkUrlLoader.isLinkSettled.mockImplementation( + (workflowId) => workflowId === 'workflow-a' + ) + workflowLinkUrlLoader.openWorkflowLinkFromUrl.mockImplementation( + async () => { + await router.replace({ + query: { workflowId: 'workflow-b', keep: 'yes' } + }) + capturePreservedQuery( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + { workflowId: 'workflow-b' }, + ['workflowId'] + ) + return 'opened' + } + ) + + await useUrlActionLoaders().runUrlActionLoaders() + + expect(router.currentRoute.value.query).toEqual({ + workflowId: 'workflow-b', + keep: 'yes' + }) + expect( + getPreservedQueryParam( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + 'workflowId' + ) + ).toBe('workflow-b') + }) + + it('runs the later loaders and clears their params while a workflow-id link is pending', async () => { + await router.replace({ + query: { workflowId: 'workflow-id', invite: 'inv-1', settings: 'x' } + }) + capturePreservedQuery( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + { workflowId: 'workflow-id' }, + ['workflowId'] + ) + workflowLinkUrlLoader.openWorkflowLinkFromUrl.mockResolvedValue('pending') + + await useUrlActionLoaders().runUrlActionLoaders() + + expect(mocks.loadInvite).toHaveBeenCalledOnce() + expect(mocks.loadSettings).toHaveBeenCalledOnce() + expect(mocks.loadLocalHandoff).toHaveBeenCalledOnce() + expect(router.currentRoute.value.query).toEqual({ + workflowId: 'workflow-id' + }) + expect( + getPreservedQueryParam( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + 'workflowId' + ) + ).toBe('workflow-id') + expect( + useSubscriptionDialog().resumePendingPricingFlow + ).toHaveBeenCalledOnce() + }) + + it('clears the other params but leaves a newer workflow-id link and its stash', async () => { + await router.replace({ query: { workflowId: 'workflow-a', topup: '1' } }) + workflowLinkUrlLoader.isLinkSettled.mockImplementation( + (workflowId) => workflowId === 'workflow-a' + ) + workflowLinkUrlLoader.openWorkflowLinkFromUrl.mockImplementation( + async () => { + await router.replace({ + query: { workflowId: 'workflow-b', topup: '1' } + }) + capturePreservedQuery( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + { workflowId: 'workflow-b' }, + ['workflowId'] + ) + return 'opened' + } + ) + + await useUrlActionLoaders().runUrlActionLoaders() + + expect(mocks.loadTopUp).toHaveBeenCalledOnce() + expect(router.currentRoute.value.query).toEqual({ + workflowId: 'workflow-b' + }) + expect( + getPreservedQueryParam( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + 'workflowId' + ) + ).toBe('workflow-b') + expect( + useSubscriptionDialog().resumePendingPricingFlow + ).toHaveBeenCalledOnce() + }) + + it('lets a newer workflow-id link held in a navigation guard land instead of cancelling it', async () => { + await router.replace({ query: { workflowId: 'workflow-a', topup: '1' } }) + workflowLinkUrlLoader.openWorkflowLinkFromUrl.mockResolvedValue('opened') + workflowLinkUrlLoader.isLinkSettled.mockImplementation( + (workflowId) => workflowId === 'workflow-a' + ) + workflowLinkUrlLoader.hasLinkInFlight.mockReturnValue(true) + let releaseGuard: () => void = () => {} + const removeGuard = router.beforeEach(() => { + removeGuard() + return new Promise((resolve) => { + releaseGuard = resolve + }) + }) + const newerLink = router.push({ query: { workflowId: 'workflow-b' } }) + + await useUrlActionLoaders().runUrlActionLoaders() + releaseGuard() + await newerLink + + expect(mocks.loadTopUp).toHaveBeenCalledOnce() + expect(router.currentRoute.value.query).toEqual({ + workflowId: 'workflow-b' + }) + expect( + useSubscriptionDialog().resumePendingPricingFlow + ).toHaveBeenCalledOnce() + }) + + it('retains a deferred workflow-id URL and stash after identity changes', async () => { + await router.replace({ + query: { workflowId: 'workflow-id', workflows: 'ignored' } + }) + capturePreservedQuery( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + { workflowId: 'workflow-id' }, + ['workflowId'] + ) + workflowLinkUrlLoader.openWorkflowLinkFromUrl.mockResolvedValue('pending') + + await useUrlActionLoaders().runUrlActionLoaders() + + expect(router.currentRoute.value.query.workflowId).toBe('workflow-id') + expect( + getPreservedQueryParam( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + 'workflowId' + ) + ).toBe('workflow-id') + }) + it('clears a deployment param no loader acted on', async () => { await router.replace({ path: '/', diff --git a/src/composables/useUrlActionLoaders.ts b/src/composables/useUrlActionLoaders.ts index 738af44f5f0..b8017cd8754 100644 --- a/src/composables/useUrlActionLoaders.ts +++ b/src/composables/useUrlActionLoaders.ts @@ -1,5 +1,7 @@ import { useRouter } from 'vue-router' +import { sweptWorkflowLinkParams } from '@/composables/sweptWorkflowLinkParams' +import { useWorkflowLinkUrlLoader } from '@/composables/useWorkflowLinkUrlLoader' import { useAssetsUrlLoader } from '@/platform/assets/composables/useAssetsUrlLoader' import { usePricingTableUrlLoader } from '@/platform/billing/subscription/composables/usePricingTableUrlLoader' import { useSubscriptionDialog } from '@/platform/billing/subscription/composables/useSubscriptionDialog' @@ -30,6 +32,7 @@ interface UrlActionStep { } type UrlActionLoaders = { + workflowLinkUrlLoader: ReturnType | null deploymentUrlLoader: ReturnType | null workspaceUrlLoader: ReturnType | null inviteUrlLoader: ReturnType | null @@ -90,6 +93,41 @@ function deploymentLinkSteps( ] } +function workflowLinkSteps( + loader: UrlActionLoaders['workflowLinkUrlLoader'] +): UrlActionStep[] { + if (!loader) return [] + return [ + { + failureMessage: 'Failed to open the linked workflow from URL:', + run: async () => { + await loader.openWorkflowLinkFromUrl(true) + } + } + ] +} + +function sweepStep( + loader: UrlActionLoaders['workflowLinkUrlLoader'], + router: ReturnType +): UrlActionStep { + return { + failureMessage: 'Failed to clear handled deep-link params from the URL:', + run: async () => { + if (loader?.hasLinkInFlight()) return + clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKFLOWS) + const query = { ...router.currentRoute.value.query } + const params = [ + ...HANDLED_PARAMS.filter((param) => param in query), + ...sweptWorkflowLinkParams(loader, query) + ] + if (params.length === 0) return + for (const param of params) delete query[param] + await router.replace({ query }) + } + } +} + /** * Orders the deep-link loaders: the deployment link first, since with * `?deployment` it owns `?workspace` too (it switches, then picks after the @@ -111,6 +149,7 @@ function buildUrlActionSteps( run: () => loader.loadWorkspaceFromUrl() }) } + steps.push(...workflowLinkSteps(loaders.workflowLinkUrlLoader)) if (loaders.inviteUrlLoader) { const loader = loaders.inviteUrlLoader steps.push({ @@ -162,16 +201,7 @@ function buildUrlActionSteps( }) } - steps.push({ - failureMessage: 'Failed to clear handled deep-link params from the URL:', - run: async () => { - clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKFLOWS) - const query = { ...router.currentRoute.value.query } - if (!HANDLED_PARAMS.some((param) => param in query)) return - for (const param of HANDLED_PARAMS) delete query[param] - await router.replace({ query }) - } - }) + steps.push(sweepStep(loaders.workflowLinkUrlLoader, router)) return steps } @@ -225,7 +255,7 @@ function useIfCloud(create: () => T): T | null { /** * Aggregates the query-param "deep link" loaders the cloud app checks on mount - * (`?deployment`, `?workspace`, `?invite`, `?create_workspace`, `?pricing`, + * (`?deployment`, `?workspace`, `?workflowId`, `?invite`, `?create_workspace`, `?pricing`, * `?topup`, `?settings`, `?assets`), then recovers an interrupted checkout. The loaders * are instantiated in setup so their `useRoute`/`useRouter` resolve; call * `runUrlActionLoaders()` from `onMounted` once the app is ready. @@ -233,6 +263,7 @@ function useIfCloud(create: () => T): T | null { export function useUrlActionLoaders() { const router = useRouter() + const workflowLinkUrlLoader = useIfCloud(useWorkflowLinkUrlLoader) const deploymentUrlLoader = useIfCloud(useDeploymentUrlLoader) const workspaceUrlLoader = useIfCloud(useWorkspaceUrlLoader) const inviteUrlLoader = useIfCloud(useInviteUrlLoader) @@ -247,6 +278,7 @@ export function useUrlActionLoaders() { const steps = isCloud ? buildUrlActionSteps( { + workflowLinkUrlLoader, deploymentUrlLoader, workspaceUrlLoader, inviteUrlLoader, diff --git a/src/composables/useWorkflowLinkUrlLoader.test.ts b/src/composables/useWorkflowLinkUrlLoader.test.ts new file mode 100644 index 00000000000..9c216da9667 --- /dev/null +++ b/src/composables/useWorkflowLinkUrlLoader.test.ts @@ -0,0 +1,806 @@ +import { + assert, + beforeEach, + describe, + expect, + it, + onTestFinished, + vi +} from 'vitest' +import { createApp, effectScope } from 'vue' +import type { App, EffectScope } from 'vue' +import { createMemoryHistory, createRouter } from 'vue-router' +import type { + LocationQueryRaw, + RouteLocationNormalized, + Router +} from 'vue-router' + +import { useToast } from '@/components/ui/toast/toastStore' +import { useLinkedWorkflowUrlLoader } from '@/composables/useLinkedWorkflowUrlLoader' +import { useUrlActionLoaders } from '@/composables/useUrlActionLoaders' +import { + capturePreservedQuery, + clearPreservedQuery, + getPreservedQueryParam +} from '@/platform/navigation/preservedQueryManager' +import { PRESERVED_QUERY_DEFINITIONS } from '@/platform/navigation/preservedQueryDefinitions' +import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQueryNamespaces' +import { installPreservedQueryTracker } from '@/platform/navigation/preservedQueryTracker' +import { useTelemetry } from '@/platform/telemetry' +import { reportError } from '@/platform/telemetry/reportError' +import { useWorkflowService } from '@/platform/workflow/core/services/workflowService' +import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore' +import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' +import { api } from '@/scripts/api' +import { blankGraph } from '@/scripts/defaultGraph' +import '@/scripts/changeTracker' + +import { useWorkflowLinkUrlLoader } from './useWorkflowLinkUrlLoader' + +vi.mock(import('@/scripts/app')) +vi.mock(import('@/platform/telemetry')) +vi.mock(import('@/platform/telemetry/reportError')) +vi.mock(import('@/platform/workflow/core/services/workflowService')) +vi.mock(import('@/platform/workspace/composables/useDeploymentUrlLoader')) +vi.mock(import('@/platform/workspace/composables/useWorkspaceUrlLoader')) +vi.mock(import('@/platform/workspace/composables/useInviteUrlLoader')) +vi.mock(import('@/platform/workspace/composables/useCreateWorkspaceUrlLoader')) +vi.mock( + import('@/platform/billing/subscription/composables/usePricingTableUrlLoader') +) +vi.mock(import('@/platform/billing/subscription/composables/useTopUpUrlLoader')) +vi.mock( + import('@/platform/billing/subscription/composables/useSubscriptionDialog') +) +vi.mock(import('@/platform/settings/composables/useSettingsUrlLoader')) +vi.mock(import('@/platform/assets/composables/useAssetsUrlLoader')) +vi.mock(import('@/platform/openOnCloud/composables/useLocalHandoffUrlLoader')) + +const distribution = vi.hoisted(() => ({ isCloud: true })) +vi.mock(import('@/platform/distribution/types'), () => ({ + get isCloud() { + return distribution.isCloud + } +})) + +const ID = '82b98188-0c8f-41d2-9b91-617b9152b809' +const NEXT_ID = '5d1c7f0e-3a4b-4c2d-8e9f-0a1b2c3d4e5f' +const NAMESPACE = PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID +const PATH = 'workflows/Car swap.json' +const MODIFIED_MS = 1_793_000_000_000 + +function serveFile(path = PATH) { + vi.spyOn(api, 'fetchApi').mockResolvedValue( + Response.json({ path, size: 12, modified: MODIFIED_MS }) + ) + vi.spyOn(api, 'getUserData').mockImplementation(async () => + Response.json(blankGraph) + ) + vi.spyOn(api, 'listUserDataFullInfo').mockResolvedValue([ + { path: path.slice('workflows/'.length), size: 12, modified: MODIFIED_MS } + ]) +} + +function holdLookup() { + serveFile() + let respond: () => void = () => {} + vi.mocked(api.fetchApi).mockReturnValueOnce( + new Promise((resolve) => { + respond = () => + resolve(Response.json({ path: PATH, size: 12, modified: MODIFIED_MS })) + }) + ) + return () => respond() +} + +function refuse(status: number, body: object) { + vi.spyOn(api, 'fetchApi').mockResolvedValue(Response.json(body, { status })) +} + +async function openExistingTab() { + const store = useWorkflowStore() + const existing = store.createTemporary('Existing.json') + await store.openWorkflow(existing) + return { store, existing, active: store.activeWorkflow } +} + +function isUrlCleanup(to: RouteLocationNormalized): boolean { + return !('workflowId' in to.query) +} + +function isNewerLink(to: RouteLocationNormalized): boolean { + return to.query.workflowId === NEXT_ID +} + +describe('workflow-id links', () => { + let router: Router + let app: App + let scope: EffectScope + let loader: ReturnType + + function inApp(composable: () => T): T { + const result = app.runWithContext(() => scope.run(composable)) + assert.exists(result) + return result + } + + function currentQuery() { + return router.currentRoute.value.query + } + + async function navigate(query: LocationQueryRaw) { + await router.push({ path: '/', query }) + } + + function holdNavigation(matches: (to: RouteLocationNormalized) => boolean) { + let arrive: () => void = () => {} + let release: () => void = () => {} + const arrived = new Promise((resolve) => { + arrive = resolve + }) + const released = new Promise((resolve) => { + release = resolve + }) + const removeGuard = router.beforeEach(async (to) => { + if (!matches(to)) return + arrive() + await released + }) + return { + arrived, + release: () => { + removeGuard() + release() + } + } + } + + function runUrlActions() { + return inApp(useUrlActionLoaders).runUrlActionLoaders() + } + + beforeEach(async () => { + distribution.isCloud = true + clearPreservedQuery(NAMESPACE) + clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKFLOWS) + clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.DEPLOYMENT) + clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKSPACE) + Object.assign(useTeamWorkspaceStore(), { activeWorkspaceId: 'workspace-1' }) + router = createRouter({ + history: createMemoryHistory(), + routes: [{ path: '/:pathMatch(.*)*', component: { render: () => null } }] + }) + installPreservedQueryTracker(router, PRESERVED_QUERY_DEFINITIONS) + app = createApp({}) + app.use(router) + await router.push('/') + scope = effectScope() + onTestFinished(() => scope.stop()) + loader = inApp(useWorkflowLinkUrlLoader) + }) + + it('opens the sidebar file the workflow id names, in front of restored tabs', async () => { + serveFile() + await navigate({ workflowId: ID, workflows: 'other', keep: 'yes' }) + const { store, existing } = await openExistingTab() + vi.mocked(useWorkflowService().openWorkflow).mockImplementation( + async (workflow) => { + await store.openWorkflow(workflow) + return true + } + ) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('opened') + + expect(api.fetchApi).toHaveBeenCalledExactlyOnceWith( + `/workflows/${ID}/sidebar-file` + ) + expect(store.activeWorkflow?.path).toBe(PATH) + expect(store.activeWorkflow?.isTemporary).toBe(false) + expect(store.openWorkflows.map(({ path }) => path)).toEqual([ + existing.path, + PATH + ]) + expect(currentQuery()).toEqual({ keep: 'yes' }) + expect( + useTelemetry()?.trackWorkflowLinkOpened + ).toHaveBeenCalledExactlyOnceWith({ + outcome: 'opened', + workspace_id: 'workspace-1' + }) + expect(await loader.openWorkflowLinkFromUrl()).toBe('absent') + expect(useTelemetry()?.trackWorkflowLinkOpened).toHaveBeenCalledTimes(1) + }) + + it('opens a link preserved through sign-in and onboarding and clears the stash', async () => { + serveFile() + sessionStorage.setItem( + 'Comfy.PreservedQuery.workflowId', + JSON.stringify({ workflowId: ID }) + ) + capturePreservedQuery( + PRESERVED_QUERY_NAMESPACES.WORKFLOWS, + { workflows: 'ignored' }, + ['workflows'] + ) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('opened') + + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBeUndefined() + expect( + getPreservedQueryParam(PRESERVED_QUERY_NAMESPACES.WORKFLOWS, 'workflows') + ).toBeUndefined() + expect(sessionStorage.getItem('Comfy.PreservedQuery.workflowId')).toBeNull() + }) + + it('opens a sidebar file saved after the bootstrap listing was cached', async () => { + serveFile() + vi.mocked(api.listUserDataFullInfo).mockResolvedValueOnce([ + { path: 'old.json', size: 12, modified: MODIFIED_MS } + ]) + const store = useWorkflowStore() + await store.loadWorkflows() + await navigate({ workflowId: ID }) + vi.mocked(useWorkflowService().openWorkflow).mockImplementation( + async (workflow) => { + await store.openWorkflow(workflow) + return true + } + ) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('opened') + expect(store.activeWorkflow?.path).toBe(PATH) + expect(useToast().toasts).toEqual([]) + }) + + it('reports one result across boot consumers when URL cleanup fails', async () => { + serveFile() + await navigate({ workflowId: ID }) + vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(true) + const failCleanupOnce = vi + .fn(() => true) + .mockImplementationOnce(() => { + throw new Error('cancelled') + }) + router.beforeEach(failCleanupOnce) + const consumers = [ + inApp(useWorkflowLinkUrlLoader), + inApp(useWorkflowLinkUrlLoader) + ] + + expect(await consumers[0].openWorkflowLinkFromUrl()).toBe('opened') + await consumers[1].openWorkflowLinkFromUrl(true) + + expect(api.fetchApi).toHaveBeenCalledTimes(1) + expect(useTelemetry()?.trackWorkflowLinkOpened).toHaveBeenCalledTimes(1) + expect(currentQuery()).toEqual({}) + }) + + it('opens nothing and leaves restored tabs on 404', async () => { + refuse(404, { code: 'NOT_FOUND', message: 'not found' }) + await navigate({ workflowId: ID }) + const { store, existing, active } = await openExistingTab() + + expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') + + expect(store.activeWorkflow).toBe(active) + expect(store.openWorkflows).toEqual([existing]) + expect(useToast().toasts.map(({ title }) => title)).toEqual([ + "Couldn't open this workflow" + ]) + expect(useWorkflowService().openWorkflow).not.toHaveBeenCalled() + expect(currentQuery()).toEqual({}) + expect( + useTelemetry()?.trackWorkflowLinkOpened + ).toHaveBeenCalledExactlyOnceWith({ + outcome: 'not_found', + workspace_id: 'workspace-1' + }) + }) + + it.for([ + { + name: 'no sidebar path in details', + body: { details: { reason: 'no_sidebar_path' } }, + reason: 'no_sidebar_path' + }, + { + name: 'an ambiguous name in details', + body: { details: { reason: 'name_ambiguous' } }, + reason: 'name_ambiguous' + }, + { + name: 'a missing file in details', + body: { details: { reason: 'file_missing' } }, + reason: 'file_missing' + }, + { + name: 'mismatched content in details', + body: { details: { reason: 'content_mismatch' } }, + reason: 'content_mismatch' + }, + { + name: 'a reason outside details', + body: { reason: 'content_mismatch' }, + reason: 'unknown' + }, + { + name: 'a reason this release does not know', + body: { details: { reason: 'Car swap.json renamed' } }, + reason: 'unknown' + }, + { + name: 'no reason', + body: {}, + reason: 'unknown' + } + ] as const)( + 'refuses an out-of-sync workflow with $name and opens nothing', + async ({ body, reason }) => { + refuse(409, { + code: 'WORKFLOW_OUT_OF_SYNC', + message: 'workflows/Car swap.json is out of sync', + ...body + }) + await navigate({ workflowId: ID, workflows: 'Car swap' }) + const { store, existing, active } = await openExistingTab() + const contentRead = vi.spyOn(api, 'getUserData') + + expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') + + expect(api.fetchApi).toHaveBeenCalledTimes(1) + expect(contentRead).not.toHaveBeenCalled() + expect(useWorkflowService().openWorkflow).not.toHaveBeenCalled() + expect(store.activeWorkflow).toBe(active) + expect(store.openWorkflows).toEqual([existing]) + expect(useToast().toasts.map(({ title }) => title)).toEqual([ + "Couldn't open this workflow" + ]) + expect(currentQuery()).toEqual({}) + expect( + useTelemetry()?.trackWorkflowLinkOpened + ).toHaveBeenCalledExactlyOnceWith({ + outcome: 'out_of_sync', + reason, + workspace_id: 'workspace-1' + }) + } + ) + + it.for([ + { + name: 'another code', + response: () => Response.json({ code: 'CONFLICT' }, { status: 409 }) + }, + { + name: 'a body that is not JSON', + response: () => new Response('{', { status: 409 }) + } + ])( + 'treats a 409 with $name as out of sync for an unknown reason', + async ({ response }) => { + vi.spyOn(api, 'fetchApi').mockResolvedValue(response()) + await navigate({ workflowId: ID }) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') + + expect(useToast().toasts[0]?.title).toBe("Couldn't open this workflow") + expect( + useTelemetry()?.trackWorkflowLinkOpened + ).toHaveBeenCalledExactlyOnceWith({ + outcome: 'out_of_sync', + reason: 'unknown', + workspace_id: 'workspace-1' + }) + } + ) + + it.for(['invalid', '', null, [ID, ID]])( + 'rejects malformed workflowId %j without a request', + async (workflowId) => { + const request = vi.spyOn(api, 'fetchApi') + await navigate({ workflowId }) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') + + expect(request).not.toHaveBeenCalled() + expect(useToast().toasts[0]?.title).toBe("Couldn't open this workflow") + expect(currentQuery()).toEqual({}) + } + ) + + it('rejects an empty workflowId while an older link is still stashed', async () => { + const request = vi.spyOn(api, 'fetchApi') + capturePreservedQuery(NAMESPACE, { workflowId: ID }, ['workflowId']) + await navigate({ workflowId: '' }) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') + + expect(request).not.toHaveBeenCalled() + expect(useToast().toasts[0]?.title).toBe("Couldn't open this workflow") + expect(currentQuery()).toEqual({}) + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBeUndefined() + expect(loader.hasLinkInFlight()).toBe(false) + }) + + it.for(['workspace', 'deployment'])( + 'keeps a stashed link until the %s navigation finishes', + async (namespace) => { + const request = vi.spyOn(api, 'fetchApi') + await navigate({ workflowId: ID, [namespace]: 'destination' }) + await navigate({}) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('pending') + + expect(request).not.toHaveBeenCalled() + expect(useToast().toasts).toEqual([]) + expect(useTelemetry()?.trackWorkflowLinkOpened).not.toHaveBeenCalled() + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(ID) + clearPreservedQuery(namespace) + serveFile() + + expect(await loader.openWorkflowLinkFromUrl(true)).toBe('opened') + expect(useTelemetry()?.trackWorkflowLinkOpened).toHaveBeenCalledTimes(1) + } + ) + + it('does nothing outside Cloud', async () => { + distribution.isCloud = false + const request = vi.spyOn(api, 'fetchApi') + await navigate({ workflowId: ID }) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('absent') + + expect(request).not.toHaveBeenCalled() + expect(currentQuery()).toEqual({ workflowId: ID }) + expect(useTelemetry()?.trackWorkflowLinkOpened).not.toHaveBeenCalled() + }) + + it.for([ + { + name: 'server error', + response: () => new Response(null, { status: 500 }) + }, + { name: 'invalid JSON', response: () => new Response('{') }, + { + name: 'a reply without a path', + response: () => Response.json({ size: 1, modified: MODIFIED_MS }) + }, + { + name: 'a path outside the workflows folder', + response: () => + Response.json({ + path: 'comfy.settings.json', + size: 1, + modified: MODIFIED_MS + }) + }, + { + name: 'a path that leaves the workflows folder', + response: () => + Response.json({ + path: 'workflows/../secrets.json', + size: 1, + modified: MODIFIED_MS + }) + } + ])( + 'reports $name as an opening error rather than a missing workflow', + async ({ response }) => { + vi.spyOn(api, 'fetchApi').mockResolvedValue(response()) + await navigate({ workflowId: ID }) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') + + expect(useWorkflowService().openWorkflow).not.toHaveBeenCalled() + expect(useToast().toasts[0]?.title).toBe( + "Couldn't open this workflow. Please try again." + ) + expect(reportError).toHaveBeenCalledWith( + expect.any(Error), + expect.objectContaining({ + errorType: 'error_loading_workflow_link' + }) + ) + expect( + useTelemetry()?.trackWorkflowLinkOpened + ).toHaveBeenCalledExactlyOnceWith({ + outcome: 'error', + workspace_id: 'workspace-1' + }) + } + ) + + it.for([ + { + name: 'the linked file cannot be read', + fail: () => { + serveFile('workflows/Customer Jane Doe.json') + vi.mocked(useWorkflowService().openWorkflow).mockRejectedValue( + new Error( + "Failed to load file 'workflows/Customer Jane Doe.json': 500 Internal Server Error" + ) + ) + }, + reported: new Error('Could not open workflow link'), + errorType: 'error_opening_workflow_link', + errorName: 'Error' + }, + { + name: 'the lookup reply is not JSON', + fail: () => { + vi.spyOn(api, 'fetchApi').mockResolvedValue( + new Response('workflows/Customer Jane Doe.json') + ) + }, + reported: new Error('Could not read workflow link'), + errorType: 'error_loading_workflow_link', + errorName: 'SyntaxError' + } + ])( + 'reports that $name without the file name or the error text', + async ({ fail, reported, errorType, errorName }) => { + fail() + await navigate({ workflowId: ID }) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') + + expect(reportError).toHaveBeenCalledExactlyOnceWith(reported, { + surface: 'graph', + errorType, + context: { error_name: errorName } + }) + expect(vi.mocked(reportError).mock.calls[0]?.[0]).not.toHaveProperty( + 'cause' + ) + } + ) + + it('keeps the intent if the workspace changes during the lookup', async () => { + vi.spyOn(api, 'fetchApi').mockImplementation(async () => { + Object.assign(useTeamWorkspaceStore(), { + activeWorkspaceId: 'workspace-2' + }) + return new Response(null, { status: 404 }) + }) + await navigate({ workflowId: ID }) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('pending') + + expect(currentQuery().workflowId).toBe(ID) + expect(useToast().toasts).toEqual([]) + expect(useTelemetry()?.trackWorkflowLinkOpened).not.toHaveBeenCalled() + }) + + it('leaves a link the browser navigated to while an earlier lookup waited', async () => { + const respond = holdLookup() + await navigate({ workflowId: ID }) + vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(true) + + const attempt = loader.openWorkflowLinkFromUrl() + await navigate({ workflowId: NEXT_ID }) + respond() + + expect(await attempt).toBe('pending') + expect(useWorkflowService().openWorkflow).not.toHaveBeenCalled() + expect(currentQuery()).toEqual({ workflowId: NEXT_ID }) + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(NEXT_ID) + expect(useToast().toasts).toEqual([]) + expect(useTelemetry()?.trackWorkflowLinkOpened).not.toHaveBeenCalled() + }) + + it('opens and clears nothing when the editor unmounts while the lookup waits', async () => { + const respond = holdLookup() + await navigate({ workflowId: ID }) + vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(true) + + const attempt = loader.openWorkflowLinkFromUrl() + scope.stop() + respond() + + expect(await attempt).toBe('pending') + expect(useWorkflowService().openWorkflow).not.toHaveBeenCalled() + expect(currentQuery()).toEqual({ workflowId: ID }) + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(ID) + expect(useToast().toasts).toEqual([]) + expect(useTelemetry()?.trackWorkflowLinkOpened).not.toHaveBeenCalled() + }) + + it.for([ + { + name: 'finished navigating to a newer link', + newer: { workflowId: NEXT_ID }, + route: NEXT_ID, + stash: NEXT_ID + }, + { + name: 'navigated elsewhere with the same link', + newer: { workflowId: ID, keep: 'yes' }, + route: ID, + stash: ID + } + ])( + 'leaves the link when the browser $name while an opened link cleared the URL', + async ({ newer, route, stash }) => { + serveFile() + await navigate({ workflowId: ID }) + vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(true) + const cleanup = holdNavigation(isUrlCleanup) + + const attempt = loader.openWorkflowLinkFromUrl(true) + await cleanup.arrived + await navigate(newer) + cleanup.release() + + expect(await attempt).toBe('opened') + expect(currentQuery().workflowId).toBe(route) + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(stash) + expect( + useTelemetry()?.trackWorkflowLinkOpened + ).toHaveBeenCalledExactlyOnceWith({ + outcome: 'opened', + workspace_id: 'workspace-1' + }) + } + ) + + it('leaves a newer link a navigation guard holds while an opened link cleared the URL', async () => { + serveFile() + await navigate({ workflowId: ID }) + vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(true) + const cleanup = holdNavigation(isUrlCleanup) + const signIn = holdNavigation(isNewerLink) + + const attempt = loader.openWorkflowLinkFromUrl(true) + await cleanup.arrived + const newerLink = navigate({ workflowId: NEXT_ID }) + await signIn.arrived + cleanup.release() + + expect(await attempt).toBe('opened') + expect(currentQuery()).toEqual({ workflowId: ID }) + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(NEXT_ID) + signIn.release() + await newerLink + expect(currentQuery()).toEqual({ workflowId: NEXT_ID }) + }) + + it('keeps a boot link opened when another navigation cancels its URL cleanup, and clears it later without reopening', async () => { + serveFile() + await navigate({ workflowId: ID }) + const { store } = await openExistingTab() + vi.mocked(useWorkflowService().openWorkflow).mockImplementation( + async (workflow) => { + await store.openWorkflow(workflow) + return true + } + ) + const cleanup = holdNavigation(isUrlCleanup) + const linkedLoader = inApp(useLinkedWorkflowUrlLoader) + + const boot = linkedLoader.openLinkedWorkflowFromUrl() + await cleanup.arrived + await navigate({ workflowId: ID, keep: 'yes' }) + cleanup.release() + + expect(await boot).toBe('opened') + expect(store.activeWorkflow?.path).toBe(PATH) + expect(currentQuery()).toEqual({ workflowId: ID, keep: 'yes' }) + + expect(await loader.openWorkflowLinkFromUrl(true)).toBe('opened') + + expect(useWorkflowService().openWorkflow).toHaveBeenCalledOnce() + expect(store.activeWorkflow?.path).toBe(PATH) + expect(currentQuery()).toEqual({ keep: 'yes' }) + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBeUndefined() + expect(useTelemetry()?.trackWorkflowLinkOpened).toHaveBeenCalledTimes(1) + }) + + it('runs the URL actions without another replace while a newer link waits in a navigation guard', async () => { + serveFile() + await navigate({ workflowId: ID }) + vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(true) + const replace = vi.spyOn(router, 'replace') + const cleanup = holdNavigation(isUrlCleanup) + const signIn = holdNavigation(isNewerLink) + + const actions = runUrlActions() + await cleanup.arrived + const newerLink = navigate({ workflowId: NEXT_ID }) + await signIn.arrived + cleanup.release() + await actions + + expect(useWorkflowService().openWorkflow).toHaveBeenCalledOnce() + expect(replace).toHaveBeenCalledOnce() + expect(currentQuery()).toEqual({ workflowId: ID }) + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(NEXT_ID) + signIn.release() + await newerLink + expect(currentQuery()).toEqual({ workflowId: NEXT_ID }) + }) + + it('lets a newer link held in a navigation guard land when the URL actions run after the boot link opened', async () => { + serveFile() + await navigate({ workflowId: ID }) + const { store } = await openExistingTab() + vi.mocked(useWorkflowService().openWorkflow).mockImplementation( + async (workflow) => { + await store.openWorkflow(workflow) + return true + } + ) + const replace = vi.spyOn(router, 'replace') + const cleanup = holdNavigation(isUrlCleanup) + const signIn = holdNavigation(isNewerLink) + const linkedLoader = inApp(useLinkedWorkflowUrlLoader) + + const boot = linkedLoader.openLinkedWorkflowFromUrl() + await cleanup.arrived + const newerLink = navigate({ workflowId: NEXT_ID }) + await signIn.arrived + cleanup.release() + expect(await boot).toBe('opened') + await runUrlActions() + signIn.release() + await newerLink + + expect(currentQuery()).toEqual({ workflowId: NEXT_ID }) + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(NEXT_ID) + expect(replace).toHaveBeenCalledOnce() + expect(useWorkflowService().openWorkflow).toHaveBeenCalledOnce() + expect(store.activeWorkflow?.path).toBe(PATH) + }) + + it('clears the other URL actions while a link from the stash waits for a workspace change', async () => { + vi.spyOn(api, 'fetchApi').mockImplementation(async () => { + Object.assign(useTeamWorkspaceStore(), { + activeWorkspaceId: 'workspace-2' + }) + return new Response(null, { status: 404 }) + }) + await navigate({ workflowId: ID }) + await navigate({ topup: '1' }) + const replace = vi.spyOn(router, 'replace') + + await runUrlActions() + + expect(replace).toHaveBeenCalledOnce() + expect(currentQuery()).toEqual({}) + expect(getPreservedQueryParam(NAMESPACE, 'workflowId')).toBe(ID) + expect(useTelemetry()?.trackWorkflowLinkOpened).not.toHaveBeenCalled() + }) + + it('reports an opening error when the sidebar file is not in the workflow list after a sync', async () => { + serveFile() + vi.mocked(api.listUserDataFullInfo).mockResolvedValue([]) + await navigate({ workflowId: ID }) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') + + expect(useWorkflowService().openWorkflow).not.toHaveBeenCalled() + expect(reportError).toHaveBeenCalledWith( + expect.any(Error), + expect.objectContaining({ + surface: 'graph', + errorType: 'error_opening_workflow_link' + }) + ) + }) + + it('keeps tabs unchanged when the sidebar file cannot be opened', async () => { + serveFile() + await navigate({ workflowId: ID }) + const { store, existing, active } = await openExistingTab() + vi.mocked(useWorkflowService().openWorkflow).mockResolvedValue(false) + + expect(await loader.openWorkflowLinkFromUrl()).toBe('failed') + + expect(store.activeWorkflow).toBe(active) + expect(store.openWorkflows).toEqual([existing]) + expect(useToast().toasts[0]?.title).toBe( + "Couldn't open this workflow. Please try again." + ) + }) +}) diff --git a/src/composables/useWorkflowLinkUrlLoader.ts b/src/composables/useWorkflowLinkUrlLoader.ts new file mode 100644 index 00000000000..3a6c4f6b014 --- /dev/null +++ b/src/composables/useWorkflowLinkUrlLoader.ts @@ -0,0 +1,356 @@ +import { + zErrorResponse, + zWorkflowSidebarFileResponse +} from '@comfyorg/ingest-types/zod' +import { createSharedComposable } from '@vueuse/core' +import { onScopeDispose } from 'vue' +import { useRoute, useRouter } from 'vue-router' +import { z } from 'zod' + +import { useToast } from '@/components/ui/toast/toastStore' +import { t } from '@/i18n' +import { isCloud } from '@/platform/distribution/types' +import { + clearPreservedQuery, + getPreservedQueryParam, + hydratePreservedQuery, + mergePreservedQueryIntoQuery +} from '@/platform/navigation/preservedQueryManager' +import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQueryNamespaces' +import { useTelemetry } from '@/platform/telemetry' +import { reportError } from '@/platform/telemetry/reportError' +import type { + WorkflowLinkOpenedMetadata, + WorkflowLinkOutOfSyncReason +} from '@/platform/telemetry/types' +import { useWorkflowService } from '@/platform/workflow/core/services/workflowService' +import { useWorkflowStore } from '@/platform/workflow/management/stores/workflowStore' +import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' +import { api } from '@/scripts/api' + +const NAMESPACE = PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID +const workflowIdSchema = z.uuid() +const outOfSyncReasonSchema = z.enum([ + 'no_sidebar_path', + 'name_ambiguous', + 'file_missing', + 'content_mismatch' +]) +const outOfSyncBodySchema = zErrorResponse.pick({ code: true, details: true }) + +type WorkflowLinkLoadStatus = 'absent' | 'pending' | 'opened' | 'failed' +type LinkOutcome = + | { kind: 'opened' } + | { kind: 'not_found' } + | { kind: 'out_of_sync'; reason: WorkflowLinkOutOfSyncReason } + | { kind: 'error' } +type ResolveOutcome = LinkOutcome | { kind: 'pending' } +type LookupResult = + | { kind: 'found'; path: string } + | Exclude +type LinkCarriers = { route: unknown; stash: string | undefined } +type Ownership = { + owns: () => boolean + unreplaced: () => boolean +} + +function isWorkflowId(value: unknown): value is string { + return typeof value === 'string' && workflowIdSchema.safeParse(value).success +} + +function isSameLink(carried: unknown, workflowId: unknown): boolean { + return ( + carried === workflowId || + (!isWorkflowId(carried) && !isWorkflowId(workflowId)) + ) +} + +function failureContext(cause: unknown) { + return { error_name: cause instanceof Error ? cause.name : typeof cause } +} + +function isWorkflowPath(path: string): boolean { + return ( + path.startsWith('workflows/') && + path.endsWith('.json') && + !path.includes('\\') && + path + .split('/') + .every((part) => part !== '' && part !== '.' && part !== '..') + ) +} + +async function readOutOfSyncReason( + response: Response +): Promise { + const body: unknown = await response.json().catch(() => undefined) + const parsed = outOfSyncBodySchema.safeParse(body) + if (!parsed.success || parsed.data.code !== 'WORKFLOW_OUT_OF_SYNC') + return 'unknown' + const reason = outOfSyncReasonSchema.safeParse(parsed.data.details?.reason) + return reason.success ? reason.data : 'unknown' +} + +async function readLookupResponse(response: Response): Promise { + if (response.status === 404) return { kind: 'not_found' } + if (response.status === 409) + return { kind: 'out_of_sync', reason: await readOutOfSyncReason(response) } + if (!response.ok) { + reportError(new Error('Workflow link lookup failed'), { + surface: 'graph', + errorType: 'error_loading_workflow_link', + context: { status: response.status } + }) + return { kind: 'error' } + } + const body: unknown = await response.json() + const parsed = zWorkflowSidebarFileResponse.safeParse(body) + if (!parsed.success || !isWorkflowPath(parsed.data.path)) { + reportError(new Error('Invalid workflow link lookup response'), { + surface: 'graph', + errorType: 'error_loading_workflow_link' + }) + return { kind: 'error' } + } + return { kind: 'found', path: parsed.data.path } +} + +async function lookupSidebarFile(workflowId: string): Promise { + try { + const response = await api.fetchApi(`/workflows/${workflowId}/sidebar-file`) + return await readLookupResponse(response) + } catch (cause) { + reportError(new Error('Could not read workflow link'), { + surface: 'graph', + errorType: 'error_loading_workflow_link', + context: failureContext(cause) + }) + return { kind: 'error' } + } +} + +function navigationPending(query: Record): boolean { + return [ + PRESERVED_QUERY_NAMESPACES.WORKSPACE, + PRESERVED_QUERY_NAMESPACES.DEPLOYMENT + ].some( + (namespace) => + namespace in query || + getPreservedQueryParam(namespace, namespace) !== undefined + ) +} + +function toTelemetry( + outcome: LinkOutcome, + workspaceId: string | null +): WorkflowLinkOpenedMetadata { + return outcome.kind === 'out_of_sync' + ? { + outcome: 'out_of_sync', + reason: outcome.reason, + workspace_id: workspaceId + } + : { outcome: outcome.kind, workspace_id: workspaceId } +} + +function useWorkflowLinkUrlLoaderInternal() { + const route = useRoute() + const router = useRouter() + const workflowStore = useWorkflowStore() + const workspaceStore = useTeamWorkspaceStore() + const toast = useToast() + let completed: + | { + value: unknown + workspaceId: string | null + status: 'opened' | 'failed' + } + | undefined + const startedLinks = new Set() + let disposed = false + onScopeDispose(() => { + disposed = true + }) + + async function stripLinkFromUrl(): Promise { + if (!('workflowId' in route.query) && !('workflows' in route.query)) + return true + const query = { ...route.query } + delete query.workflowId + delete query.workflows + try { + return (await router.replace({ query })) === undefined + } catch (cause) { + reportError(new Error('Could not clear workflow link'), { + surface: 'graph', + errorType: 'error_clearing_workflow_link', + context: failureContext(cause) + }) + return true + } + } + + async function clearOwnedIntent(ownership: Ownership) { + if (!ownership.owns()) return + hydratePreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKFLOWS) + if (!(await stripLinkFromUrl()) || !ownership.unreplaced()) return + clearPreservedQuery(NAMESPACE) + clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKFLOWS) + } + + async function openPath( + path: string, + isCurrent: () => boolean + ): Promise { + try { + await workflowStore.loadWorkflows() + if (!isCurrent()) return { kind: 'pending' } + let workflow = workflowStore.getWorkflowByPath(path) + if (!workflow) { + await workflowStore.syncWorkflows() + if (!isCurrent()) return { kind: 'pending' } + workflow = workflowStore.getWorkflowByPath(path) + } + if (!workflow) { + reportError( + new Error('Workflow link file is not in the workflow list'), + { + surface: 'graph', + errorType: 'error_opening_workflow_link' + } + ) + return { kind: 'error' } + } + const opened = await useWorkflowService().openWorkflow(workflow, { + isCurrent + }) + return opened ? { kind: 'opened' } : { kind: 'error' } + } catch (cause) { + reportError(new Error('Could not open workflow link'), { + surface: 'graph', + errorType: 'error_opening_workflow_link', + context: failureContext(cause) + }) + return { kind: 'error' } + } + } + + async function resolveLink( + value: unknown, + isCurrent: () => boolean + ): Promise { + if (!isWorkflowId(value)) return { kind: 'not_found' } + const result = await lookupSidebarFile(value) + if (!isCurrent()) return { kind: 'pending' } + return result.kind === 'found' ? openPath(result.path, isCurrent) : result + } + + function reportOutcome(outcome: LinkOutcome, workspaceId: string | null) { + if (outcome.kind !== 'opened') { + toast.error( + t( + outcome.kind === 'error' + ? 'toastMessages.linkedWorkflowLoadFailed' + : 'toastMessages.linkedWorkflowNotOpened' + ) + ) + } + useTelemetry()?.trackWorkflowLinkOpened(toTelemetry(outcome, workspaceId)) + } + + function linkQuery() { + hydratePreservedQuery(NAMESPACE) + return 'workflowId' in route.query + ? route.query + : (mergePreservedQueryIntoQuery(NAMESPACE, route.query) ?? route.query) + } + + function linkCarriers(): LinkCarriers { + return { + route: route.query.workflowId, + stash: getPreservedQueryParam(NAMESPACE, 'workflowId') + } + } + + function carriesOnly(workflowId: unknown): boolean { + const { route, stash } = linkCarriers() + return ( + (route === undefined || isSameLink(route, workflowId)) && + (stash === undefined || isSameLink(stash, workflowId)) + ) + } + + function hasLink(): boolean { + const current = linkCarriers() + return current.route !== undefined || current.stash !== undefined + } + + function attemptOwnership( + workflowId: unknown, + workspaceId: string | null + ): Ownership { + const unreplaced = () => + !disposed && + workspaceStore.activeWorkspaceId === workspaceId && + carriesOnly(workflowId) + return { owns: () => hasLink() && unreplaced(), unreplaced } + } + + function completedStatus(value: unknown, workspaceId: string | null) { + if ( + !completed || + completed.value !== value || + completed.workspaceId !== workspaceId + ) + return undefined + return completed.status + } + + async function openWorkflowLinkFromUrl( + afterNavigation = false + ): Promise { + if (!isCloud) return 'absent' + const query = linkQuery() + if (!('workflowId' in query)) return 'absent' + if (!afterNavigation && navigationPending(query)) return 'pending' + return settleLink(query.workflowId, workspaceStore.activeWorkspaceId) + } + + async function settleLink( + workflowId: unknown, + workspaceId: string | null + ): Promise { + startedLinks.add(workflowId) + const ownership = attemptOwnership(workflowId, workspaceId) + const priorStatus = completedStatus(workflowId, workspaceId) + if (priorStatus) { + await clearOwnedIntent(ownership) + return priorStatus + } + const outcome = await resolveLink(workflowId, ownership.owns) + if (outcome.kind === 'pending' || !ownership.owns()) return 'pending' + const status = outcome.kind === 'opened' ? 'opened' : 'failed' + completed = { value: workflowId, workspaceId, status } + await clearOwnedIntent(ownership) + reportOutcome(outcome, workspaceId) + return status + } + + function isLinkSettled(workflowId: unknown): boolean { + return ( + completedStatus(workflowId, workspaceStore.activeWorkspaceId) !== + undefined + ) + } + + function hasLinkInFlight(): boolean { + const { route, stash } = linkCarriers() + return stash !== undefined && stash !== route && !startedLinks.has(stash) + } + + return { openWorkflowLinkFromUrl, isLinkSettled, hasLinkInFlight } +} + +export const useWorkflowLinkUrlLoader = createSharedComposable( + useWorkflowLinkUrlLoaderInternal +) diff --git a/src/locales/en/main.json b/src/locales/en/main.json index 5e944b06364..984345dece9 100644 --- a/src/locales/en/main.json +++ b/src/locales/en/main.json @@ -2603,6 +2603,8 @@ "nothingToQueue": "Nothing to queue", "pleaseSelectOutputNodes": "Please select output nodes", "failedToQueue": "Failed to queue", + "linkedWorkflowNotOpened": "Couldn't open this workflow", + "linkedWorkflowLoadFailed": "Couldn't open this workflow. Please try again.", "failedToSaveDraft": "Failed to save workflow draft", "failedExecutionPathResolution": "Could not resolve path to selected nodes", "no3dScene": "No 3D scene to apply texture", diff --git a/src/platform/navigation/preservedQueryDefinitions.test.ts b/src/platform/navigation/preservedQueryDefinitions.test.ts index 802f4b8c04b..ed4f3653dc2 100644 --- a/src/platform/navigation/preservedQueryDefinitions.test.ts +++ b/src/platform/navigation/preservedQueryDefinitions.test.ts @@ -24,7 +24,8 @@ describe('PRESERVED_QUERY_DEFINITIONS', () => { [PRESERVED_QUERY_NAMESPACES.WORKSPACE, 'workspace'], [PRESERVED_QUERY_NAMESPACES.DEPLOYMENT, 'deployment'], [PRESERVED_QUERY_NAMESPACES.WORKFLOWS, 'workflows'], - [PRESERVED_QUERY_NAMESPACES.LOCAL_HANDOFF, 'from_local'] + [PRESERVED_QUERY_NAMESPACES.LOCAL_HANDOFF, 'from_local'], + [PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, 'workflowId'] ])('captures %s so a redirect cannot lose it', ([namespace, key]) => { expect(registered.get(namespace)).toContain(key) }) diff --git a/src/platform/navigation/preservedQueryDefinitions.ts b/src/platform/navigation/preservedQueryDefinitions.ts index ce6b53a2e2e..54691bcdd8f 100644 --- a/src/platform/navigation/preservedQueryDefinitions.ts +++ b/src/platform/navigation/preservedQueryDefinitions.ts @@ -9,6 +9,11 @@ import type { PreservedQueryDefinition } from '@/platform/navigation/preservedQu * belongs in this list too. */ export const PRESERVED_QUERY_DEFINITIONS: PreservedQueryDefinition[] = [ + { + namespace: PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + keys: ['workflowId'], + rejectRepeated: true + }, { namespace: PRESERVED_QUERY_NAMESPACES.TEMPLATE, keys: ['template', 'source', 'mode'] diff --git a/src/platform/navigation/preservedQueryNamespaces.ts b/src/platform/navigation/preservedQueryNamespaces.ts index 2d65e7cf041..955b2958d5d 100644 --- a/src/platform/navigation/preservedQueryNamespaces.ts +++ b/src/platform/navigation/preservedQueryNamespaces.ts @@ -13,5 +13,6 @@ export const PRESERVED_QUERY_NAMESPACES = { WORKSPACE: 'workspace', DEPLOYMENT: 'deployment', WORKFLOWS: 'workflows', - LOCAL_HANDOFF: 'local_handoff' + LOCAL_HANDOFF: 'local_handoff', + WORKFLOW_ID: 'workflowId' } as const diff --git a/src/platform/navigation/preservedQueryTracker.test.ts b/src/platform/navigation/preservedQueryTracker.test.ts index c0af29dcff6..3e1a3edabda 100644 --- a/src/platform/navigation/preservedQueryTracker.test.ts +++ b/src/platform/navigation/preservedQueryTracker.test.ts @@ -6,6 +6,8 @@ import { clearPreservedQuery, getPreservedQueryParam } from '@/platform/navigation/preservedQueryManager' +import { PRESERVED_QUERY_DEFINITIONS } from '@/platform/navigation/preservedQueryDefinitions' +import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQueryNamespaces' import { installPreservedQueryTracker } from '@/platform/navigation/preservedQueryTracker' const STRIPPED_NAMESPACE = 'test_strip' @@ -283,6 +285,29 @@ describe('installPreservedQueryTracker', () => { ) }) + it('clears a stale rejectRepeated value when the URL supplies an empty value', async () => { + const router = createTestRouter() + installPreservedQueryTracker(router, [rejectRepeatedDefinition]) + + await router.push('/?workspace=ws-team') + await router.push('/?workspace=') + + expect(router.currentRoute.value.fullPath).toBe('/?workspace=') + expect( + getPreservedQueryParam(REJECT_REPEATED_NAMESPACE, 'workspace') + ).toBeUndefined() + }) + + it('keeps a plain namespace stash when the URL supplies an empty value', async () => { + const router = createTestRouter() + installPreservedQueryTracker(router, [plainDefinition]) + + await router.push('/?plain_code=abc') + await router.push('/?plain_code=') + + expect(getPreservedQueryParam(PLAIN_NAMESPACE, 'plain_code')).toBe('abc') + }) + it('drops a bare param of a non-rejectRepeated namespace like any empty value', async () => { const router = createTestRouter() installPreservedQueryTracker(router, [ @@ -296,3 +321,23 @@ describe('installPreservedQueryTracker', () => { ).toBeUndefined() }) }) + +describe('installPreservedQueryTracker with the app definitions', () => { + beforeEach(() => clearPreservedQuery(PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID)) + + it('preserves a workflow-id link through sign-in and onboarding redirects', async () => { + const router = createTestRouter() + installPreservedQueryTracker(router, PRESERVED_QUERY_DEFINITIONS) + + await router.push('/?workflowId=82b98188-0c8f-41d2-9b91-617b9152b809') + await router.push('/login') + await router.push('/onboarding') + + expect( + getPreservedQueryParam( + PRESERVED_QUERY_NAMESPACES.WORKFLOW_ID, + 'workflowId' + ) + ).toBe('82b98188-0c8f-41d2-9b91-617b9152b809') + }) +}) diff --git a/src/platform/navigation/preservedQueryTracker.ts b/src/platform/navigation/preservedQueryTracker.ts index 193781cb031..378ec9c2923 100644 --- a/src/platform/navigation/preservedQueryTracker.ts +++ b/src/platform/navigation/preservedQueryTracker.ts @@ -28,7 +28,9 @@ export interface PreservedQueryDefinition { * becomes a bare `,`. Both are strings outside any real id's charset, so * they read back as invalid rather than resolving to one of several * colliding values or to "absent" (`capturePreservedQuery` itself drops a - * null/empty value as not worth capturing). + * null/empty value as not worth capturing). A key present with an empty + * value (`?key=`) clears the namespace's stash instead, so an older stashed + * value never stands in for the newer, empty one the URL carries. */ rejectRepeated?: true } @@ -53,6 +55,10 @@ function withAmbiguityMarked( return result } +function hasValue(value: LocationQuery[string] | undefined): boolean { + return (Array.isArray(value) ? value : [value]).some(Boolean) +} + export const installPreservedQueryTracker = ( router: Router, definitions: PreservedQueryDefinition[] @@ -73,6 +79,13 @@ export const installPreservedQueryTracker = ( const captureQuery = rejectRepeated ? withAmbiguityMarked(to.query, keys) : to.query + if ( + rejectRepeated && + !presentKeys.some((key) => hasValue(captureQuery[key])) + ) { + clearPreservedQuery(namespace) + return + } capturePreservedQuery(namespace, captureQuery, keys, { merge: stripAfterCapture }) diff --git a/src/platform/telemetry/TelemetryRegistry.test.ts b/src/platform/telemetry/TelemetryRegistry.test.ts index 5628c3e5d7f..d4d290eb655 100644 --- a/src/platform/telemetry/TelemetryRegistry.test.ts +++ b/src/platform/telemetry/TelemetryRegistry.test.ts @@ -276,6 +276,23 @@ describe('TelemetryRegistry', () => { expect(b.trackCheckoutJourneyEvent).toHaveBeenCalledExactlyOnceWith(event) }) + it('dispatches trackWorkflowLinkOpened to every supporting provider', () => { + const a: TelemetryProvider = { trackWorkflowLinkOpened: vi.fn() } + const b: TelemetryProvider = {} + const registry = new TelemetryRegistry() + registry.registerProvider(a) + registry.registerProvider(b) + + const metadata = { + outcome: 'out_of_sync' as const, + reason: 'content_mismatch' as const, + workspace_id: 'ws-1' + } + registry.trackWorkflowLinkOpened(metadata) + + expect(a.trackWorkflowLinkOpened).toHaveBeenCalledExactlyOnceWith(metadata) + }) + it('dispatches trackWidgetFavoriteToggled to every registered provider', () => { const a: TelemetryProvider = { trackWidgetFavoriteToggled: vi.fn() } const b: TelemetryProvider = { trackWidgetFavoriteToggled: vi.fn() } diff --git a/src/platform/telemetry/TelemetryRegistry.ts b/src/platform/telemetry/TelemetryRegistry.ts index 7dd3e5396ce..9777eda6573 100644 --- a/src/platform/telemetry/TelemetryRegistry.ts +++ b/src/platform/telemetry/TelemetryRegistry.ts @@ -93,6 +93,7 @@ import type { WidgetFavoriteToggledMetadata, WorkflowCreatedMetadata, WorkflowImportMetadata, + WorkflowLinkOpenedMetadata, WorkflowSavedMetadata, WorkspaceInviteFailedMetadata, WorkspaceInviteMetadata, @@ -330,6 +331,10 @@ export class TelemetryRegistry implements TelemetryDispatcher { this.dispatch((provider) => provider.trackWorkflowOpened?.(metadata)) } + trackWorkflowLinkOpened(metadata: WorkflowLinkOpenedMetadata): void { + this.dispatch((provider) => provider.trackWorkflowLinkOpened?.(metadata)) + } + trackWorkflowSaved(metadata: WorkflowSavedMetadata): void { this.dispatch((provider) => provider.trackWorkflowSaved?.(metadata)) } diff --git a/src/platform/telemetry/providers/cloud/PostHogTelemetryProvider.test.ts b/src/platform/telemetry/providers/cloud/PostHogTelemetryProvider.test.ts index 47dbcd9e426..80fa02229fb 100644 --- a/src/platform/telemetry/providers/cloud/PostHogTelemetryProvider.test.ts +++ b/src/platform/telemetry/providers/cloud/PostHogTelemetryProvider.test.ts @@ -183,6 +183,30 @@ describe('PostHogTelemetryProvider', () => { setLocation('') }) + it.for([ + { outcome: 'opened', workspace_id: 'workspace-1' }, + { outcome: 'not_found', workspace_id: 'workspace-1' }, + { outcome: 'error', workspace_id: null }, + { + outcome: 'out_of_sync', + reason: 'content_mismatch', + workspace_id: 'workspace-1' + } + ] as const)( + 'records the workflow-id link result $outcome with no workflow name, path or id', + async (metadata) => { + const provider = createProvider() + await vi.dynamicImportSettled() + + provider.trackWorkflowLinkOpened(metadata) + + expect(hoisted.mockCapture).toHaveBeenCalledExactlyOnceWith( + 'app:workflow_link_opened', + metadata + ) + } + ) + describe('initialization', () => { it('disables itself when posthog_project_token is not provided', async () => { const provider = createProvider({ posthog_project_token: undefined }) diff --git a/src/platform/telemetry/providers/cloud/PostHogTelemetryProvider.ts b/src/platform/telemetry/providers/cloud/PostHogTelemetryProvider.ts index aaab6249a7e..a7ad0e892d8 100644 --- a/src/platform/telemetry/providers/cloud/PostHogTelemetryProvider.ts +++ b/src/platform/telemetry/providers/cloud/PostHogTelemetryProvider.ts @@ -113,6 +113,7 @@ import type { WidgetFavoriteToggledMetadata, WorkflowCreatedMetadata, WorkflowImportMetadata, + WorkflowLinkOpenedMetadata, WorkflowSavedMetadata, WorkspaceInviteFailedMetadata, WorkspaceInviteMetadata @@ -703,6 +704,10 @@ export class PostHogTelemetryProvider implements TelemetryProvider { this.trackEvent(TelemetryEvents.WORKFLOW_OPENED, metadata) } + trackWorkflowLinkOpened(metadata: WorkflowLinkOpenedMetadata): void { + this.trackEvent(TelemetryEvents.WORKFLOW_LINK_OPENED, metadata) + } + trackWorkflowSaved(metadata: WorkflowSavedMetadata): void { this.trackEvent(TelemetryEvents.WORKFLOW_SAVED, metadata) } diff --git a/src/platform/telemetry/types.ts b/src/platform/telemetry/types.ts index d15fd652f85..f298d3708da 100644 --- a/src/platform/telemetry/types.ts +++ b/src/platform/telemetry/types.ts @@ -469,6 +469,24 @@ export interface EnterLinearMetadata { source?: string } +export type WorkflowLinkOutOfSyncReason = + | 'no_sidebar_path' + | 'name_ambiguous' + | 'file_missing' + | 'content_mismatch' + | 'unknown' + +export type WorkflowLinkOpenedMetadata = + | { + outcome: 'opened' | 'not_found' | 'error' + workspace_id: string | null + } + | { + outcome: 'out_of_sync' + reason: WorkflowLinkOutOfSyncReason + workspace_id: string | null + } + export interface WorkflowSavedMetadata { is_app: boolean is_new: boolean @@ -1567,6 +1585,7 @@ export interface TelemetryProvider { // Workflow management events trackWorkflowImported?(metadata: WorkflowImportMetadata): void trackWorkflowOpened?(metadata: WorkflowImportMetadata): void + trackWorkflowLinkOpened?(metadata: WorkflowLinkOpenedMetadata): void trackWorkflowSaved?(metadata: WorkflowSavedMetadata): void trackDefaultViewSet?(metadata: DefaultViewSetMetadata): void trackEnterLinear?(metadata: EnterLinearMetadata): void @@ -1764,6 +1783,7 @@ export const TelemetryEvents = { // Workflow Management WORKFLOW_IMPORTED: 'app:workflow_imported', WORKFLOW_OPENED: 'app:workflow_opened', + WORKFLOW_LINK_OPENED: 'app:workflow_link_opened', ENTER_LINEAR_MODE: 'app:app_mode_opened', SHARE_FLOW: 'app:share_flow', SHARE_LINK_OPENED: 'app:share_link_opened', @@ -1949,6 +1969,7 @@ export type TelemetryEventProperties = | EnterLinearMetadata | ShareFlowMetadata | ShareLinkOpenedMetadata + | WorkflowLinkOpenedMetadata | WorkflowSavedMetadata | DefaultViewSetMetadata | SubscriptionMetadata diff --git a/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.test.ts b/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.test.ts index 55e4fe40012..148f755a6d7 100644 --- a/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.test.ts +++ b/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.test.ts @@ -25,6 +25,7 @@ import { StorageKeys } from '@/platform/workflow/persistence/base/storageKeys' import * as storageIO from '@/platform/workflow/persistence/base/storageIO' import { useWorkflowDraftStoreV2 } from '@/platform/workflow/persistence/stores/workflowDraftStoreV2' import { useWorkflowPersistenceV2 } from './useWorkflowPersistenceV2' +import type { useWorkflowLinkUrlLoader } from '@/composables/useWorkflowLinkUrlLoader' const apiEvents: EventTarget = api @@ -62,6 +63,22 @@ vi.mock( }) ) +const workflowLinkUrlLoader = vi.hoisted(() => ({ + openWorkflowLinkFromUrl: vi.fn< + ReturnType['openWorkflowLinkFromUrl'] + >(async () => 'absent'), + isLinkSettled: vi.fn< + ReturnType['isLinkSettled'] + >(() => false), + hasLinkInFlight: vi.fn< + ReturnType['hasLinkInFlight'] + >(() => false) +})) + +vi.mock(import('@/composables/useWorkflowLinkUrlLoader'), () => ({ + useWorkflowLinkUrlLoader: () => workflowLinkUrlLoader +})) + const folderWorkflowsUrlLoader = vi.hoisted(() => ({ openFolderWorkflowsFromUrl: vi.fn(async () => false) })) @@ -853,6 +870,48 @@ describe('useWorkflowPersistenceV2', () => { ) }) + describe('a workflow-id link', () => { + it('defers Getting Started while a workflow-id link waits for navigation', async () => { + workflowLinkUrlLoader.openWorkflowLinkFromUrl.mockResolvedValue('pending') + vi.spyOn(useWorkflowStore(), 'loadWorkflows').mockResolvedValue() + + await expect( + mountWorkflowPersistence().initializeWorkflow() + ).resolves.toBe('url-intent') + }) + + it.for(['opened', 'failed', 'pending'] as const)( + 'does not fall back to a folder when the workflow-id link result is %s', + async (status) => { + workflowLinkUrlLoader.openWorkflowLinkFromUrl.mockResolvedValue(status) + vi.spyOn(useWorkflowStore(), 'loadWorkflows').mockResolvedValue() + const { initializeWorkflow } = mountWorkflowPersistence() + + await initializeWorkflow() + + expect( + folderWorkflowsUrlLoader.openFolderWorkflowsFromUrl + ).not.toHaveBeenCalled() + } + ) + + it('keeps restored tabs behind the linked workflow without replacing the active tab', async () => { + const store = useWorkflowStore() + vi.spyOn(store, 'loadWorkflows').mockResolvedValue() + const previous = store.createTemporary('Previous.json') + writeTabState([previous.path], 0) + workflowLinkUrlLoader.openWorkflowLinkFromUrl.mockResolvedValue('opened') + const { initializeWorkflow, restoreWorkflowTabsState } = + mountWorkflowPersistence() + + await initializeWorkflow() + await restoreWorkflowTabsState() + + expect(store.openWorkflows).toEqual([previous]) + expect(openWorkflowMock).not.toHaveBeenCalled() + }) + }) + describe('a link that names a workflows folder', () => { it('opens the folder instead of restoring the last workflow', async () => { const workflowStore = useWorkflowStore() diff --git a/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.ts b/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.ts index cd165415b36..9f4ee6cc76a 100644 --- a/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.ts +++ b/src/platform/workflow/persistence/composables/useWorkflowPersistenceV2.ts @@ -24,7 +24,7 @@ import { PRESERVED_QUERY_NAMESPACES } from '@/platform/navigation/preservedQuery import { isCloud } from '@/platform/distribution/types' import { LOCAL_HANDOFF_PARAM } from '@/platform/openOnCloud/localHandoffProtocol' import { useSettingStore } from '@/platform/settings/settingStore' -import { useFolderWorkflowsUrlLoader } from '@/platform/workflow/management/composables/useFolderWorkflowsUrlLoader' +import { useLinkedWorkflowUrlLoader } from '@/composables/useLinkedWorkflowUrlLoader' import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' import { useWorkflowService } from '@/platform/workflow/core/services/workflowService' import { @@ -57,8 +57,8 @@ export function useWorkflowPersistenceV2() { const router = useRouter() const sharedWorkflowUrlLoader = useSharedWorkflowUrlLoader() const templateUrlLoader = useTemplateUrlLoader() - const folderWorkflowsUrlLoader = useFolderWorkflowsUrlLoader() - let openedFolderWorkflows = false + const linkedWorkflowUrlLoader = useLinkedWorkflowUrlLoader() + let openedLinkedWorkflow = false const TEMPLATE_NAMESPACE = PRESERVED_QUERY_NAMESPACES.TEMPLATE const SHARE_NAMESPACE = PRESERVED_QUERY_NAMESPACES.SHARE const LOCAL_HANDOFF_NAMESPACE = PRESERVED_QUERY_NAMESPACES.LOCAL_HANDOFF @@ -299,7 +299,9 @@ export function useWorkflowPersistenceV2() { flags.openOnCloudEnabled && hasPreservedIntent(LOCAL_HANDOFF_NAMESPACE, LOCAL_HANDOFF_PARAM) - const resolveStartupOutcome = async (): Promise => { + const resolveStartupOutcome = async ( + workflowLinkPending = false + ): Promise => { if (settingStore.get('Comfy.TutorialCompleted')) { await comfyApp.loadGraphData() return 'restored' @@ -308,7 +310,8 @@ export function useWorkflowPersistenceV2() { await useWorkflowService().loadBlankWorkflow() await nextTick() discardStartupBlankDraft() - return hasSharedWorkflowIntent() || + return workflowLinkPending || + hasSharedWorkflowIntent() || hasTemplateUrlIntent() || hasLocalHandoffIntent() ? 'url-intent' @@ -328,12 +331,14 @@ export function useWorkflowPersistenceV2() { } const initializeWorkflow = async (): Promise => { - openedFolderWorkflows = - await folderWorkflowsUrlLoader.openFolderWorkflowsFromUrl() - if (openedFolderWorkflows) return 'restored' + const linkedWorkflow = + await linkedWorkflowUrlLoader.openLinkedWorkflowFromUrl() + const workflowLinkPending = linkedWorkflow === 'pending' + openedLinkedWorkflow = linkedWorkflow === 'opened' + if (openedLinkedWorkflow) return 'restored' if (!workflowPersistenceEnabled.value) { - return await resolveStartupOutcome() + return await resolveStartupOutcome(workflowLinkPending) } const isRestoreCurrent = await waitForRestoreIdentity() @@ -347,10 +352,12 @@ export function useWorkflowPersistenceV2() { if (!isRestoreCurrent()) return 'restored' const restored = await loadPreviousWorkflowFromStorage(isRestoreCurrent) if (!isRestoreCurrent()) return 'restored' - return restored ? 'restored' : await resolveStartupOutcome() + return restored + ? 'restored' + : await resolveStartupOutcome(workflowLinkPending) } catch (err) { console.error('Error loading previous workflow', err) - return await resolveStartupOutcome() + return await resolveStartupOutcome(workflowLinkPending) } } @@ -500,7 +507,7 @@ export function useWorkflowPersistenceV2() { }) tabStateRestored = true - if (openedFolderWorkflows) return + if (openedLinkedWorkflow) return const activePath = storedWorkflows[storedActiveIndex] const workflow = activePath