From 835c2f7cdd3977e837fb90e067be1be893fee587 Mon Sep 17 00:00:00 2001 From: Vinh Trinh Date: Thu, 17 Sep 2026 14:40:13 -0700 Subject: [PATCH 01/33] feat(workspace): a Release switcher under the workspace selector (FE-2434) A person on Comfy Cloud whose account is in the rollout sees, under the workspace selector in the user popover, which developer-platform Release this browser runs its jobs on ("Running on: Comfy Cloud" or the Build's name and version), and can pick another one of the workspace's Releases or go back to Comfy Cloud. A pick or a clear reloads the editor, since what changes is what the editor is served at boot: the Release's node catalog and its packs' JavaScript. Nodes the picked Release lacks then surface through the existing missing-nodes dialog when the workflow loads, and a submit still answers with the server's own message. The switcher renders nothing until the listing has answered and when the account is outside the rollout (the route answers 403), so nobody sees a control they cannot use. A Release with no live deployment is listed but disabled, with the reason as its title; a refused pick shows the server's message as a toast and reloads nothing. Backend contract: GET /api/workspaces/{id}/releases (cloud#9645) for the list and the current pick, PUT and DELETE /api/workspaces/{id}/release (cloud#9390) for the pick. The pick itself is an HttpOnly cookie the editor never reads. --- src/locales/en/main.json | 14 ++ src/platform/workspace/api/workspaceApi.ts | 60 +++++ .../CurrentUserPopoverWorkspace.vue | 5 + .../components/ReleaseSwitcher.stories.ts | 132 ++++++++++ .../components/ReleaseSwitcher.test.ts | 206 ++++++++++++++++ .../workspace/components/ReleaseSwitcher.vue | 226 ++++++++++++++++++ .../workspace/releasePickState.test.ts | 79 ++++++ src/platform/workspace/releasePickState.ts | 68 ++++++ .../workspace/stores/releasePickStore.test.ts | 190 +++++++++++++++ .../workspace/stores/releasePickStore.ts | 112 +++++++++ 10 files changed, 1092 insertions(+) create mode 100644 src/platform/workspace/components/ReleaseSwitcher.stories.ts create mode 100644 src/platform/workspace/components/ReleaseSwitcher.test.ts create mode 100644 src/platform/workspace/components/ReleaseSwitcher.vue create mode 100644 src/platform/workspace/releasePickState.test.ts create mode 100644 src/platform/workspace/releasePickState.ts create mode 100644 src/platform/workspace/stores/releasePickStore.test.ts create mode 100644 src/platform/workspace/stores/releasePickStore.ts diff --git a/src/locales/en/main.json b/src/locales/en/main.json index 47e427dafd4..102ef988cdc 100644 --- a/src/locales/en/main.json +++ b/src/locales/en/main.json @@ -3866,6 +3866,20 @@ "managedByOrganization": "Your organization manages your workspaces, so you can't create one.", "failedToSwitch": "Failed to switch workspace" }, + "releaseSwitcher": { + "runningOn": "Running on", + "comfyCloud": "Comfy Cloud", + "comfyCloudCaption": "Comfy's own node set", + "release": "{build} v{version}", + "unnamedRelease": "Release {id}", + "deployedAs": "Deployed, {status}", + "notDeployed": "Not deployed", + "notDeployedTooltip": "Deploy this Release on the Developer Platform first.", + "noReleases": "This workspace has no Releases yet.", + "buildsHidden": "Build names are not visible to this account.", + "reloadNote": "The editor reloads to show the Release's nodes.", + "failedToSwitch": "Could not switch" + }, "selectionToolbox": { "executeButton": { "tooltip": "Execute to selected output nodes (Highlighted with orange border)", diff --git a/src/platform/workspace/api/workspaceApi.ts b/src/platform/workspace/api/workspaceApi.ts index 2ddf2200a95..7d749331622 100644 --- a/src/platform/workspace/api/workspaceApi.ts +++ b/src/platform/workspace/api/workspaceApi.ts @@ -21,6 +21,7 @@ import type { PaymentPortalRequest, PaymentPortalResponse, PendingInvite, + PickWorkspaceReleaseRequest, Plan, PreviewSubscribeRequest, PreviewSubscribeResponse, @@ -40,6 +41,8 @@ import type { TeamCreditStops, TeamCreditStopSummary, UpdateWorkspaceRequest, + WorkspaceRelease, + WorkspaceReleaseList, WorkspaceWithRole } from '@comfyorg/ingest-types' import { @@ -96,6 +99,8 @@ export type { SubscriptionDuration } export type { WorkspaceWithRole } export type { ListWorkspacesResponse } export type { CurrentWorkspaceResponse } +export type { WorkspaceRelease } +export type { WorkspaceReleaseList } export type { Plan } export type { BillingPlansResponse } export type { TeamCreditStops } @@ -306,6 +311,61 @@ export const workspaceApi = { } }, + /** + * List the developer-platform Releases this browser may pick, and which + * one it picked. 403 when the account is outside the rollout. + * GET /api/workspaces/:id/releases + */ + async listReleases(workspaceId: WorkspaceId): Promise { + const headers = await getAuthHeaderOrThrow() + try { + const response = await workspaceApiClient.get( + workspaceApiUrl(`/workspaces/${workspaceId}/releases`), + { headers } + ) + return response.data + } catch (err) { + handleAxiosError(err) + } + }, + + /** + * Pick the Release this browser runs on. The pick is a cookie on the + * response; nothing about the workspace changes. + * PUT /api/workspaces/:id/release + */ + async pickRelease( + workspaceId: WorkspaceId, + payload: PickWorkspaceReleaseRequest + ): Promise { + const headers = await getAuthHeaderOrThrow() + try { + await workspaceApiClient.put( + workspaceApiUrl(`/workspaces/${workspaceId}/release`), + payload, + { headers } + ) + } catch (err) { + handleAxiosError(err) + } + }, + + /** + * Clear the pick; this browser runs on Comfy Cloud again. + * DELETE /api/workspaces/:id/release + */ + async clearRelease(workspaceId: WorkspaceId): Promise { + const headers = await getAuthHeaderOrThrow() + try { + await workspaceApiClient.delete( + workspaceApiUrl(`/workspaces/${workspaceId}/release`), + { headers } + ) + } catch (err) { + handleAxiosError(err) + } + }, + /** * Delete a workspace (owner only) * DELETE /api/workspaces/:id diff --git a/src/platform/workspace/components/CurrentUserPopoverWorkspace.vue b/src/platform/workspace/components/CurrentUserPopoverWorkspace.vue index b377a4f7fa1..3521418d80d 100644 --- a/src/platform/workspace/components/CurrentUserPopoverWorkspace.vue +++ b/src/platform/workspace/components/CurrentUserPopoverWorkspace.vue @@ -88,6 +88,10 @@ + + +
@@ -262,6 +266,7 @@ import { useI18n } from 'vue-i18n' import { formatCreditsFromCents } from '@/base/credits/comfyCredits' import UserAvatar from '@/components/common/UserAvatar.vue' import WorkspaceProfilePic from '@/platform/workspace/components/WorkspaceProfilePic.vue' +import ReleaseSwitcher from '@/platform/workspace/components/ReleaseSwitcher.vue' import WorkspaceSwitcherPopover from '@/platform/workspace/components/WorkspaceSwitcherPopover.vue' import Button from '@/components/ui/button/Button.vue' import Skeleton from '@/components/ui/skeleton/Skeleton.vue' diff --git a/src/platform/workspace/components/ReleaseSwitcher.stories.ts b/src/platform/workspace/components/ReleaseSwitcher.stories.ts new file mode 100644 index 00000000000..8f17e175f37 --- /dev/null +++ b/src/platform/workspace/components/ReleaseSwitcher.stories.ts @@ -0,0 +1,132 @@ +import type { Meta, StoryObj } from '@storybook/vue3-vite' + +import type { WorkspaceRelease } from '@/platform/workspace/api/workspaceApi' +import type { ReleasePickState } from '@/platform/workspace/releasePickState' +import { useReleasePickStore } from '@/platform/workspace/stores/releasePickStore' + +import ReleaseSwitcher from './ReleaseSwitcher.vue' + +/** + * The Release switcher under the workspace selector in the user popover: + * which developer-platform Release this browser runs its Cloud jobs on, and + * the list it may pick from. Each story seeds the store's state directly; the + * Storybook team-workspace stub has no active workspace, so the store never + * calls the listing route here. Click the trigger to open the panel. + */ +const meta: Meta = { + title: 'Components/ReleaseSwitcher', + component: ReleaseSwitcher, + tags: ['autodocs'], + parameters: { layout: 'centered' }, + decorators: [ + (story) => ({ + components: { story }, + template: + '
' + }) + ] +} + +export default meta +type Story = StoryObj + +const studioV2: WorkspaceRelease = { + release_id: '6f1c2b0e-3c4d-4e5f-8a9b-0c1d2e3f4a5b', + build_id: 'b-1', + build_name: 'Studio Build', + version: 2, + created_at: '2026-09-16T18:00:00Z', + deployed: true, + deployment_status: 'ready' +} + +const studioV1: WorkspaceRelease = { + release_id: '0a1b2c3d-4e5f-4a6b-8c7d-9e0f1a2b3c4d', + build_id: 'b-1', + build_name: 'Studio Build', + version: 1, + created_at: '2026-09-12T09:30:00Z', + deployed: false +} + +const experimentsV3: WorkspaceRelease = { + release_id: 'c0ffee00-1111-4222-8333-444455556666', + build_id: 'b-2', + build_name: 'Experiments', + version: 3, + created_at: '2026-09-15T12:00:00Z', + deployed: true, + deployment_status: 'stopped' +} + +// The store is seeded from a component's setup(), where the app's Pinia is +// injected; a story beforeEach runs before any component and has no active +// Pinia. +function seeded(state: ReleasePickState): Story { + return { + decorators: [ + (story) => ({ + components: { story }, + setup() { + useReleasePickStore().state = state + }, + template: '' + }) + ] + } +} + +/** Nothing picked: this browser runs on Comfy Cloud. */ +export const Default: Story = seeded({ + phase: 'ready', + releases: [studioV2, experimentsV3, studioV1], + pickedReleaseId: null, + buildsVisible: true +}) + +/** A Release picked; the trigger names it. */ +export const Picked: Story = seeded({ + phase: 'ready', + releases: [studioV2, experimentsV3, studioV1], + pickedReleaseId: studioV2.release_id, + buildsVisible: true +}) + +/** The listing has not answered yet. */ +export const Loading: Story = seeded({ phase: 'loading' }) + +/** The platform could not be asked; the server's message is shown. */ +export const Unavailable: Story = seeded({ + phase: 'unavailable', + message: 'could not list releases from comfy-deploy; try again' +}) + +/** A workspace with no Releases yet. */ +export const Empty: Story = seeded({ + phase: 'ready', + releases: [], + pickedReleaseId: null, + buildsVisible: true +}) + +/** + * comfy-builder refused the caller (its routes sit behind the Builds beta): + * the deployed Releases are listed nameless, and the panel says why. + */ +export const BuildsHidden: Story = seeded({ + phase: 'ready', + releases: [ + { + release_id: studioV2.release_id, + deployed: true, + deployment_status: 'ready' + }, + { + release_id: experimentsV3.release_id, + deployed: true, + deployment_status: 'stopped' + } + ], + pickedReleaseId: studioV2.release_id, + buildsVisible: false +}) diff --git a/src/platform/workspace/components/ReleaseSwitcher.test.ts b/src/platform/workspace/components/ReleaseSwitcher.test.ts new file mode 100644 index 00000000000..d724fdf8521 --- /dev/null +++ b/src/platform/workspace/components/ReleaseSwitcher.test.ts @@ -0,0 +1,206 @@ +import { render, screen, waitFor } from '@testing-library/vue' +import userEvent from '@testing-library/user-event' +import { beforeEach, describe, expect, it, vi } from 'vitest' +import { createI18n } from 'vue-i18n' + +import type { WorkspaceReleaseList } from '@comfyorg/ingest-types' + +import enMessages from '@/locales/en/main.json' +import { useToastStore } from '@/platform/updates/common/toastStore' +import { WorkspaceApiError } from '@/platform/workspace/api/workspaceApi' +import { useReleasePickStore } from '@/platform/workspace/stores/releasePickStore' +import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' + +import ReleaseSwitcher from './ReleaseSwitcher.vue' + +const mockWorkspaceApi = vi.hoisted(() => ({ + listReleases: vi.fn(), + pickRelease: vi.fn(), + clearRelease: vi.fn() +})) + +vi.mock(import('@/platform/workspace/api/workspaceApi'), async () => { + class WorkspaceApiError extends Error { + constructor( + message: string, + public readonly status?: number, + public readonly code?: string + ) { + super(message) + this.name = 'WorkspaceApiError' + } + } + return { workspaceApi: mockWorkspaceApi, WorkspaceApiError } +}) + +const i18n = createI18n({ + legacy: false, + locale: 'en', + messages: { en: enMessages } +}) + +const listing: WorkspaceReleaseList = { + builds_visible: true, + releases: [ + { + release_id: 'aaaaaaaa-0000-4000-8000-000000000002', + build_id: 'b-1', + build_name: 'Studio Build', + version: 2, + deployed: true, + deployment_status: 'ready' + }, + { + release_id: 'aaaaaaaa-0000-4000-8000-000000000001', + build_id: 'b-1', + build_name: 'Studio Build', + version: 1, + deployed: false + }, + { + release_id: 'bbbbbbbb-0000-4000-8000-000000000009', + deployed: true, + deployment_status: 'stopped' + } + ] +} + +function renderSwitcher() { + return render(ReleaseSwitcher, { + global: { + plugins: [i18n] + } + }) +} + +describe('ReleaseSwitcher', () => { + const reload = vi.fn() + + beforeEach(() => { + Object.assign(useTeamWorkspaceStore(), { workspaceId: 'ws-1' }) + Object.defineProperty(window, 'location', { + value: { reload, origin: 'http://localhost' }, + writable: true, + configurable: true + }) + }) + + it('renders nothing when the account is outside the rollout', async () => { + mockWorkspaceApi.listReleases.mockRejectedValue( + new WorkspaceApiError('not enabled for this account yet', 403) + ) + renderSwitcher() + await waitFor(() => + expect(useReleasePickStore().state.phase).toBe('hidden') + ) + expect(mockWorkspaceApi.listReleases).toHaveBeenCalledWith('ws-1') + expect(screen.queryByTestId('release-switcher')).toBeNull() + }) + + it('says Comfy Cloud when nothing is picked, and lists the Releases', async () => { + mockWorkspaceApi.listReleases.mockResolvedValue(listing) + renderSwitcher() + + await waitFor(() => + expect(screen.getByTestId('release-switcher-current')).toHaveTextContent( + 'Comfy Cloud' + ) + ) + await userEvent.click(screen.getByTestId('release-switcher-trigger')) + + const panel = screen.getByTestId('release-switcher-panel') + expect(panel).toHaveTextContent('Studio Build v2') + expect(panel).toHaveTextContent('Deployed, ready') + expect(panel).toHaveTextContent('Studio Build v1') + expect(panel).toHaveTextContent('Not deployed') + expect(panel).toHaveTextContent('Release bbbbbbbb') + expect(screen.getByTestId('release-row-cloud')).toHaveAttribute( + 'aria-checked', + 'true' + ) + expect( + screen.getByTestId('release-row-aaaaaaaa-0000-4000-8000-000000000001') + ).toBeDisabled() + }) + + it('shows the picked Release by name', async () => { + mockWorkspaceApi.listReleases.mockResolvedValue({ + ...listing, + picked_release_id: 'aaaaaaaa-0000-4000-8000-000000000002' + }) + renderSwitcher() + await waitFor(() => + expect(screen.getByTestId('release-switcher-current')).toHaveTextContent( + 'Studio Build v2' + ) + ) + }) + + it('picks a deployed Release, which reloads the editor', async () => { + mockWorkspaceApi.listReleases.mockResolvedValue(listing) + mockWorkspaceApi.pickRelease.mockResolvedValue(undefined) + renderSwitcher() + await userEvent.click(await screen.findByTestId('release-switcher-trigger')) + + await userEvent.click( + screen.getByTestId('release-row-aaaaaaaa-0000-4000-8000-000000000002') + ) + + expect(mockWorkspaceApi.pickRelease).toHaveBeenCalledWith('ws-1', { + release_id: 'aaaaaaaa-0000-4000-8000-000000000002' + }) + await waitFor(() => expect(reload).toHaveBeenCalledOnce()) + }) + + it('goes back to Comfy Cloud through the clear route', async () => { + mockWorkspaceApi.listReleases.mockResolvedValue({ + ...listing, + picked_release_id: 'aaaaaaaa-0000-4000-8000-000000000002' + }) + mockWorkspaceApi.clearRelease.mockResolvedValue(undefined) + renderSwitcher() + await userEvent.click(await screen.findByTestId('release-switcher-trigger')) + + await userEvent.click(screen.getByTestId('release-row-cloud')) + + expect(mockWorkspaceApi.clearRelease).toHaveBeenCalledWith('ws-1') + await waitFor(() => expect(reload).toHaveBeenCalledOnce()) + }) + + it("shows the server's refusal as a toast and does not reload", async () => { + mockWorkspaceApi.listReleases.mockResolvedValue(listing) + mockWorkspaceApi.pickRelease.mockRejectedValue( + new WorkspaceApiError('release has no deployment; deploy it first', 422) + ) + renderSwitcher() + await userEvent.click(await screen.findByTestId('release-switcher-trigger')) + await userEvent.click( + screen.getByTestId('release-row-aaaaaaaa-0000-4000-8000-000000000002') + ) + + await waitFor(() => + expect(useToastStore().messagesToAdd).toContainEqual( + expect.objectContaining({ + severity: 'error', + detail: 'release has no deployment; deploy it first' + }) + ) + ) + expect(reload).not.toHaveBeenCalled() + expect(screen.queryByTestId('release-switcher-panel')).toBeNull() + }) + + it('shows why the list is unavailable', async () => { + mockWorkspaceApi.listReleases.mockRejectedValue( + new WorkspaceApiError( + 'could not list releases from comfy-deploy; try again', + 503 + ) + ) + renderSwitcher() + await userEvent.click(await screen.findByTestId('release-switcher-trigger')) + expect( + screen.getByTestId('release-switcher-unavailable') + ).toHaveTextContent('could not list releases from comfy-deploy; try again') + }) +}) diff --git a/src/platform/workspace/components/ReleaseSwitcher.vue b/src/platform/workspace/components/ReleaseSwitcher.vue new file mode 100644 index 00000000000..8c0a706bafb --- /dev/null +++ b/src/platform/workspace/components/ReleaseSwitcher.vue @@ -0,0 +1,226 @@ + + + + diff --git a/src/platform/workspace/releasePickState.test.ts b/src/platform/workspace/releasePickState.test.ts new file mode 100644 index 00000000000..68c897b7e40 --- /dev/null +++ b/src/platform/workspace/releasePickState.test.ts @@ -0,0 +1,79 @@ +import { describe, expect, it } from 'vitest' + +import type { WorkspaceRelease } from '@comfyorg/ingest-types' + +import type { ReleasePickEvent, ReleasePickState } from './releasePickState' +import { reduceReleasePick } from './releasePickState' + +const release: WorkspaceRelease = { + release_id: 'r-1', + build_name: 'Studio Build', + version: 1, + deployed: true, + deployment_status: 'ready' +} + +const loaded: ReleasePickEvent = { + type: 'loaded', + releases: [release], + pickedReleaseId: 'r-1', + buildsVisible: true +} + +const ready: ReleasePickState = { + phase: 'ready', + releases: [release], + pickedReleaseId: 'r-1', + buildsVisible: true +} + +describe('reduceReleasePick', () => { + it('loads into ready, or into hidden or unavailable when refused or failed', () => { + expect( + reduceReleasePick({ phase: 'idle' }, { type: 'loadStarted' }) + ).toEqual({ phase: 'loading' }) + expect(reduceReleasePick({ phase: 'loading' }, loaded)).toEqual(ready) + expect( + reduceReleasePick({ phase: 'loading' }, { type: 'loadRefused' }) + ).toEqual({ phase: 'hidden' }) + expect( + reduceReleasePick( + { phase: 'loading' }, + { type: 'loadFailed', message: 'comfy-deploy is down' } + ) + ).toEqual({ phase: 'unavailable', message: 'comfy-deploy is down' }) + }) + + it('switches only from ready, and a failed switch returns to ready', () => { + const switching = reduceReleasePick(ready, { + type: 'switchStarted', + target: null + }) + expect(switching).toEqual({ ...ready, phase: 'switching', target: null }) + expect(reduceReleasePick(switching, { type: 'switchFailed' })).toEqual( + ready + ) + + for (const state of [ + { phase: 'idle' }, + { phase: 'loading' }, + { phase: 'hidden' }, + { phase: 'unavailable', message: 'x' } + ] satisfies ReleasePickState[]) { + expect( + reduceReleasePick(state, { type: 'switchStarted', target: 'r-1' }) + ).toBe(state) + } + expect(reduceReleasePick(ready, { type: 'switchFailed' })).toBe(ready) + }) + + it('does not drop an in-flight switch for a reload of the list', () => { + const switching = reduceReleasePick(ready, { + type: 'switchStarted', + target: 'r-1' + }) + expect(reduceReleasePick(switching, { type: 'loadStarted' })).toBe( + switching + ) + }) +}) diff --git a/src/platform/workspace/releasePickState.ts b/src/platform/workspace/releasePickState.ts new file mode 100644 index 00000000000..ff8968f617a --- /dev/null +++ b/src/platform/workspace/releasePickState.ts @@ -0,0 +1,68 @@ +import type { WorkspaceRelease } from '@comfyorg/ingest-types' + +/** + * Which developer-platform Release this browser runs its Cloud jobs on, and + * the list it may pick from (FE-2434). The pick itself is an HttpOnly cookie + * ingest sets; the editor learns it from the listing and never reads it. + */ +export interface ReleaseListing { + releases: WorkspaceRelease[] + pickedReleaseId: string | null + buildsVisible: boolean +} + +export type ReleasePickState = + | { phase: 'idle' } + | { phase: 'loading' } + /** The account is outside the rollout, or the session cannot pick. */ + | { phase: 'hidden' } + | { phase: 'unavailable'; message: string } + | ({ phase: 'ready' } & ReleaseListing) + /** A pick or a clear is in flight; on success the page reloads. */ + | ({ phase: 'switching'; target: string | null } & ReleaseListing) + +export type ReleasePickEvent = + | { type: 'loadStarted' } + | ({ type: 'loaded' } & ReleaseListing) + | { type: 'loadRefused' } + | { type: 'loadFailed'; message: string } + | { type: 'switchStarted'; target: string | null } + | { type: 'switchFailed' } + +export function reduceReleasePick( + state: ReleasePickState, + event: ReleasePickEvent +): ReleasePickState { + switch (event.type) { + case 'loadStarted': + return state.phase === 'switching' ? state : { phase: 'loading' } + case 'loaded': + return { + phase: 'ready', + releases: event.releases, + pickedReleaseId: event.pickedReleaseId, + buildsVisible: event.buildsVisible + } + case 'loadRefused': + return { phase: 'hidden' } + case 'loadFailed': + return { phase: 'unavailable', message: event.message } + case 'switchStarted': + if (state.phase !== 'ready') return state + return { + phase: 'switching', + target: event.target, + releases: state.releases, + pickedReleaseId: state.pickedReleaseId, + buildsVisible: state.buildsVisible + } + case 'switchFailed': + if (state.phase !== 'switching') return state + return { + phase: 'ready', + releases: state.releases, + pickedReleaseId: state.pickedReleaseId, + buildsVisible: state.buildsVisible + } + } +} diff --git a/src/platform/workspace/stores/releasePickStore.test.ts b/src/platform/workspace/stores/releasePickStore.test.ts new file mode 100644 index 00000000000..0eb7688d4dd --- /dev/null +++ b/src/platform/workspace/stores/releasePickStore.test.ts @@ -0,0 +1,190 @@ +import { beforeEach, describe, expect, it, vi } from 'vitest' + +import type { WorkspaceReleaseList } from '@comfyorg/ingest-types' + +import { WorkspaceApiError } from '@/platform/workspace/api/workspaceApi' + +import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' + +import { useReleasePickStore } from './releasePickStore' + +const mockWorkspaceApi = vi.hoisted(() => ({ + listReleases: vi.fn(), + pickRelease: vi.fn(), + clearRelease: vi.fn() +})) + +vi.mock(import('@/platform/workspace/api/workspaceApi'), async () => { + class WorkspaceApiError extends Error { + constructor( + message: string, + public readonly status?: number, + public readonly code?: string + ) { + super(message) + this.name = 'WorkspaceApiError' + } + } + return { workspaceApi: mockWorkspaceApi, WorkspaceApiError } +}) + +const listing: WorkspaceReleaseList = { + builds_visible: true, + picked_release_id: 'r-2', + releases: [ + { + release_id: 'r-2', + build_id: 'b-1', + build_name: 'Studio Build', + version: 2, + deployed: true, + deployment_status: 'ready' + }, + { + release_id: 'r-1', + build_id: 'b-1', + build_name: 'Studio Build', + version: 1, + deployed: false + } + ] +} + +describe('useReleasePickStore', () => { + const reload = vi.fn() + + beforeEach(() => { + Object.assign(useTeamWorkspaceStore(), { workspaceId: 'ws-1' }) + Object.defineProperty(window, 'location', { + value: { reload, origin: 'http://localhost' }, + writable: true, + configurable: true + }) + }) + + it('loads the listing and knows which Release is picked', async () => { + mockWorkspaceApi.listReleases.mockResolvedValue(listing) + const store = useReleasePickStore() + expect(store.isVisible).toBe(false) + + await store.load() + + expect(mockWorkspaceApi.listReleases).toHaveBeenCalledWith('ws-1') + expect(store.state.phase).toBe('ready') + expect(store.isVisible).toBe(true) + expect(store.releases).toHaveLength(2) + expect(store.pickedReleaseId).toBe('r-2') + expect(store.pickedRelease?.build_name).toBe('Studio Build') + }) + + it('hides itself when the account is outside the rollout', async () => { + mockWorkspaceApi.listReleases.mockRejectedValue( + new WorkspaceApiError( + 'not enabled for this account yet', + 403, + 'FORBIDDEN' + ) + ) + const store = useReleasePickStore() + await store.load() + expect(store.state.phase).toBe('hidden') + expect(store.isVisible).toBe(false) + }) + + it('is unavailable, with the message, when the platform cannot be asked', async () => { + mockWorkspaceApi.listReleases.mockRejectedValue( + new WorkspaceApiError( + 'could not list releases from comfy-deploy; try again', + 503 + ) + ) + const store = useReleasePickStore() + await store.load() + expect(store.state).toEqual({ + phase: 'unavailable', + message: 'could not list releases from comfy-deploy; try again' + }) + expect(store.isVisible).toBe(true) + }) + + it('picks a Release and reloads the page', async () => { + mockWorkspaceApi.listReleases.mockResolvedValue(listing) + mockWorkspaceApi.pickRelease.mockResolvedValue(undefined) + const store = useReleasePickStore() + await store.load() + + await expect(store.pick('r-1')).resolves.toBeNull() + + expect(mockWorkspaceApi.pickRelease).toHaveBeenCalledWith('ws-1', { + release_id: 'r-1' + }) + expect(reload).toHaveBeenCalledOnce() + }) + + it('clears the pick for Comfy Cloud and reloads', async () => { + mockWorkspaceApi.listReleases.mockResolvedValue(listing) + mockWorkspaceApi.clearRelease.mockResolvedValue(undefined) + const store = useReleasePickStore() + await store.load() + + await expect(store.pick(null)).resolves.toBeNull() + + expect(mockWorkspaceApi.clearRelease).toHaveBeenCalledWith('ws-1') + expect(mockWorkspaceApi.pickRelease).not.toHaveBeenCalled() + expect(reload).toHaveBeenCalledOnce() + }) + + it('hands back a refused pick and stays ready, without reloading', async () => { + mockWorkspaceApi.listReleases.mockResolvedValue(listing) + mockWorkspaceApi.pickRelease.mockRejectedValue( + new WorkspaceApiError( + 'release r-1 has no deployment; deploy it first', + 422 + ) + ) + const store = useReleasePickStore() + await store.load() + + await expect(store.pick('r-1')).resolves.toBe( + 'release r-1 has no deployment; deploy it first' + ) + expect(store.state.phase).toBe('ready') + expect(store.pickedReleaseId).toBe('r-2') + expect(reload).not.toHaveBeenCalled() + }) + + it('picking the current Release is a no-op', async () => { + mockWorkspaceApi.listReleases.mockResolvedValue(listing) + const store = useReleasePickStore() + await store.load() + + await expect(store.pick('r-2')).resolves.toBeNull() + expect(mockWorkspaceApi.pickRelease).not.toHaveBeenCalled() + expect(reload).not.toHaveBeenCalled() + }) + + it('ignores a listing that arrives after the workspace changed', async () => { + let resolve: (value: WorkspaceReleaseList) => void = () => {} + mockWorkspaceApi.listReleases.mockReturnValue( + new Promise((r) => { + resolve = r + }) + ) + const store = useReleasePickStore() + const loading = store.load() + Object.assign(useTeamWorkspaceStore(), { workspaceId: 'ws-2' }) + resolve(listing) + await loading + + expect(store.state.phase).toBe('loading') + expect(store.releases).toEqual([]) + }) + + it('does nothing without an active workspace', async () => { + Object.assign(useTeamWorkspaceStore(), { workspaceId: null }) + const store = useReleasePickStore() + await store.load() + expect(mockWorkspaceApi.listReleases).not.toHaveBeenCalled() + expect(store.state.phase).toBe('idle') + }) +}) diff --git a/src/platform/workspace/stores/releasePickStore.ts b/src/platform/workspace/stores/releasePickStore.ts new file mode 100644 index 00000000000..a252c5f80ec --- /dev/null +++ b/src/platform/workspace/stores/releasePickStore.ts @@ -0,0 +1,112 @@ +import { defineStore } from 'pinia' +import { computed, shallowRef } from 'vue' + +import { + WorkspaceApiError, + workspaceApi +} from '@/platform/workspace/api/workspaceApi' +import type { + ReleasePickEvent, + ReleasePickState +} from '@/platform/workspace/releasePickState' +import { reduceReleasePick } from '@/platform/workspace/releasePickState' +import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' + +/** + * The Release this browser runs on and the Releases it may pick (FE-2434). + * + * A pick changes what the editor is served at boot (the Release's node + * catalog and its packs' JavaScript), so a successful pick or clear reloads + * the page rather than patching the running editor. + */ +export const useReleasePickStore = defineStore('releasePick', () => { + const workspaceStore = useTeamWorkspaceStore() + + const state = shallowRef({ phase: 'idle' }) + + function dispatch(event: ReleasePickEvent) { + state.value = reduceReleasePick(state.value, event) + } + + const releases = computed(() => + 'releases' in state.value ? state.value.releases : [] + ) + const pickedReleaseId = computed(() => + 'pickedReleaseId' in state.value ? state.value.pickedReleaseId : null + ) + const pickedRelease = computed( + () => + releases.value.find((r) => r.release_id === pickedReleaseId.value) ?? null + ) + const buildsVisible = computed(() => + 'buildsVisible' in state.value ? state.value.buildsVisible : true + ) + /** False until the listing has answered, and when the account cannot pick. */ + const isVisible = computed( + () => state.value.phase !== 'idle' && state.value.phase !== 'hidden' + ) + const isSwitching = computed(() => state.value.phase === 'switching') + + async function load(): Promise { + const id = workspaceStore.workspaceId + if (!id) return + dispatch({ type: 'loadStarted' }) + try { + const listing = await workspaceApi.listReleases(id) + if (workspaceStore.workspaceId !== id) return + dispatch({ + type: 'loaded', + releases: listing.releases, + pickedReleaseId: listing.picked_release_id ?? null, + buildsVisible: listing.builds_visible + }) + } catch (err) { + if (workspaceStore.workspaceId !== id) return + if (err instanceof WorkspaceApiError && err.status === 403) { + dispatch({ type: 'loadRefused' }) + return + } + dispatch({ type: 'loadFailed', message: errorMessage(err) }) + } + } + + /** + * Pick a Release for this browser, or null for Comfy Cloud, then reload so + * the editor boots on it. Resolves to the server's refusal, or null when + * the pick took (the page is reloading). + */ + async function pick(releaseId: string | null): Promise { + const id = workspaceStore.workspaceId + if (!id || state.value.phase !== 'ready') return null + if (releaseId === pickedReleaseId.value) return null + dispatch({ type: 'switchStarted', target: releaseId }) + try { + if (releaseId === null) { + await workspaceApi.clearRelease(id) + } else { + await workspaceApi.pickRelease(id, { release_id: releaseId }) + } + } catch (err) { + dispatch({ type: 'switchFailed' }) + return errorMessage(err) + } + window.location.reload() + return null + } + + return { + state, + releases, + pickedReleaseId, + pickedRelease, + buildsVisible, + isVisible, + isSwitching, + load, + pick + } +}) + +function errorMessage(err: unknown): string { + return err instanceof Error ? err.message : String(err) +} From a6ae63caf0a1a4c0761c9b1aaadd63e10ac5f9c8 Mon Sep 17 00:00:00 2001 From: Vinh Trinh Date: Mon, 28 Sep 2026 12:41:16 -0400 Subject: [PATCH 02/33] feat(workspace): the Release switcher shows the workspace default, and an owner sets it (BE-17480) The listing now says where the current pick came from (pick_source: browser or workspace_default) and which Release the workspace's owner set as its default. The switcher: - says "Workspace default" under the current Release when this browser has no pick of its own and follows it; - marks that Release in the list, and offers "Use the workspace default" to a browser that picked for itself (DELETE .../release?follow=workspace); - for an owner, a footer with the current default and "Set as workspace default" for the picked Release, or "Clear workspace default" (PUT/DELETE /api/workspaces/{id}/default-release). The page reloads only when the change alters what this browser runs on. Picking Comfy Cloud stays this browser's own choice: with a default set it still wins over the default until "Use the workspace default". --- src/locales/en/main.json | 10 +- src/platform/workspace/api/workspaceApi.ts | 50 ++++++- .../components/ReleaseSwitcher.stories.ts | 34 +++++ .../components/ReleaseSwitcher.test.ts | 104 ++++++++++++++- .../workspace/components/ReleaseSwitcher.vue | 124 ++++++++++++++++-- .../workspace/releasePickState.test.ts | 4 + src/platform/workspace/releasePickState.ts | 17 +++ .../workspace/stores/releasePickStore.test.ts | 120 ++++++++++++++++- .../workspace/stores/releasePickStore.ts | 94 ++++++++++++- 9 files changed, 537 insertions(+), 20 deletions(-) diff --git a/src/locales/en/main.json b/src/locales/en/main.json index 102ef988cdc..cade57f5cc8 100644 --- a/src/locales/en/main.json +++ b/src/locales/en/main.json @@ -3878,7 +3878,15 @@ "noReleases": "This workspace has no Releases yet.", "buildsHidden": "Build names are not visible to this account.", "reloadNote": "The editor reloads to show the Release's nodes.", - "failedToSwitch": "Could not switch" + "failedToSwitch": "Could not switch", + "workspaceDefault": "Workspace default", + "workspaceDefaultIs": "Workspace default: {release}", + "noWorkspaceDefault": "No workspace default: members start on Comfy Cloud.", + "followWorkspace": "Use the workspace default", + "followWorkspaceCaption": "Drop this browser's own pick and run on {release}", + "setAsDefault": "Set as workspace default", + "clearDefault": "Clear workspace default", + "failedToSetDefault": "Could not change the workspace default" }, "selectionToolbox": { "executeButton": { diff --git a/src/platform/workspace/api/workspaceApi.ts b/src/platform/workspace/api/workspaceApi.ts index 7d749331622..1582cd70948 100644 --- a/src/platform/workspace/api/workspaceApi.ts +++ b/src/platform/workspace/api/workspaceApi.ts @@ -351,14 +351,60 @@ export const workspaceApi = { }, /** - * Clear the pick; this browser runs on Comfy Cloud again. + * Clear the pick: this browser runs on Comfy Cloud, or with + * `follow: 'workspace'` on whatever the workspace says (its default + * Release, or Comfy Cloud when it has none). * DELETE /api/workspaces/:id/release */ - async clearRelease(workspaceId: WorkspaceId): Promise { + async clearRelease( + workspaceId: WorkspaceId, + options: { follow?: 'workspace' } = {} + ): Promise { const headers = await getAuthHeaderOrThrow() try { await workspaceApiClient.delete( workspaceApiUrl(`/workspaces/${workspaceId}/release`), + { + headers, + params: options.follow ? { follow: options.follow } : undefined + } + ) + } catch (err) { + handleAxiosError(err) + } + }, + + /** + * Set the Release members of the workspace run on when their browser has + * no pick of its own (BE-17480). Owner only. + * PUT /api/workspaces/:id/default-release + */ + async setDefaultRelease( + workspaceId: WorkspaceId, + payload: PickWorkspaceReleaseRequest + ): Promise { + const headers = await getAuthHeaderOrThrow() + try { + await workspaceApiClient.put( + workspaceApiUrl(`/workspaces/${workspaceId}/default-release`), + payload, + { headers } + ) + } catch (err) { + handleAxiosError(err) + } + }, + + /** + * Clear the workspace's default Release; members with no pick are back on + * Comfy Cloud. Owner only. + * DELETE /api/workspaces/:id/default-release + */ + async clearDefaultRelease(workspaceId: WorkspaceId): Promise { + const headers = await getAuthHeaderOrThrow() + try { + await workspaceApiClient.delete( + workspaceApiUrl(`/workspaces/${workspaceId}/default-release`), { headers } ) } catch (err) { diff --git a/src/platform/workspace/components/ReleaseSwitcher.stories.ts b/src/platform/workspace/components/ReleaseSwitcher.stories.ts index 8f17e175f37..59095f060cd 100644 --- a/src/platform/workspace/components/ReleaseSwitcher.stories.ts +++ b/src/platform/workspace/components/ReleaseSwitcher.stories.ts @@ -81,6 +81,8 @@ export const Default: Story = seeded({ phase: 'ready', releases: [studioV2, experimentsV3, studioV1], pickedReleaseId: null, + pickSource: null, + defaultReleaseId: null, buildsVisible: true }) @@ -89,6 +91,34 @@ export const Picked: Story = seeded({ phase: 'ready', releases: [studioV2, experimentsV3, studioV1], pickedReleaseId: studioV2.release_id, + pickSource: 'browser', + defaultReleaseId: null, + buildsVisible: true +}) + +/** + * An owner set a workspace default (BE-17480) and this browser has no pick + * of its own, so it follows it; the trigger says so. + */ +export const FollowingWorkspaceDefault: Story = seeded({ + phase: 'ready', + releases: [studioV2, experimentsV3, studioV1], + pickedReleaseId: studioV2.release_id, + pickSource: 'workspace_default', + defaultReleaseId: studioV2.release_id, + buildsVisible: true +}) + +/** + * This browser picked for itself while the workspace has a default: the + * panel offers the default as a row to go back to. + */ +export const OwnPickOverWorkspaceDefault: Story = seeded({ + phase: 'ready', + releases: [studioV2, experimentsV3, studioV1], + pickedReleaseId: experimentsV3.release_id, + pickSource: 'browser', + defaultReleaseId: studioV2.release_id, buildsVisible: true }) @@ -106,6 +136,8 @@ export const Empty: Story = seeded({ phase: 'ready', releases: [], pickedReleaseId: null, + pickSource: null, + defaultReleaseId: null, buildsVisible: true }) @@ -128,5 +160,7 @@ export const BuildsHidden: Story = seeded({ } ], pickedReleaseId: studioV2.release_id, + pickSource: 'browser', + defaultReleaseId: null, buildsVisible: false }) diff --git a/src/platform/workspace/components/ReleaseSwitcher.test.ts b/src/platform/workspace/components/ReleaseSwitcher.test.ts index d724fdf8521..db665216472 100644 --- a/src/platform/workspace/components/ReleaseSwitcher.test.ts +++ b/src/platform/workspace/components/ReleaseSwitcher.test.ts @@ -16,7 +16,9 @@ import ReleaseSwitcher from './ReleaseSwitcher.vue' const mockWorkspaceApi = vi.hoisted(() => ({ listReleases: vi.fn(), pickRelease: vi.fn(), - clearRelease: vi.fn() + clearRelease: vi.fn(), + setDefaultRelease: vi.fn(), + clearDefaultRelease: vi.fn() })) vi.mock(import('@/platform/workspace/api/workspaceApi'), async () => { @@ -190,6 +192,106 @@ describe('ReleaseSwitcher', () => { expect(screen.queryByTestId('release-switcher-panel')).toBeNull() }) + it('says it follows the workspace default, and marks that Release in the list', async () => { + mockWorkspaceApi.listReleases.mockResolvedValue({ + ...listing, + picked_release_id: 'aaaaaaaa-0000-4000-8000-000000000002', + pick_source: 'workspace_default', + default_release_id: 'aaaaaaaa-0000-4000-8000-000000000002' + }) + renderSwitcher() + await waitFor(() => + expect(screen.getByTestId('release-switcher-current')).toHaveTextContent( + 'Studio Build v2' + ) + ) + expect(screen.getByTestId('release-switcher-following')).toHaveTextContent( + 'Workspace default' + ) + await userEvent.click(screen.getByTestId('release-switcher-trigger')) + expect( + screen.getByTestId('release-row-aaaaaaaa-0000-4000-8000-000000000002') + ).toHaveTextContent('Workspace default') + expect(screen.queryByTestId('release-row-follow')).toBeNull() + expect(screen.queryByTestId('release-switcher-owner')).toBeNull() + }) + + it('offers a browser with its own pick the workspace default, which clears with follow=workspace', async () => { + mockWorkspaceApi.listReleases.mockResolvedValue({ + ...listing, + pick_source: 'browser', + default_release_id: 'aaaaaaaa-0000-4000-8000-000000000002' + }) + mockWorkspaceApi.clearRelease.mockResolvedValue(undefined) + renderSwitcher() + await userEvent.click(await screen.findByTestId('release-switcher-trigger')) + expect(screen.queryByTestId('release-switcher-following')).toBeNull() + + const follow = screen.getByTestId('release-row-follow') + expect(follow).toHaveTextContent('Studio Build v2') + await userEvent.click(follow) + + expect(mockWorkspaceApi.clearRelease).toHaveBeenCalledWith('ws-1', { + follow: 'workspace' + }) + await waitFor(() => expect(reload).toHaveBeenCalledOnce()) + }) + + it('lets an owner set the picked Release as the workspace default, and clear it', async () => { + Object.assign(useTeamWorkspaceStore(), { + workspaceId: 'ws-1', + activeWorkspace: { id: 'ws-1', role: 'owner' } + }) + mockWorkspaceApi.listReleases + .mockResolvedValueOnce({ + ...listing, + picked_release_id: 'aaaaaaaa-0000-4000-8000-000000000002', + pick_source: 'browser' + }) + .mockResolvedValue({ + ...listing, + picked_release_id: 'aaaaaaaa-0000-4000-8000-000000000002', + pick_source: 'browser', + default_release_id: 'aaaaaaaa-0000-4000-8000-000000000002' + }) + mockWorkspaceApi.setDefaultRelease.mockResolvedValue(undefined) + mockWorkspaceApi.clearDefaultRelease.mockResolvedValue(undefined) + renderSwitcher() + await userEvent.click(await screen.findByTestId('release-switcher-trigger')) + + const owner = screen.getByTestId('release-switcher-owner') + expect(owner).toHaveTextContent('No workspace default') + expect(screen.queryByTestId('release-switcher-clear-default')).toBeNull() + await userEvent.click(screen.getByTestId('release-switcher-set-default')) + + expect(mockWorkspaceApi.setDefaultRelease).toHaveBeenCalledWith('ws-1', { + release_id: 'aaaaaaaa-0000-4000-8000-000000000002' + }) + await waitFor(() => + expect(owner).toHaveTextContent('Workspace default: Studio Build v2') + ) + expect(reload).not.toHaveBeenCalled() + expect(screen.queryByTestId('release-switcher-set-default')).toBeNull() + + await userEvent.click(screen.getByTestId('release-switcher-clear-default')) + expect(mockWorkspaceApi.clearDefaultRelease).toHaveBeenCalledWith('ws-1') + }) + + it('shows a member the workspace default but no way to change it', async () => { + mockWorkspaceApi.listReleases.mockResolvedValue({ + ...listing, + picked_release_id: 'aaaaaaaa-0000-4000-8000-000000000002', + pick_source: 'browser', + default_release_id: 'bbbbbbbb-0000-4000-8000-000000000009' + }) + renderSwitcher() + await userEvent.click(await screen.findByTestId('release-switcher-trigger')) + expect(screen.queryByTestId('release-switcher-owner')).toBeNull() + expect(screen.getByTestId('release-row-follow')).toHaveTextContent( + 'Release bbbbbbbb' + ) + }) + it('shows why the list is unavailable', async () => { mockWorkspaceApi.listReleases.mockRejectedValue( new WorkspaceApiError( diff --git a/src/platform/workspace/components/ReleaseSwitcher.vue b/src/platform/workspace/components/ReleaseSwitcher.vue index 8c0a706bafb..5140ba35e0e 100644 --- a/src/platform/workspace/components/ReleaseSwitcher.vue +++ b/src/platform/workspace/components/ReleaseSwitcher.vue @@ -1,6 +1,9 @@ + popover; renders nothing while the account is outside the rollout. + Shows the workspace's default Release when an owner set one (BE-17480): + a browser with no pick of its own follows it, and an owner sets or + clears it from the panel's footer. -->
+
+ + {{ + defaultReleaseId === null + ? $t('releaseSwitcher.noWorkspaceDefault') + : $t('releaseSwitcher.workspaceDefaultIs', { + release: defaultLabel + }) + }} + +
+ + +
+
@@ -156,6 +232,10 @@ const { releases, pickedReleaseId, pickedRelease, + defaultReleaseId, + defaultRelease, + followsWorkspace, + canSetDefault, buildsVisible, isVisible, isSwitching @@ -196,13 +276,21 @@ function deploymentLabel(release: WorkspaceRelease): string { }) } -const currentLabel = computed(() => { - if (pickedReleaseId.value === null) return t('releaseSwitcher.comfyCloud') - if (pickedRelease.value) return releaseLabel(pickedRelease.value) - return t('releaseSwitcher.unnamedRelease', { - id: pickedReleaseId.value.slice(0, 8) - }) -}) +function labelFor( + releaseId: string | null, + release: WorkspaceRelease | null +): string { + if (releaseId === null) return t('releaseSwitcher.comfyCloud') + if (release) return releaseLabel(release) + return t('releaseSwitcher.unnamedRelease', { id: releaseId.slice(0, 8) }) +} + +const currentLabel = computed(() => + labelFor(pickedReleaseId.value, pickedRelease.value) +) +const defaultLabel = computed(() => + labelFor(defaultReleaseId.value, defaultRelease.value) +) function rowClass(current: boolean): string { return cn( @@ -212,15 +300,29 @@ function rowClass(current: boolean): string { ) } -async function choose(releaseId: string | null) { - const refusal = await store.pick(releaseId) +function report(summary: string, refusal: string | null) { if (refusal === null) return isOpen.value = false useToastStore().add({ severity: 'error', - summary: t('releaseSwitcher.failedToSwitch'), + summary, detail: refusal, life: 8000 }) } + +async function choose(releaseId: string | null) { + report(t('releaseSwitcher.failedToSwitch'), await store.pick(releaseId)) +} + +async function follow() { + report(t('releaseSwitcher.failedToSwitch'), await store.followWorkspace()) +} + +async function changeDefault(releaseId: string | null) { + report( + t('releaseSwitcher.failedToSetDefault'), + await store.setDefault(releaseId) + ) +} diff --git a/src/platform/workspace/releasePickState.test.ts b/src/platform/workspace/releasePickState.test.ts index 68c897b7e40..11d2bdde705 100644 --- a/src/platform/workspace/releasePickState.test.ts +++ b/src/platform/workspace/releasePickState.test.ts @@ -17,6 +17,8 @@ const loaded: ReleasePickEvent = { type: 'loaded', releases: [release], pickedReleaseId: 'r-1', + pickSource: 'browser', + defaultReleaseId: null, buildsVisible: true } @@ -24,6 +26,8 @@ const ready: ReleasePickState = { phase: 'ready', releases: [release], pickedReleaseId: 'r-1', + pickSource: 'browser', + defaultReleaseId: null, buildsVisible: true } diff --git a/src/platform/workspace/releasePickState.ts b/src/platform/workspace/releasePickState.ts index ff8968f617a..54ea797a077 100644 --- a/src/platform/workspace/releasePickState.ts +++ b/src/platform/workspace/releasePickState.ts @@ -5,9 +5,20 @@ import type { WorkspaceRelease } from '@comfyorg/ingest-types' * the list it may pick from (FE-2434). The pick itself is an HttpOnly cookie * ingest sets; the editor learns it from the listing and never reads it. */ +/** Where the current pick came from (BE-17480). */ +export type ReleasePickSource = 'browser' | 'workspace_default' + export interface ReleaseListing { releases: WorkspaceRelease[] pickedReleaseId: string | null + /** + * `browser` when this browser picked for itself (a Release, or Comfy + * Cloud); `workspace_default` when it follows the workspace's default + * Release; null when there is neither, so it runs on Comfy Cloud. + */ + pickSource: ReleasePickSource | null + /** The workspace's default Release an owner set, or null. */ + defaultReleaseId: string | null buildsVisible: boolean } @@ -41,6 +52,8 @@ export function reduceReleasePick( phase: 'ready', releases: event.releases, pickedReleaseId: event.pickedReleaseId, + pickSource: event.pickSource, + defaultReleaseId: event.defaultReleaseId, buildsVisible: event.buildsVisible } case 'loadRefused': @@ -54,6 +67,8 @@ export function reduceReleasePick( target: event.target, releases: state.releases, pickedReleaseId: state.pickedReleaseId, + pickSource: state.pickSource, + defaultReleaseId: state.defaultReleaseId, buildsVisible: state.buildsVisible } case 'switchFailed': @@ -62,6 +77,8 @@ export function reduceReleasePick( phase: 'ready', releases: state.releases, pickedReleaseId: state.pickedReleaseId, + pickSource: state.pickSource, + defaultReleaseId: state.defaultReleaseId, buildsVisible: state.buildsVisible } } diff --git a/src/platform/workspace/stores/releasePickStore.test.ts b/src/platform/workspace/stores/releasePickStore.test.ts index 0eb7688d4dd..7ef4ba4cbce 100644 --- a/src/platform/workspace/stores/releasePickStore.test.ts +++ b/src/platform/workspace/stores/releasePickStore.test.ts @@ -11,7 +11,9 @@ import { useReleasePickStore } from './releasePickStore' const mockWorkspaceApi = vi.hoisted(() => ({ listReleases: vi.fn(), pickRelease: vi.fn(), - clearRelease: vi.fn() + clearRelease: vi.fn(), + setDefaultRelease: vi.fn(), + clearDefaultRelease: vi.fn() })) vi.mock(import('@/platform/workspace/api/workspaceApi'), async () => { @@ -31,6 +33,7 @@ vi.mock(import('@/platform/workspace/api/workspaceApi'), async () => { const listing: WorkspaceReleaseList = { builds_visible: true, picked_release_id: 'r-2', + pick_source: 'browser', releases: [ { release_id: 'r-2', @@ -75,6 +78,121 @@ describe('useReleasePickStore', () => { expect(store.releases).toHaveLength(2) expect(store.pickedReleaseId).toBe('r-2') expect(store.pickedRelease?.build_name).toBe('Studio Build') + expect(store.pickSource).toBe('browser') + expect(store.followsWorkspace).toBe(false) + expect(store.defaultReleaseId).toBeNull() + expect(store.canSetDefault).toBe(false) + }) + + it('follows the workspace default when the browser has no pick of its own', async () => { + mockWorkspaceApi.listReleases.mockResolvedValue({ + ...listing, + pick_source: 'workspace_default', + default_release_id: 'r-2' + }) + const store = useReleasePickStore() + await store.load() + + expect(store.pickedReleaseId).toBe('r-2') + expect(store.pickSource).toBe('workspace_default') + expect(store.followsWorkspace).toBe(true) + expect(store.defaultReleaseId).toBe('r-2') + expect(store.defaultRelease?.version).toBe(2) + + // Already following: nothing to drop. + await expect(store.followWorkspace()).resolves.toBeNull() + expect(mockWorkspaceApi.clearRelease).not.toHaveBeenCalled() + + // Picking Comfy Cloud is this browser's own choice, even though nothing + // is "picked" yet: it goes through the clear route and reloads. + mockWorkspaceApi.clearRelease.mockResolvedValue(undefined) + await expect(store.pick(null)).resolves.toBeNull() + expect(mockWorkspaceApi.clearRelease).toHaveBeenCalledWith('ws-1') + expect(reload).toHaveBeenCalledOnce() + }) + + it('drops its own pick to follow the workspace, through the clear route with follow=workspace', async () => { + mockWorkspaceApi.listReleases.mockResolvedValue({ + ...listing, + picked_release_id: 'r-1', + default_release_id: 'r-2' + }) + mockWorkspaceApi.clearRelease.mockResolvedValue(undefined) + const store = useReleasePickStore() + await store.load() + + await expect(store.followWorkspace()).resolves.toBeNull() + + expect(mockWorkspaceApi.clearRelease).toHaveBeenCalledWith('ws-1', { + follow: 'workspace' + }) + expect(reload).toHaveBeenCalledOnce() + }) + + it('an owner sets the picked Release as the workspace default and the listing refreshes', async () => { + Object.assign(useTeamWorkspaceStore(), { + workspaceId: 'ws-1', + activeWorkspace: { id: 'ws-1', role: 'owner' } + }) + mockWorkspaceApi.listReleases + .mockResolvedValueOnce(listing) + .mockResolvedValueOnce({ ...listing, default_release_id: 'r-2' }) + mockWorkspaceApi.setDefaultRelease.mockResolvedValue(undefined) + const store = useReleasePickStore() + await store.load() + expect(store.canSetDefault).toBe(true) + + await expect(store.setDefault('r-2')).resolves.toBeNull() + + expect(mockWorkspaceApi.setDefaultRelease).toHaveBeenCalledWith('ws-1', { + release_id: 'r-2' + }) + expect(reload).not.toHaveBeenCalled() + expect(store.state.phase).toBe('ready') + expect(store.defaultReleaseId).toBe('r-2') + + // Clearing it, likewise; setting what is already set is a no-op. + await expect(store.setDefault('r-2')).resolves.toBeNull() + expect(mockWorkspaceApi.setDefaultRelease).toHaveBeenCalledOnce() + mockWorkspaceApi.listReleases.mockResolvedValueOnce(listing) + mockWorkspaceApi.clearDefaultRelease.mockResolvedValue(undefined) + await expect(store.setDefault(null)).resolves.toBeNull() + expect(mockWorkspaceApi.clearDefaultRelease).toHaveBeenCalledWith('ws-1') + expect(store.defaultReleaseId).toBeNull() + }) + + it('a browser that follows the workspace reloads when its owner changes the default', async () => { + mockWorkspaceApi.listReleases.mockResolvedValue({ + ...listing, + picked_release_id: undefined, + pick_source: undefined + }) + mockWorkspaceApi.setDefaultRelease.mockResolvedValue(undefined) + const store = useReleasePickStore() + await store.load() + expect(store.followsWorkspace).toBe(true) + + await expect(store.setDefault('r-2')).resolves.toBeNull() + expect(reload).toHaveBeenCalledOnce() + }) + + it("hands back the server's refusal of a default and stays ready", async () => { + mockWorkspaceApi.listReleases.mockResolvedValue(listing) + mockWorkspaceApi.setDefaultRelease.mockRejectedValue( + new WorkspaceApiError( + 'only a workspace owner can set the default release', + 403 + ) + ) + const store = useReleasePickStore() + await store.load() + + await expect(store.setDefault('r-1')).resolves.toBe( + 'only a workspace owner can set the default release' + ) + expect(store.state.phase).toBe('ready') + expect(store.defaultReleaseId).toBeNull() + expect(reload).not.toHaveBeenCalled() }) it('hides itself when the account is outside the rollout', async () => { diff --git a/src/platform/workspace/stores/releasePickStore.ts b/src/platform/workspace/stores/releasePickStore.ts index a252c5f80ec..cdc1a775c2c 100644 --- a/src/platform/workspace/stores/releasePickStore.ts +++ b/src/platform/workspace/stores/releasePickStore.ts @@ -7,13 +7,16 @@ import { } from '@/platform/workspace/api/workspaceApi' import type { ReleasePickEvent, + ReleasePickSource, ReleasePickState } from '@/platform/workspace/releasePickState' import { reduceReleasePick } from '@/platform/workspace/releasePickState' import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' /** - * The Release this browser runs on and the Releases it may pick (FE-2434). + * The Release this browser runs on and the Releases it may pick (FE-2434), + * plus the workspace's default Release an owner sets for members with no + * pick of their own (BE-17480). * * A pick changes what the editor is served at boot (the Release's node * catalog and its packs' JavaScript), so a successful pick or clear reloads @@ -38,6 +41,26 @@ export const useReleasePickStore = defineStore('releasePick', () => { () => releases.value.find((r) => r.release_id === pickedReleaseId.value) ?? null ) + const pickSource = computed(() => + 'pickSource' in state.value ? state.value.pickSource : null + ) + const defaultReleaseId = computed(() => + 'defaultReleaseId' in state.value ? state.value.defaultReleaseId : null + ) + const defaultRelease = computed( + () => + releases.value.find((r) => r.release_id === defaultReleaseId.value) ?? + null + ) + /** + * True when this browser has no pick of its own and so runs on whatever + * the workspace says: its default Release, or Comfy Cloud without one. + */ + const followsWorkspace = computed(() => pickSource.value !== 'browser') + /** Only a workspace owner may set or clear the default Release. */ + const canSetDefault = computed( + () => workspaceStore.activeWorkspace?.role === 'owner' + ) const buildsVisible = computed(() => 'buildsVisible' in state.value ? state.value.buildsVisible : true ) @@ -58,6 +81,8 @@ export const useReleasePickStore = defineStore('releasePick', () => { type: 'loaded', releases: listing.releases, pickedReleaseId: listing.picked_release_id ?? null, + pickSource: listing.pick_source ?? null, + defaultReleaseId: listing.default_release_id ?? null, buildsVisible: listing.builds_visible }) } catch (err) { @@ -73,12 +98,16 @@ export const useReleasePickStore = defineStore('releasePick', () => { /** * Pick a Release for this browser, or null for Comfy Cloud, then reload so * the editor boots on it. Resolves to the server's refusal, or null when - * the pick took (the page is reloading). + * the pick took (the page is reloading). Picking Comfy Cloud is this + * browser's own choice: with a workspace default set it still wins over + * the default, until `followWorkspace` drops it. */ async function pick(releaseId: string | null): Promise { const id = workspaceStore.workspaceId if (!id || state.value.phase !== 'ready') return null - if (releaseId === pickedReleaseId.value) return null + if (releaseId === pickedReleaseId.value && !followsWorkspace.value) { + return null + } dispatch({ type: 'switchStarted', target: releaseId }) try { if (releaseId === null) { @@ -94,16 +123,73 @@ export const useReleasePickStore = defineStore('releasePick', () => { return null } + /** + * Drop this browser's own pick so it runs on whatever the workspace says + * (its default Release, or Comfy Cloud), then reload. Resolves like `pick`. + */ + async function followWorkspace(): Promise { + const id = workspaceStore.workspaceId + if (!id || state.value.phase !== 'ready') return null + if (followsWorkspace.value) return null + dispatch({ type: 'switchStarted', target: defaultReleaseId.value }) + try { + await workspaceApi.clearRelease(id, { follow: 'workspace' }) + } catch (err) { + dispatch({ type: 'switchFailed' }) + return errorMessage(err) + } + window.location.reload() + return null + } + + /** + * Set the workspace's default Release (owner only), or clear it with null. + * Members with no pick of their own move to it at their next boot. This + * browser reloads only when it follows the workspace, since nothing else + * about what it runs on changed; otherwise the listing is refreshed. + * Resolves to the server's refusal, or null when the default took. + */ + async function setDefault(releaseId: string | null): Promise { + const id = workspaceStore.workspaceId + if (!id || state.value.phase !== 'ready') return null + if (releaseId === defaultReleaseId.value) return null + dispatch({ type: 'switchStarted', target: pickedReleaseId.value }) + try { + if (releaseId === null) { + await workspaceApi.clearDefaultRelease(id) + } else { + await workspaceApi.setDefaultRelease(id, { release_id: releaseId }) + } + } catch (err) { + dispatch({ type: 'switchFailed' }) + return errorMessage(err) + } + if (followsWorkspace.value) { + window.location.reload() + return null + } + dispatch({ type: 'switchFailed' }) + await load() + return null + } + return { state, releases, pickedReleaseId, pickedRelease, + pickSource, + defaultReleaseId, + defaultRelease, + followsWorkspace, + canSetDefault, buildsVisible, isVisible, isSwitching, load, - pick + pick, + followWorkspace, + setDefault } }) From 58b4e9c8cc595d0f246d756abf1746d036847a38 Mon Sep 17 00:00:00 2001 From: Vinh Trinh Date: Fri, 2 Oct 2026 13:55:26 -0400 Subject: [PATCH 03/33] refactor(workspace): the switcher picks a deployment, not a Release (FE-2434, BE-17480) A deployment keeps its URL while its owner updates it to new Releases (James Kwon's stable-URL TDD), so a Cloud pick names the deployment and follows those updates instead of being stranded on an old Release. - Rows are the workspace's deployments: Build name and the Release it runs now (deployment id when Build names are hidden), with id and status. - Routes: GET /deployments, PUT/DELETE /deployment, PUT/DELETE /default-deployment. - Renamed ReleaseSwitcher, releasePickStore and releasePickState to the Deployment names; i18n block releaseSwitcher -> deploymentSwitcher. - A stopped deployment is pickable; its status is shown. - The shared workspaceApi automock gains the five deployment methods. Typecheck still fails only on the WorkspaceDeployment, WorkspaceDeploymentList and PickWorkspaceDeploymentRequest imports, which resolve once the cloud merge regenerates @comfyorg/ingest-types. --- src/locales/en/main.json | 18 +- .../workspace/api/__mocks__/workspaceApi.ts | 5 + .../workspace/api/workspaceApi.test.ts | 71 ++ src/platform/workspace/api/workspaceApi.ts | 78 +- .../CurrentUserPopoverWorkspace.test.ts | 26 + .../CurrentUserPopoverWorkspace.vue | 11 +- .../components/DeploymentSwitcher.stories.ts | 161 ++++ .../components/DeploymentSwitcher.test.ts | 439 ++++++++++ .../components/DeploymentSwitcher.vue | 158 ++++ .../components/DeploymentSwitcherList.vue | 75 ++ .../DeploymentSwitcherOwnerFooter.vue | 62 ++ .../components/DeploymentSwitcherRow.vue | 36 + .../components/ReleaseSwitcher.stories.ts | 166 ---- .../components/ReleaseSwitcher.test.ts | 308 ------- .../workspace/components/ReleaseSwitcher.vue | 328 -------- .../composables/useDeploymentLabels.ts | 73 ++ .../workspace/deploymentPickState.test.ts | 176 ++++ src/platform/workspace/deploymentPickState.ts | 128 +++ .../workspace/releasePickState.test.ts | 83 -- src/platform/workspace/releasePickState.ts | 85 -- .../stores/deploymentPickStore.test.ts | 775 ++++++++++++++++++ .../workspace/stores/deploymentPickStore.ts | 239 ++++++ .../workspace/stores/releasePickStore.test.ts | 308 ------- .../workspace/stores/releasePickStore.ts | 198 ----- 24 files changed, 2478 insertions(+), 1529 deletions(-) create mode 100644 src/platform/workspace/components/DeploymentSwitcher.stories.ts create mode 100644 src/platform/workspace/components/DeploymentSwitcher.test.ts create mode 100644 src/platform/workspace/components/DeploymentSwitcher.vue create mode 100644 src/platform/workspace/components/DeploymentSwitcherList.vue create mode 100644 src/platform/workspace/components/DeploymentSwitcherOwnerFooter.vue create mode 100644 src/platform/workspace/components/DeploymentSwitcherRow.vue delete mode 100644 src/platform/workspace/components/ReleaseSwitcher.stories.ts delete mode 100644 src/platform/workspace/components/ReleaseSwitcher.test.ts delete mode 100644 src/platform/workspace/components/ReleaseSwitcher.vue create mode 100644 src/platform/workspace/composables/useDeploymentLabels.ts create mode 100644 src/platform/workspace/deploymentPickState.test.ts create mode 100644 src/platform/workspace/deploymentPickState.ts delete mode 100644 src/platform/workspace/releasePickState.test.ts delete mode 100644 src/platform/workspace/releasePickState.ts create mode 100644 src/platform/workspace/stores/deploymentPickStore.test.ts create mode 100644 src/platform/workspace/stores/deploymentPickStore.ts delete mode 100644 src/platform/workspace/stores/releasePickStore.test.ts delete mode 100644 src/platform/workspace/stores/releasePickStore.ts diff --git a/src/locales/en/main.json b/src/locales/en/main.json index cade57f5cc8..11c2247857f 100644 --- a/src/locales/en/main.json +++ b/src/locales/en/main.json @@ -3866,24 +3866,22 @@ "managedByOrganization": "Your organization manages your workspaces, so you can't create one.", "failedToSwitch": "Failed to switch workspace" }, - "releaseSwitcher": { + "deploymentSwitcher": { "runningOn": "Running on", "comfyCloud": "Comfy Cloud", "comfyCloudCaption": "Comfy's own node set", - "release": "{build} v{version}", - "unnamedRelease": "Release {id}", - "deployedAs": "Deployed, {status}", - "notDeployed": "Not deployed", - "notDeployedTooltip": "Deploy this Release on the Developer Platform first.", - "noReleases": "This workspace has no Releases yet.", + "deployment": "{build} v{version}", + "unnamedDeployment": "Deployment {id}", + "caption": "{id}, {status}", + "noDeployments": "This workspace has no deployments yet. Deploy a Release on the Developer Platform first.", "buildsHidden": "Build names are not visible to this account.", - "reloadNote": "The editor reloads to show the Release's nodes.", + "reloadNote": "The editor reloads to show the deployment's nodes. When the deployment is updated to a new Release, the editor follows it.", "failedToSwitch": "Could not switch", "workspaceDefault": "Workspace default", - "workspaceDefaultIs": "Workspace default: {release}", + "workspaceDefaultIs": "Workspace default: {deployment}", "noWorkspaceDefault": "No workspace default: members start on Comfy Cloud.", "followWorkspace": "Use the workspace default", - "followWorkspaceCaption": "Drop this browser's own pick and run on {release}", + "followWorkspaceCaption": "Drop this browser's own pick and run on {deployment}", "setAsDefault": "Set as workspace default", "clearDefault": "Clear workspace default", "failedToSetDefault": "Could not change the workspace default" diff --git a/src/platform/workspace/api/__mocks__/workspaceApi.ts b/src/platform/workspace/api/__mocks__/workspaceApi.ts index 956e326e5f9..010577271c5 100644 --- a/src/platform/workspace/api/__mocks__/workspaceApi.ts +++ b/src/platform/workspace/api/__mocks__/workspaceApi.ts @@ -39,6 +39,11 @@ export const workspaceApi = vi.mockObject( created_at: '2026-01-01T00:00:00Z', joined_at: '2026-01-01T00:00:00Z' }), + listDeployments: async () => ({ items: [], builds_visible: true }), + pickDeployment: async () => {}, + clearDeployment: async () => {}, + setDefaultDeployment: async () => {}, + clearDefaultDeployment: async () => {}, delete: async () => {}, leave: async () => {}, listMembers: async () => ({ diff --git a/src/platform/workspace/api/workspaceApi.test.ts b/src/platform/workspace/api/workspaceApi.test.ts index 67440ca8544..0b7771d12d8 100644 --- a/src/platform/workspace/api/workspaceApi.test.ts +++ b/src/platform/workspace/api/workspaceApi.test.ts @@ -12,6 +12,7 @@ const { mockAxiosInstance } = vi.hoisted(() => ({ mockAxiosInstance: { get: vi.fn(), post: vi.fn(), + put: vi.fn(), patch: vi.fn(), delete: vi.fn(), interceptors: { response: { use: vi.fn() } } @@ -351,6 +352,76 @@ describe('workspaceApi', () => { }) }) + describe('deployment picking', () => { + it('listDeployments() sends GET /workspaces/:id/deployments', async () => { + const data = { items: [], builds_visible: true } + mockAxiosInstance.get.mockResolvedValue({ data }) + + const result = await workspaceApi.listDeployments('ws-1') + + expect(mockAxiosInstance.get).toHaveBeenCalledWith( + '/api/workspaces/ws-1/deployments', + { headers: AUTH_HEADER } + ) + expect(result).toEqual(data) + }) + + it('pickDeployment() sends PUT /workspaces/:id/deployment with the deployment', async () => { + mockAxiosInstance.put.mockResolvedValue({}) + + await workspaceApi.pickDeployment('ws-1', { deployment_id: 'dep-1' }) + + expect(mockAxiosInstance.put).toHaveBeenCalledWith( + '/api/workspaces/ws-1/deployment', + { deployment_id: 'dep-1' }, + { headers: AUTH_HEADER } + ) + }) + + it('clearDeployment() sends DELETE /workspaces/:id/deployment, with follow=workspace only when asked', async () => { + mockAxiosInstance.delete.mockResolvedValue({}) + + await workspaceApi.clearDeployment('ws-1') + await workspaceApi.clearDeployment('ws-1', { follow: 'workspace' }) + + expect(mockAxiosInstance.delete).toHaveBeenNthCalledWith( + 1, + '/api/workspaces/ws-1/deployment', + { headers: AUTH_HEADER, params: undefined } + ) + expect(mockAxiosInstance.delete).toHaveBeenNthCalledWith( + 2, + '/api/workspaces/ws-1/deployment', + { headers: AUTH_HEADER, params: { follow: 'workspace' } } + ) + }) + + it('setDefaultDeployment() sends PUT /workspaces/:id/default-deployment with the deployment', async () => { + mockAxiosInstance.put.mockResolvedValue({}) + + await workspaceApi.setDefaultDeployment('ws-1', { + deployment_id: 'dep-1' + }) + + expect(mockAxiosInstance.put).toHaveBeenCalledWith( + '/api/workspaces/ws-1/default-deployment', + { deployment_id: 'dep-1' }, + { headers: AUTH_HEADER } + ) + }) + + it('clearDefaultDeployment() sends DELETE /workspaces/:id/default-deployment', async () => { + mockAxiosInstance.delete.mockResolvedValue({}) + + await workspaceApi.clearDefaultDeployment('ws-1') + + expect(mockAxiosInstance.delete).toHaveBeenCalledWith( + '/api/workspaces/ws-1/default-deployment', + { headers: AUTH_HEADER } + ) + }) + }) + describe('member management', () => { it('listMembers() sends GET with params', async () => { const data = { diff --git a/src/platform/workspace/api/workspaceApi.ts b/src/platform/workspace/api/workspaceApi.ts index 1582cd70948..7786f1d2238 100644 --- a/src/platform/workspace/api/workspaceApi.ts +++ b/src/platform/workspace/api/workspaceApi.ts @@ -21,7 +21,7 @@ import type { PaymentPortalRequest, PaymentPortalResponse, PendingInvite, - PickWorkspaceReleaseRequest, + PickWorkspaceDeploymentRequest, Plan, PreviewSubscribeRequest, PreviewSubscribeResponse, @@ -41,8 +41,7 @@ import type { TeamCreditStops, TeamCreditStopSummary, UpdateWorkspaceRequest, - WorkspaceRelease, - WorkspaceReleaseList, + WorkspaceDeploymentList, WorkspaceWithRole } from '@comfyorg/ingest-types' import { @@ -99,8 +98,6 @@ export type { SubscriptionDuration } export type { WorkspaceWithRole } export type { ListWorkspacesResponse } export type { CurrentWorkspaceResponse } -export type { WorkspaceRelease } -export type { WorkspaceReleaseList } export type { Plan } export type { BillingPlansResponse } export type { TeamCreditStops } @@ -312,16 +309,18 @@ export const workspaceApi = { }, /** - * List the developer-platform Releases this browser may pick, and which - * one it picked. 403 when the account is outside the rollout. - * GET /api/workspaces/:id/releases + * List the developer-platform deployments this browser may pick, each + * with the Release it runs now, and which one it picked. 403 when the account is outside the rollout. + * GET /api/workspaces/:id/deployments */ - async listReleases(workspaceId: WorkspaceId): Promise { - const headers = await getAuthHeaderOrThrow() + async listDeployments( + workspaceId: WorkspaceId + ): Promise { + const auth = await requestAuth() try { - const response = await workspaceApiClient.get( - workspaceApiUrl(`/workspaces/${workspaceId}/releases`), - { headers } + const response = await workspaceApiClient.get( + workspaceApiUrl(`/workspaces/${workspaceId}/deployments`), + auth ) return response.data } catch (err) { @@ -330,20 +329,21 @@ export const workspaceApi = { }, /** - * Pick the Release this browser runs on. The pick is a cookie on the + * Pick the deployment this browser runs on; it follows the deployment's + * updates to new Releases. The pick is a cookie on the * response; nothing about the workspace changes. - * PUT /api/workspaces/:id/release + * PUT /api/workspaces/:id/deployment */ - async pickRelease( + async pickDeployment( workspaceId: WorkspaceId, - payload: PickWorkspaceReleaseRequest + payload: PickWorkspaceDeploymentRequest ): Promise { - const headers = await getAuthHeaderOrThrow() + const auth = await requestAuth() try { await workspaceApiClient.put( - workspaceApiUrl(`/workspaces/${workspaceId}/release`), + workspaceApiUrl(`/workspaces/${workspaceId}/deployment`), payload, - { headers } + auth ) } catch (err) { handleAxiosError(err) @@ -353,19 +353,19 @@ export const workspaceApi = { /** * Clear the pick: this browser runs on Comfy Cloud, or with * `follow: 'workspace'` on whatever the workspace says (its default - * Release, or Comfy Cloud when it has none). - * DELETE /api/workspaces/:id/release + * deployment, or Comfy Cloud when it has none). + * DELETE /api/workspaces/:id/deployment */ - async clearRelease( + async clearDeployment( workspaceId: WorkspaceId, options: { follow?: 'workspace' } = {} ): Promise { - const headers = await getAuthHeaderOrThrow() + const auth = await requestAuth() try { await workspaceApiClient.delete( - workspaceApiUrl(`/workspaces/${workspaceId}/release`), + workspaceApiUrl(`/workspaces/${workspaceId}/deployment`), { - headers, + ...auth, params: options.follow ? { follow: options.follow } : undefined } ) @@ -375,20 +375,20 @@ export const workspaceApi = { }, /** - * Set the Release members of the workspace run on when their browser has + * Set the deployment members of the workspace run on when their browser has * no pick of its own (BE-17480). Owner only. - * PUT /api/workspaces/:id/default-release + * PUT /api/workspaces/:id/default-deployment */ - async setDefaultRelease( + async setDefaultDeployment( workspaceId: WorkspaceId, - payload: PickWorkspaceReleaseRequest + payload: PickWorkspaceDeploymentRequest ): Promise { - const headers = await getAuthHeaderOrThrow() + const auth = await requestAuth() try { await workspaceApiClient.put( - workspaceApiUrl(`/workspaces/${workspaceId}/default-release`), + workspaceApiUrl(`/workspaces/${workspaceId}/default-deployment`), payload, - { headers } + auth ) } catch (err) { handleAxiosError(err) @@ -396,16 +396,16 @@ export const workspaceApi = { }, /** - * Clear the workspace's default Release; members with no pick are back on + * Clear the workspace's default deployment; members with no pick are back on * Comfy Cloud. Owner only. - * DELETE /api/workspaces/:id/default-release + * DELETE /api/workspaces/:id/default-deployment */ - async clearDefaultRelease(workspaceId: WorkspaceId): Promise { - const headers = await getAuthHeaderOrThrow() + async clearDefaultDeployment(workspaceId: WorkspaceId): Promise { + const auth = await requestAuth() try { await workspaceApiClient.delete( - workspaceApiUrl(`/workspaces/${workspaceId}/default-release`), - { headers } + workspaceApiUrl(`/workspaces/${workspaceId}/default-deployment`), + auth ) } catch (err) { handleAxiosError(err) diff --git a/src/platform/workspace/components/CurrentUserPopoverWorkspace.test.ts b/src/platform/workspace/components/CurrentUserPopoverWorkspace.test.ts index 84e9fb1db53..2f108ec3d53 100644 --- a/src/platform/workspace/components/CurrentUserPopoverWorkspace.test.ts +++ b/src/platform/workspace/components/CurrentUserPopoverWorkspace.test.ts @@ -24,6 +24,7 @@ import { useSubscriptionDialog } from '@/platform/cloud/subscription/composables import { useSettingsDialog } from '@/platform/settings/composables/useSettingsDialog' import { useWorkspaceUI } from '@/platform/workspace/composables/useWorkspaceUI' import type { BillingStatus } from '@/platform/workspace/api/workspaceApi' +import { workspaceApi } from '@/platform/workspace/api/workspaceApi' import CurrentUserPopoverWorkspace from './CurrentUserPopoverWorkspace.vue' @@ -80,6 +81,8 @@ vi.mock(import('@/platform/distribution/types'), () => ({ vi.mock(import('@/composables/billing/useBillingDialogs')) vi.mock(import('@/platform/workspace/composables/useWorkspaceDialogs')) +vi.mock(import('@/platform/workspace/api/workspaceApi')) + vi.mock(import('@/platform/telemetry')) vi.mock(import('@/composables/useFeatureFlags')) @@ -304,6 +307,29 @@ describe('CurrentUserPopoverWorkspace', () => { }) }) + it('shows the deployment switcher on Cloud once the listing answers', async () => { + Object.assign(useTeamWorkspaceStore(), { workspaceId: 'ws-1' }) + vi.mocked(workspaceApi.listDeployments).mockResolvedValue({ + items: [], + builds_visible: true + }) + renderComponent() + + expect( + await screen.findByTestId('deployment-switcher-current') + ).toHaveTextContent('Comfy Cloud') + expect(workspaceApi.listDeployments).toHaveBeenCalledWith('ws-1') + }) + + it('does not ask for deployments on Local', () => { + state.isCloud = false + Object.assign(useTeamWorkspaceStore(), { workspaceId: 'ws-1' }) + renderComponent() + + expect(screen.queryByTestId('deployment-switcher')).not.toBeInTheDocument() + expect(workspaceApi.listDeployments).not.toHaveBeenCalled() + }) + it('exposes the full workspace name on hover', async () => { const user = userEvent.setup() renderComponent('team') diff --git a/src/platform/workspace/components/CurrentUserPopoverWorkspace.vue b/src/platform/workspace/components/CurrentUserPopoverWorkspace.vue index 3521418d80d..f0dfbc3eab3 100644 --- a/src/platform/workspace/components/CurrentUserPopoverWorkspace.vue +++ b/src/platform/workspace/components/CurrentUserPopoverWorkspace.vue @@ -88,9 +88,12 @@
- - + + @@ -266,7 +269,7 @@ import { useI18n } from 'vue-i18n' import { formatCreditsFromCents } from '@/base/credits/comfyCredits' import UserAvatar from '@/components/common/UserAvatar.vue' import WorkspaceProfilePic from '@/platform/workspace/components/WorkspaceProfilePic.vue' -import ReleaseSwitcher from '@/platform/workspace/components/ReleaseSwitcher.vue' +import DeploymentSwitcher from '@/platform/workspace/components/DeploymentSwitcher.vue' import WorkspaceSwitcherPopover from '@/platform/workspace/components/WorkspaceSwitcherPopover.vue' import Button from '@/components/ui/button/Button.vue' import Skeleton from '@/components/ui/skeleton/Skeleton.vue' diff --git a/src/platform/workspace/components/DeploymentSwitcher.stories.ts b/src/platform/workspace/components/DeploymentSwitcher.stories.ts new file mode 100644 index 00000000000..095f2637fe4 --- /dev/null +++ b/src/platform/workspace/components/DeploymentSwitcher.stories.ts @@ -0,0 +1,161 @@ +import type { Meta, StoryObj } from '@storybook/vue3-vite' + +import type { WorkspaceDeployment } from '@comfyorg/ingest-types' +import type { DeploymentPickState } from '@/platform/workspace/deploymentPickState' +import { useDeploymentPickStore } from '@/platform/workspace/stores/deploymentPickStore' + +import DeploymentSwitcher from './DeploymentSwitcher.vue' + +/** + * The deployment switcher under the workspace selector in the user popover: + * which developer-platform deployment this browser runs its Cloud jobs on, + * and the list it may pick from. Each row is a deployment with the Release it + * runs now; a pick follows the deployment when its owner updates it. Each story seeds the store's state directly; the + * Storybook team-workspace stub has no active workspace, so the store never + * calls the listing route here. Click the trigger to open the panel. + */ +const meta: Meta = { + title: 'Components/DeploymentSwitcher', + component: DeploymentSwitcher, + tags: ['autodocs'], + parameters: { layout: 'centered' }, + decorators: [ + (story) => ({ + components: { story }, + template: + '
' + }) + ] +} + +export default meta +type Story = StoryObj + +const studioProd: WorkspaceDeployment = { + deployment_id: 'dep-f24d36bb-fd1f-4cd7-bfa9-fe015b5cd33d', + release_id: '6f1c2b0e-3c4d-4e5f-8a9b-0c1d2e3f4a5b', + build_id: 'b-1', + build_name: 'Studio Build', + release_version: 2, + status: 'ready', + created_at: '2026-09-16T18:00:00Z' +} + +const studioStaging: WorkspaceDeployment = { + deployment_id: 'dep-0a1b2c3d-4e5f-4a6b-8c7d-9e0f1a2b3c4d', + release_id: 'c4a8e2f0-5b6c-4d7e-8f90-1a2b3c4d5e6f', + build_id: 'b-1', + build_name: 'Studio Build', + release_version: 3, + status: 'starting', + created_at: '2026-09-12T09:30:00Z' +} + +const experiments: WorkspaceDeployment = { + deployment_id: 'dep-c0ffee00-1111-4222-8333-444455556666', + release_id: 'c0ffee00-1111-4222-8333-444455556666', + build_id: 'b-2', + build_name: 'Experiments', + release_version: 3, + status: 'stopped', + created_at: '2026-09-15T12:00:00Z' +} + +// The store is seeded from a component's setup(), where the app's Pinia is +// injected; a story beforeEach runs before any component and has no active +// Pinia. +function seeded(state: DeploymentPickState): Story { + return { + decorators: [ + (story) => ({ + components: { story }, + setup() { + useDeploymentPickStore().state = state + }, + template: '' + }) + ] + } +} + +/** Nothing picked: this browser runs on Comfy Cloud. */ +export const Default: Story = seeded({ + phase: 'ready', + deployments: [studioProd, experiments, studioStaging], + pickedDeploymentId: null, + pickSource: null, + defaultDeploymentId: null, + buildsVisible: true +}) + +/** A deployment picked; the trigger names its Build and Release. */ +export const Picked: Story = seeded({ + phase: 'ready', + deployments: [studioProd, experiments, studioStaging], + pickedDeploymentId: studioProd.deployment_id, + pickSource: 'browser', + defaultDeploymentId: null, + buildsVisible: true +}) + +/** + * An owner set a workspace default (BE-17480) and this browser has no pick + * of its own, so it follows it; the trigger says so. + */ +export const FollowingWorkspaceDefault: Story = seeded({ + phase: 'ready', + deployments: [studioProd, experiments, studioStaging], + pickedDeploymentId: studioProd.deployment_id, + pickSource: 'workspace_default', + defaultDeploymentId: studioProd.deployment_id, + buildsVisible: true +}) + +/** + * This browser picked for itself while the workspace has a default: the + * panel offers the default as a row to go back to. + */ +export const OwnPickOverWorkspaceDefault: Story = seeded({ + phase: 'ready', + deployments: [studioProd, experiments, studioStaging], + pickedDeploymentId: experiments.deployment_id, + pickSource: 'browser', + defaultDeploymentId: studioProd.deployment_id, + buildsVisible: true +}) + +/** A workspace with no deployments yet. */ +export const Empty: Story = seeded({ + phase: 'ready', + deployments: [], + pickedDeploymentId: null, + pickSource: null, + defaultDeploymentId: null, + buildsVisible: true +}) + +/** + * comfy-builder refused the caller (its routes sit behind the Builds beta): + * the deployments are listed by id, and the panel says why. + */ +export const BuildsHidden: Story = seeded({ + phase: 'ready', + deployments: [ + { + deployment_id: studioProd.deployment_id, + release_id: studioProd.release_id, + status: 'ready', + created_at: studioProd.created_at + }, + { + deployment_id: experiments.deployment_id, + release_id: experiments.release_id, + status: 'stopped', + created_at: experiments.created_at + } + ], + pickedDeploymentId: studioProd.deployment_id, + pickSource: 'browser', + defaultDeploymentId: null, + buildsVisible: false +}) diff --git a/src/platform/workspace/components/DeploymentSwitcher.test.ts b/src/platform/workspace/components/DeploymentSwitcher.test.ts new file mode 100644 index 00000000000..f467d919b4a --- /dev/null +++ b/src/platform/workspace/components/DeploymentSwitcher.test.ts @@ -0,0 +1,439 @@ +import { render, screen, waitFor } from '@testing-library/vue' +import userEvent from '@testing-library/user-event' +import { beforeEach, describe, expect, it, vi } from 'vitest' +import { nextTick } from 'vue' +import { createI18n } from 'vue-i18n' + +import type { WorkspaceDeploymentList } from '@comfyorg/ingest-types' + +import enMessages from '@/locales/en/main.json' +import { useToastStore } from '@/platform/updates/common/toastStore' +import { WorkspaceApiError } from '@/platform/workspace/api/workspaceApi' +import { useDeploymentPickStore } from '@/platform/workspace/stores/deploymentPickStore' +import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' + +import DeploymentSwitcher from './DeploymentSwitcher.vue' + +const mockWorkspaceApi = vi.hoisted(() => ({ + listDeployments: vi.fn(), + pickDeployment: vi.fn(), + clearDeployment: vi.fn(), + setDefaultDeployment: vi.fn(), + clearDefaultDeployment: vi.fn() +})) + +vi.mock(import('@/platform/workspace/api/workspaceApi'), async () => { + class WorkspaceApiError extends Error { + constructor( + message: string, + public readonly status?: number, + public readonly code?: string + ) { + super(message) + this.name = 'WorkspaceApiError' + } + } + return { workspaceApi: mockWorkspaceApi, WorkspaceApiError } +}) + +const i18n = createI18n({ + legacy: false, + locale: 'en', + messages: { en: enMessages } +}) + +const D2 = 'dep-a2a2a2a2-0000-4000-8000-000000000002' +const D1 = 'dep-a1a1a1a1-0000-4000-8000-000000000001' +const D9 = 'dep-b9b9b9b9-0000-4000-8000-000000000009' + +const listing: WorkspaceDeploymentList = { + builds_visible: true, + items: [ + { + deployment_id: D2, + release_id: 'r-2', + build_id: 'b-1', + build_name: 'Studio Build', + release_version: 2, + status: 'ready', + created_at: '2026-10-01T00:00:00Z' + }, + { + deployment_id: D1, + release_id: 'r-1', + build_id: 'b-1', + build_name: 'Studio Build', + release_version: 1, + status: 'stopped', + created_at: '2026-09-20T00:00:00Z' + }, + { + deployment_id: D9, + release_id: 'r-9', + status: 'stopped', + created_at: '2026-09-10T00:00:00Z' + } + ] +} + +function renderSwitcher() { + return render(DeploymentSwitcher, { + global: { + plugins: [i18n] + } + }) +} + +describe('DeploymentSwitcher', () => { + const reload = vi.fn() + + beforeEach(() => { + Object.assign(useTeamWorkspaceStore(), { workspaceId: 'ws-1' }) + Object.defineProperty(window, 'location', { + value: { reload, origin: 'http://localhost' }, + writable: true, + configurable: true + }) + }) + + it('renders nothing when the account is outside the rollout', async () => { + mockWorkspaceApi.listDeployments.mockRejectedValue( + new WorkspaceApiError('not enabled for this account yet', 403) + ) + renderSwitcher() + await waitFor(() => + expect(useDeploymentPickStore().state.phase).toBe('hidden') + ) + expect(mockWorkspaceApi.listDeployments).toHaveBeenCalledWith('ws-1') + expect(screen.queryByTestId('deployment-switcher')).toBeNull() + }) + + it('says Comfy Cloud when nothing is picked, and lists the deployments', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue(listing) + renderSwitcher() + + await waitFor(() => + expect( + screen.getByTestId('deployment-switcher-current') + ).toHaveTextContent('Comfy Cloud') + ) + await userEvent.click(screen.getByTestId('deployment-switcher-trigger')) + + const panel = screen.getByTestId('deployment-switcher-panel') + expect(panel).toHaveTextContent('Studio Build v2') + expect(panel).toHaveTextContent('dep-a2a2a2a2, ready') + expect(panel).toHaveTextContent('Studio Build v1') + expect(panel).toHaveTextContent('dep-a1a1a1a1, stopped') + expect(panel).toHaveTextContent('Deployment dep-b9b9b9b9') + expect(screen.getByTestId('deployment-row-cloud')).toHaveAttribute( + 'aria-checked', + 'true' + ) + // A stopped deployment can still be picked; a job submitted to it is + // refused until it is ready. + expect(screen.getByTestId(`deployment-row-${D1}`)).not.toBeDisabled() + // Comfy Cloud with no workspace default: nothing to say it follows. + expect(screen.queryByTestId('deployment-switcher-following')).toBeNull() + expect(screen.queryByTestId('deployment-row-follow')).toBeNull() + }) + + it('shows the picked deployment by its Build and Release', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue({ + ...listing, + picked_deployment_id: D2 + }) + renderSwitcher() + await waitFor(() => + expect( + screen.getByTestId('deployment-switcher-current') + ).toHaveTextContent('Studio Build v2') + ) + }) + + it('picks a deployment, which reloads the editor', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue(listing) + mockWorkspaceApi.pickDeployment.mockResolvedValue(undefined) + renderSwitcher() + await userEvent.click( + await screen.findByTestId('deployment-switcher-trigger') + ) + + await userEvent.click(screen.getByTestId(`deployment-row-${D2}`)) + + expect(mockWorkspaceApi.pickDeployment).toHaveBeenCalledWith('ws-1', { + deployment_id: D2 + }) + await waitFor(() => expect(reload).toHaveBeenCalledOnce()) + }) + + it('goes back to Comfy Cloud through the clear route', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue({ + ...listing, + picked_deployment_id: D2 + }) + mockWorkspaceApi.clearDeployment.mockResolvedValue(undefined) + renderSwitcher() + await userEvent.click( + await screen.findByTestId('deployment-switcher-trigger') + ) + + await userEvent.click(screen.getByTestId('deployment-row-cloud')) + + expect(mockWorkspaceApi.clearDeployment).toHaveBeenCalledWith('ws-1') + await waitFor(() => expect(reload).toHaveBeenCalledOnce()) + }) + + it('renders nothing until the listing answers', async () => { + let resolve: (value: WorkspaceDeploymentList) => void = () => {} + mockWorkspaceApi.listDeployments.mockReturnValue( + new Promise((r) => { + resolve = r + }) + ) + renderSwitcher() + await nextTick() + expect(screen.queryByTestId('deployment-switcher')).toBeNull() + + resolve(listing) + expect( + await screen.findByTestId('deployment-switcher-current') + ).toHaveTextContent('Comfy Cloud') + }) + + it('renders nothing when the listing fails', async () => { + mockWorkspaceApi.listDeployments.mockRejectedValue( + new WorkspaceApiError('404 page not found', 404) + ) + renderSwitcher() + await waitFor(() => + expect(useDeploymentPickStore().state.phase).toBe('hidden') + ) + expect(screen.queryByTestId('deployment-switcher')).toBeNull() + }) + + it('disables the trigger while a pick is in flight', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue(listing) + mockWorkspaceApi.pickDeployment.mockReturnValue(new Promise(() => {})) + renderSwitcher() + const trigger = await screen.findByTestId('deployment-switcher-trigger') + await userEvent.click(trigger) + expect(trigger).not.toBeDisabled() + + await userEvent.click(screen.getByTestId(`deployment-row-${D2}`)) + expect(trigger).toBeDisabled() + }) + + it("shows the server's refusal as a toast, does not reload, and lets the user pick again", async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue(listing) + mockWorkspaceApi.pickDeployment.mockRejectedValue( + new WorkspaceApiError("deployment is not one of this workspace's", 422) + ) + renderSwitcher() + const trigger = await screen.findByTestId('deployment-switcher-trigger') + await userEvent.click(trigger) + await userEvent.click(screen.getByTestId(`deployment-row-${D2}`)) + + await waitFor(() => + expect(useToastStore().messagesToAdd).toContainEqual( + expect.objectContaining({ + severity: 'error', + detail: "deployment is not one of this workspace's" + }) + ) + ) + expect(reload).not.toHaveBeenCalled() + expect(screen.queryByTestId('deployment-switcher-panel')).toBeNull() + expect(trigger).not.toBeDisabled() + }) + + it('says it follows the workspace default, and marks that deployment in the list', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue({ + ...listing, + picked_deployment_id: D2, + pick_source: 'workspace_default', + default_deployment_id: D2 + }) + renderSwitcher() + await waitFor(() => + expect( + screen.getByTestId('deployment-switcher-current') + ).toHaveTextContent('Studio Build v2') + ) + expect( + screen.getByTestId('deployment-switcher-following') + ).toHaveTextContent('Workspace default') + await userEvent.click(screen.getByTestId('deployment-switcher-trigger')) + expect(screen.getByTestId(`deployment-row-${D2}`)).toHaveTextContent( + 'Workspace default' + ) + expect(screen.queryByTestId('deployment-row-follow')).toBeNull() + expect(screen.queryByTestId('deployment-switcher-owner')).toBeNull() + }) + + it('offers a browser with its own pick the workspace default, which clears with follow=workspace', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue({ + ...listing, + pick_source: 'browser', + default_deployment_id: D2 + }) + mockWorkspaceApi.clearDeployment.mockResolvedValue(undefined) + renderSwitcher() + await userEvent.click( + await screen.findByTestId('deployment-switcher-trigger') + ) + expect(screen.queryByTestId('deployment-switcher-following')).toBeNull() + + const follow = screen.getByTestId('deployment-row-follow') + expect(follow).toHaveTextContent('Studio Build v2') + await userEvent.click(follow) + + expect(mockWorkspaceApi.clearDeployment).toHaveBeenCalledWith('ws-1', { + follow: 'workspace' + }) + await waitFor(() => expect(reload).toHaveBeenCalledOnce()) + }) + + it('lets an owner set the picked deployment as the workspace default, and clear it', async () => { + Object.assign(useTeamWorkspaceStore(), { + workspaceId: 'ws-1', + activeWorkspace: { id: 'ws-1', role: 'owner' } + }) + mockWorkspaceApi.listDeployments + .mockResolvedValueOnce({ + ...listing, + picked_deployment_id: D2, + pick_source: 'browser' + }) + .mockResolvedValue({ + ...listing, + picked_deployment_id: D2, + pick_source: 'browser', + default_deployment_id: D2 + }) + mockWorkspaceApi.setDefaultDeployment.mockResolvedValue(undefined) + mockWorkspaceApi.clearDefaultDeployment.mockResolvedValue(undefined) + renderSwitcher() + await userEvent.click( + await screen.findByTestId('deployment-switcher-trigger') + ) + + const owner = screen.getByTestId('deployment-switcher-owner') + expect(owner).toHaveTextContent('No workspace default') + expect(screen.queryByTestId('deployment-switcher-clear-default')).toBeNull() + await userEvent.click(screen.getByTestId('deployment-switcher-set-default')) + + expect(mockWorkspaceApi.setDefaultDeployment).toHaveBeenCalledWith('ws-1', { + deployment_id: D2 + }) + await waitFor(() => + expect(owner).toHaveTextContent('Workspace default: Studio Build v2') + ) + expect(reload).not.toHaveBeenCalled() + expect(screen.queryByTestId('deployment-switcher-set-default')).toBeNull() + + await userEvent.click( + screen.getByTestId('deployment-switcher-clear-default') + ) + expect(mockWorkspaceApi.clearDefaultDeployment).toHaveBeenCalledWith('ws-1') + }) + + it("disables the trigger and the owner's buttons while a default is being set", async () => { + Object.assign(useTeamWorkspaceStore(), { + workspaceId: 'ws-1', + activeWorkspace: { id: 'ws-1', role: 'owner' } + }) + mockWorkspaceApi.listDeployments.mockResolvedValue({ + ...listing, + picked_deployment_id: D2, + pick_source: 'browser', + default_deployment_id: D1 + }) + mockWorkspaceApi.setDefaultDeployment.mockReturnValue(new Promise(() => {})) + renderSwitcher() + const trigger = await screen.findByTestId('deployment-switcher-trigger') + await userEvent.click(trigger) + const setDefault = screen.getByTestId('deployment-switcher-set-default') + const clearDefault = screen.getByTestId('deployment-switcher-clear-default') + expect(setDefault).not.toBeDisabled() + expect(clearDefault).not.toBeDisabled() + + await userEvent.click(setDefault) + + expect(trigger).toBeDisabled() + expect(setDefault).toBeDisabled() + expect(clearDefault).toBeDisabled() + }) + + it('shows the new default in the footer and the list even when the refresh after it fails', async () => { + Object.assign(useTeamWorkspaceStore(), { + workspaceId: 'ws-1', + activeWorkspace: { id: 'ws-1', role: 'owner' } + }) + mockWorkspaceApi.listDeployments + .mockResolvedValueOnce({ + ...listing, + picked_deployment_id: D2, + pick_source: 'browser', + default_deployment_id: D1 + }) + .mockRejectedValue(new WorkspaceApiError('Network Error')) + mockWorkspaceApi.setDefaultDeployment.mockResolvedValue(undefined) + renderSwitcher() + await userEvent.click( + await screen.findByTestId('deployment-switcher-trigger') + ) + const owner = screen.getByTestId('deployment-switcher-owner') + expect(owner).toHaveTextContent('Workspace default: Studio Build v1') + + await userEvent.click(screen.getByTestId('deployment-switcher-set-default')) + + await waitFor(() => + expect(mockWorkspaceApi.listDeployments).toHaveBeenCalledTimes(2) + ) + await waitFor(() => + expect(owner).toHaveTextContent('Workspace default: Studio Build v2') + ) + expect(screen.getByTestId(`deployment-row-${D2}`)).toHaveTextContent( + 'Workspace default' + ) + expect(screen.getByTestId(`deployment-row-${D1}`)).not.toHaveTextContent( + 'Workspace default' + ) + expect(useToastStore().messagesToAdd).toEqual([]) + expect(reload).not.toHaveBeenCalled() + }) + + it('offers no way back to a workspace default when there is none', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue({ + ...listing, + picked_deployment_id: D2, + pick_source: 'browser' + }) + renderSwitcher() + await userEvent.click( + await screen.findByTestId('deployment-switcher-trigger') + ) + expect(screen.getByTestId(`deployment-row-${D2}`)).toHaveAttribute( + 'aria-checked', + 'true' + ) + expect(screen.queryByTestId('deployment-row-follow')).toBeNull() + }) + + it('shows a member the workspace default but no way to change it', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue({ + ...listing, + picked_deployment_id: D2, + pick_source: 'browser', + default_deployment_id: D9 + }) + renderSwitcher() + await userEvent.click( + await screen.findByTestId('deployment-switcher-trigger') + ) + expect(screen.queryByTestId('deployment-switcher-owner')).toBeNull() + expect(screen.getByTestId('deployment-row-follow')).toHaveTextContent( + 'Deployment dep-b9b9b9b9' + ) + }) +}) diff --git a/src/platform/workspace/components/DeploymentSwitcher.vue b/src/platform/workspace/components/DeploymentSwitcher.vue new file mode 100644 index 00000000000..ac8531aa0ac --- /dev/null +++ b/src/platform/workspace/components/DeploymentSwitcher.vue @@ -0,0 +1,158 @@ + + + + diff --git a/src/platform/workspace/components/DeploymentSwitcherList.vue b/src/platform/workspace/components/DeploymentSwitcherList.vue new file mode 100644 index 00000000000..2ea7e412567 --- /dev/null +++ b/src/platform/workspace/components/DeploymentSwitcherList.vue @@ -0,0 +1,75 @@ + + + + diff --git a/src/platform/workspace/components/DeploymentSwitcherOwnerFooter.vue b/src/platform/workspace/components/DeploymentSwitcherOwnerFooter.vue new file mode 100644 index 00000000000..370701476d6 --- /dev/null +++ b/src/platform/workspace/components/DeploymentSwitcherOwnerFooter.vue @@ -0,0 +1,62 @@ + + + + diff --git a/src/platform/workspace/components/DeploymentSwitcherRow.vue b/src/platform/workspace/components/DeploymentSwitcherRow.vue new file mode 100644 index 00000000000..345a5a63cec --- /dev/null +++ b/src/platform/workspace/components/DeploymentSwitcherRow.vue @@ -0,0 +1,36 @@ + + + + diff --git a/src/platform/workspace/components/ReleaseSwitcher.stories.ts b/src/platform/workspace/components/ReleaseSwitcher.stories.ts deleted file mode 100644 index 59095f060cd..00000000000 --- a/src/platform/workspace/components/ReleaseSwitcher.stories.ts +++ /dev/null @@ -1,166 +0,0 @@ -import type { Meta, StoryObj } from '@storybook/vue3-vite' - -import type { WorkspaceRelease } from '@/platform/workspace/api/workspaceApi' -import type { ReleasePickState } from '@/platform/workspace/releasePickState' -import { useReleasePickStore } from '@/platform/workspace/stores/releasePickStore' - -import ReleaseSwitcher from './ReleaseSwitcher.vue' - -/** - * The Release switcher under the workspace selector in the user popover: - * which developer-platform Release this browser runs its Cloud jobs on, and - * the list it may pick from. Each story seeds the store's state directly; the - * Storybook team-workspace stub has no active workspace, so the store never - * calls the listing route here. Click the trigger to open the panel. - */ -const meta: Meta = { - title: 'Components/ReleaseSwitcher', - component: ReleaseSwitcher, - tags: ['autodocs'], - parameters: { layout: 'centered' }, - decorators: [ - (story) => ({ - components: { story }, - template: - '
' - }) - ] -} - -export default meta -type Story = StoryObj - -const studioV2: WorkspaceRelease = { - release_id: '6f1c2b0e-3c4d-4e5f-8a9b-0c1d2e3f4a5b', - build_id: 'b-1', - build_name: 'Studio Build', - version: 2, - created_at: '2026-09-16T18:00:00Z', - deployed: true, - deployment_status: 'ready' -} - -const studioV1: WorkspaceRelease = { - release_id: '0a1b2c3d-4e5f-4a6b-8c7d-9e0f1a2b3c4d', - build_id: 'b-1', - build_name: 'Studio Build', - version: 1, - created_at: '2026-09-12T09:30:00Z', - deployed: false -} - -const experimentsV3: WorkspaceRelease = { - release_id: 'c0ffee00-1111-4222-8333-444455556666', - build_id: 'b-2', - build_name: 'Experiments', - version: 3, - created_at: '2026-09-15T12:00:00Z', - deployed: true, - deployment_status: 'stopped' -} - -// The store is seeded from a component's setup(), where the app's Pinia is -// injected; a story beforeEach runs before any component and has no active -// Pinia. -function seeded(state: ReleasePickState): Story { - return { - decorators: [ - (story) => ({ - components: { story }, - setup() { - useReleasePickStore().state = state - }, - template: '' - }) - ] - } -} - -/** Nothing picked: this browser runs on Comfy Cloud. */ -export const Default: Story = seeded({ - phase: 'ready', - releases: [studioV2, experimentsV3, studioV1], - pickedReleaseId: null, - pickSource: null, - defaultReleaseId: null, - buildsVisible: true -}) - -/** A Release picked; the trigger names it. */ -export const Picked: Story = seeded({ - phase: 'ready', - releases: [studioV2, experimentsV3, studioV1], - pickedReleaseId: studioV2.release_id, - pickSource: 'browser', - defaultReleaseId: null, - buildsVisible: true -}) - -/** - * An owner set a workspace default (BE-17480) and this browser has no pick - * of its own, so it follows it; the trigger says so. - */ -export const FollowingWorkspaceDefault: Story = seeded({ - phase: 'ready', - releases: [studioV2, experimentsV3, studioV1], - pickedReleaseId: studioV2.release_id, - pickSource: 'workspace_default', - defaultReleaseId: studioV2.release_id, - buildsVisible: true -}) - -/** - * This browser picked for itself while the workspace has a default: the - * panel offers the default as a row to go back to. - */ -export const OwnPickOverWorkspaceDefault: Story = seeded({ - phase: 'ready', - releases: [studioV2, experimentsV3, studioV1], - pickedReleaseId: experimentsV3.release_id, - pickSource: 'browser', - defaultReleaseId: studioV2.release_id, - buildsVisible: true -}) - -/** The listing has not answered yet. */ -export const Loading: Story = seeded({ phase: 'loading' }) - -/** The platform could not be asked; the server's message is shown. */ -export const Unavailable: Story = seeded({ - phase: 'unavailable', - message: 'could not list releases from comfy-deploy; try again' -}) - -/** A workspace with no Releases yet. */ -export const Empty: Story = seeded({ - phase: 'ready', - releases: [], - pickedReleaseId: null, - pickSource: null, - defaultReleaseId: null, - buildsVisible: true -}) - -/** - * comfy-builder refused the caller (its routes sit behind the Builds beta): - * the deployed Releases are listed nameless, and the panel says why. - */ -export const BuildsHidden: Story = seeded({ - phase: 'ready', - releases: [ - { - release_id: studioV2.release_id, - deployed: true, - deployment_status: 'ready' - }, - { - release_id: experimentsV3.release_id, - deployed: true, - deployment_status: 'stopped' - } - ], - pickedReleaseId: studioV2.release_id, - pickSource: 'browser', - defaultReleaseId: null, - buildsVisible: false -}) diff --git a/src/platform/workspace/components/ReleaseSwitcher.test.ts b/src/platform/workspace/components/ReleaseSwitcher.test.ts deleted file mode 100644 index db665216472..00000000000 --- a/src/platform/workspace/components/ReleaseSwitcher.test.ts +++ /dev/null @@ -1,308 +0,0 @@ -import { render, screen, waitFor } from '@testing-library/vue' -import userEvent from '@testing-library/user-event' -import { beforeEach, describe, expect, it, vi } from 'vitest' -import { createI18n } from 'vue-i18n' - -import type { WorkspaceReleaseList } from '@comfyorg/ingest-types' - -import enMessages from '@/locales/en/main.json' -import { useToastStore } from '@/platform/updates/common/toastStore' -import { WorkspaceApiError } from '@/platform/workspace/api/workspaceApi' -import { useReleasePickStore } from '@/platform/workspace/stores/releasePickStore' -import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' - -import ReleaseSwitcher from './ReleaseSwitcher.vue' - -const mockWorkspaceApi = vi.hoisted(() => ({ - listReleases: vi.fn(), - pickRelease: vi.fn(), - clearRelease: vi.fn(), - setDefaultRelease: vi.fn(), - clearDefaultRelease: vi.fn() -})) - -vi.mock(import('@/platform/workspace/api/workspaceApi'), async () => { - class WorkspaceApiError extends Error { - constructor( - message: string, - public readonly status?: number, - public readonly code?: string - ) { - super(message) - this.name = 'WorkspaceApiError' - } - } - return { workspaceApi: mockWorkspaceApi, WorkspaceApiError } -}) - -const i18n = createI18n({ - legacy: false, - locale: 'en', - messages: { en: enMessages } -}) - -const listing: WorkspaceReleaseList = { - builds_visible: true, - releases: [ - { - release_id: 'aaaaaaaa-0000-4000-8000-000000000002', - build_id: 'b-1', - build_name: 'Studio Build', - version: 2, - deployed: true, - deployment_status: 'ready' - }, - { - release_id: 'aaaaaaaa-0000-4000-8000-000000000001', - build_id: 'b-1', - build_name: 'Studio Build', - version: 1, - deployed: false - }, - { - release_id: 'bbbbbbbb-0000-4000-8000-000000000009', - deployed: true, - deployment_status: 'stopped' - } - ] -} - -function renderSwitcher() { - return render(ReleaseSwitcher, { - global: { - plugins: [i18n] - } - }) -} - -describe('ReleaseSwitcher', () => { - const reload = vi.fn() - - beforeEach(() => { - Object.assign(useTeamWorkspaceStore(), { workspaceId: 'ws-1' }) - Object.defineProperty(window, 'location', { - value: { reload, origin: 'http://localhost' }, - writable: true, - configurable: true - }) - }) - - it('renders nothing when the account is outside the rollout', async () => { - mockWorkspaceApi.listReleases.mockRejectedValue( - new WorkspaceApiError('not enabled for this account yet', 403) - ) - renderSwitcher() - await waitFor(() => - expect(useReleasePickStore().state.phase).toBe('hidden') - ) - expect(mockWorkspaceApi.listReleases).toHaveBeenCalledWith('ws-1') - expect(screen.queryByTestId('release-switcher')).toBeNull() - }) - - it('says Comfy Cloud when nothing is picked, and lists the Releases', async () => { - mockWorkspaceApi.listReleases.mockResolvedValue(listing) - renderSwitcher() - - await waitFor(() => - expect(screen.getByTestId('release-switcher-current')).toHaveTextContent( - 'Comfy Cloud' - ) - ) - await userEvent.click(screen.getByTestId('release-switcher-trigger')) - - const panel = screen.getByTestId('release-switcher-panel') - expect(panel).toHaveTextContent('Studio Build v2') - expect(panel).toHaveTextContent('Deployed, ready') - expect(panel).toHaveTextContent('Studio Build v1') - expect(panel).toHaveTextContent('Not deployed') - expect(panel).toHaveTextContent('Release bbbbbbbb') - expect(screen.getByTestId('release-row-cloud')).toHaveAttribute( - 'aria-checked', - 'true' - ) - expect( - screen.getByTestId('release-row-aaaaaaaa-0000-4000-8000-000000000001') - ).toBeDisabled() - }) - - it('shows the picked Release by name', async () => { - mockWorkspaceApi.listReleases.mockResolvedValue({ - ...listing, - picked_release_id: 'aaaaaaaa-0000-4000-8000-000000000002' - }) - renderSwitcher() - await waitFor(() => - expect(screen.getByTestId('release-switcher-current')).toHaveTextContent( - 'Studio Build v2' - ) - ) - }) - - it('picks a deployed Release, which reloads the editor', async () => { - mockWorkspaceApi.listReleases.mockResolvedValue(listing) - mockWorkspaceApi.pickRelease.mockResolvedValue(undefined) - renderSwitcher() - await userEvent.click(await screen.findByTestId('release-switcher-trigger')) - - await userEvent.click( - screen.getByTestId('release-row-aaaaaaaa-0000-4000-8000-000000000002') - ) - - expect(mockWorkspaceApi.pickRelease).toHaveBeenCalledWith('ws-1', { - release_id: 'aaaaaaaa-0000-4000-8000-000000000002' - }) - await waitFor(() => expect(reload).toHaveBeenCalledOnce()) - }) - - it('goes back to Comfy Cloud through the clear route', async () => { - mockWorkspaceApi.listReleases.mockResolvedValue({ - ...listing, - picked_release_id: 'aaaaaaaa-0000-4000-8000-000000000002' - }) - mockWorkspaceApi.clearRelease.mockResolvedValue(undefined) - renderSwitcher() - await userEvent.click(await screen.findByTestId('release-switcher-trigger')) - - await userEvent.click(screen.getByTestId('release-row-cloud')) - - expect(mockWorkspaceApi.clearRelease).toHaveBeenCalledWith('ws-1') - await waitFor(() => expect(reload).toHaveBeenCalledOnce()) - }) - - it("shows the server's refusal as a toast and does not reload", async () => { - mockWorkspaceApi.listReleases.mockResolvedValue(listing) - mockWorkspaceApi.pickRelease.mockRejectedValue( - new WorkspaceApiError('release has no deployment; deploy it first', 422) - ) - renderSwitcher() - await userEvent.click(await screen.findByTestId('release-switcher-trigger')) - await userEvent.click( - screen.getByTestId('release-row-aaaaaaaa-0000-4000-8000-000000000002') - ) - - await waitFor(() => - expect(useToastStore().messagesToAdd).toContainEqual( - expect.objectContaining({ - severity: 'error', - detail: 'release has no deployment; deploy it first' - }) - ) - ) - expect(reload).not.toHaveBeenCalled() - expect(screen.queryByTestId('release-switcher-panel')).toBeNull() - }) - - it('says it follows the workspace default, and marks that Release in the list', async () => { - mockWorkspaceApi.listReleases.mockResolvedValue({ - ...listing, - picked_release_id: 'aaaaaaaa-0000-4000-8000-000000000002', - pick_source: 'workspace_default', - default_release_id: 'aaaaaaaa-0000-4000-8000-000000000002' - }) - renderSwitcher() - await waitFor(() => - expect(screen.getByTestId('release-switcher-current')).toHaveTextContent( - 'Studio Build v2' - ) - ) - expect(screen.getByTestId('release-switcher-following')).toHaveTextContent( - 'Workspace default' - ) - await userEvent.click(screen.getByTestId('release-switcher-trigger')) - expect( - screen.getByTestId('release-row-aaaaaaaa-0000-4000-8000-000000000002') - ).toHaveTextContent('Workspace default') - expect(screen.queryByTestId('release-row-follow')).toBeNull() - expect(screen.queryByTestId('release-switcher-owner')).toBeNull() - }) - - it('offers a browser with its own pick the workspace default, which clears with follow=workspace', async () => { - mockWorkspaceApi.listReleases.mockResolvedValue({ - ...listing, - pick_source: 'browser', - default_release_id: 'aaaaaaaa-0000-4000-8000-000000000002' - }) - mockWorkspaceApi.clearRelease.mockResolvedValue(undefined) - renderSwitcher() - await userEvent.click(await screen.findByTestId('release-switcher-trigger')) - expect(screen.queryByTestId('release-switcher-following')).toBeNull() - - const follow = screen.getByTestId('release-row-follow') - expect(follow).toHaveTextContent('Studio Build v2') - await userEvent.click(follow) - - expect(mockWorkspaceApi.clearRelease).toHaveBeenCalledWith('ws-1', { - follow: 'workspace' - }) - await waitFor(() => expect(reload).toHaveBeenCalledOnce()) - }) - - it('lets an owner set the picked Release as the workspace default, and clear it', async () => { - Object.assign(useTeamWorkspaceStore(), { - workspaceId: 'ws-1', - activeWorkspace: { id: 'ws-1', role: 'owner' } - }) - mockWorkspaceApi.listReleases - .mockResolvedValueOnce({ - ...listing, - picked_release_id: 'aaaaaaaa-0000-4000-8000-000000000002', - pick_source: 'browser' - }) - .mockResolvedValue({ - ...listing, - picked_release_id: 'aaaaaaaa-0000-4000-8000-000000000002', - pick_source: 'browser', - default_release_id: 'aaaaaaaa-0000-4000-8000-000000000002' - }) - mockWorkspaceApi.setDefaultRelease.mockResolvedValue(undefined) - mockWorkspaceApi.clearDefaultRelease.mockResolvedValue(undefined) - renderSwitcher() - await userEvent.click(await screen.findByTestId('release-switcher-trigger')) - - const owner = screen.getByTestId('release-switcher-owner') - expect(owner).toHaveTextContent('No workspace default') - expect(screen.queryByTestId('release-switcher-clear-default')).toBeNull() - await userEvent.click(screen.getByTestId('release-switcher-set-default')) - - expect(mockWorkspaceApi.setDefaultRelease).toHaveBeenCalledWith('ws-1', { - release_id: 'aaaaaaaa-0000-4000-8000-000000000002' - }) - await waitFor(() => - expect(owner).toHaveTextContent('Workspace default: Studio Build v2') - ) - expect(reload).not.toHaveBeenCalled() - expect(screen.queryByTestId('release-switcher-set-default')).toBeNull() - - await userEvent.click(screen.getByTestId('release-switcher-clear-default')) - expect(mockWorkspaceApi.clearDefaultRelease).toHaveBeenCalledWith('ws-1') - }) - - it('shows a member the workspace default but no way to change it', async () => { - mockWorkspaceApi.listReleases.mockResolvedValue({ - ...listing, - picked_release_id: 'aaaaaaaa-0000-4000-8000-000000000002', - pick_source: 'browser', - default_release_id: 'bbbbbbbb-0000-4000-8000-000000000009' - }) - renderSwitcher() - await userEvent.click(await screen.findByTestId('release-switcher-trigger')) - expect(screen.queryByTestId('release-switcher-owner')).toBeNull() - expect(screen.getByTestId('release-row-follow')).toHaveTextContent( - 'Release bbbbbbbb' - ) - }) - - it('shows why the list is unavailable', async () => { - mockWorkspaceApi.listReleases.mockRejectedValue( - new WorkspaceApiError( - 'could not list releases from comfy-deploy; try again', - 503 - ) - ) - renderSwitcher() - await userEvent.click(await screen.findByTestId('release-switcher-trigger')) - expect( - screen.getByTestId('release-switcher-unavailable') - ).toHaveTextContent('could not list releases from comfy-deploy; try again') - }) -}) diff --git a/src/platform/workspace/components/ReleaseSwitcher.vue b/src/platform/workspace/components/ReleaseSwitcher.vue deleted file mode 100644 index 5140ba35e0e..00000000000 --- a/src/platform/workspace/components/ReleaseSwitcher.vue +++ /dev/null @@ -1,328 +0,0 @@ - - - - diff --git a/src/platform/workspace/composables/useDeploymentLabels.ts b/src/platform/workspace/composables/useDeploymentLabels.ts new file mode 100644 index 00000000000..60b5288e1a1 --- /dev/null +++ b/src/platform/workspace/composables/useDeploymentLabels.ts @@ -0,0 +1,73 @@ +import type { WorkspaceDeployment } from '@comfyorg/ingest-types' +import { storeToRefs } from 'pinia' +import { computed } from 'vue' +import { useI18n } from 'vue-i18n' + +import { useDeploymentPickStore } from '@/platform/workspace/stores/deploymentPickStore' + +/** `dep-f24d36bb` out of `dep-f24d36bb-fd1f-...`: enough to tell two apart. */ +function shortId(deploymentId: string): string { + return deploymentId.slice(0, 12) +} + +/** + * The words the deployment switcher shows (FE-2434): a deployment's label + * (its Build name and the Release version it runs now, or its short id when + * Build names are hidden), its caption, and the labels of this browser's pick + * and of the workspace's default deployment. + */ +export function useDeploymentLabels() { + const { t } = useI18n() + const { + pickedDeploymentId, + pickedDeployment, + defaultDeploymentId, + defaultDeployment + } = storeToRefs(useDeploymentPickStore()) + + function deploymentLabel(deployment: WorkspaceDeployment): string { + if ( + deployment.build_name !== undefined && + deployment.release_version !== undefined + ) { + return t('deploymentSwitcher.deployment', { + build: deployment.build_name, + version: deployment.release_version + }) + } + return t('deploymentSwitcher.unnamedDeployment', { + id: shortId(deployment.deployment_id) + }) + } + + /** The id and status, marking the workspace's default deployment. */ + function deploymentCaption(deployment: WorkspaceDeployment): string { + const caption = t('deploymentSwitcher.caption', { + id: shortId(deployment.deployment_id), + status: deployment.status + }) + return deployment.deployment_id === defaultDeploymentId.value + ? `${caption} · ${t('deploymentSwitcher.workspaceDefault')}` + : caption + } + + function labelFor( + deploymentId: string | null, + deployment: WorkspaceDeployment | null + ): string { + if (deploymentId === null) return t('deploymentSwitcher.comfyCloud') + if (deployment) return deploymentLabel(deployment) + return t('deploymentSwitcher.unnamedDeployment', { + id: shortId(deploymentId) + }) + } + + const currentLabel = computed(() => + labelFor(pickedDeploymentId.value, pickedDeployment.value) + ) + const defaultLabel = computed(() => + labelFor(defaultDeploymentId.value, defaultDeployment.value) + ) + + return { deploymentLabel, deploymentCaption, currentLabel, defaultLabel } +} diff --git a/src/platform/workspace/deploymentPickState.test.ts b/src/platform/workspace/deploymentPickState.test.ts new file mode 100644 index 00000000000..c6b8a4f9c43 --- /dev/null +++ b/src/platform/workspace/deploymentPickState.test.ts @@ -0,0 +1,176 @@ +import { describe, expect, it } from 'vitest' + +import type { WorkspaceDeployment } from '@comfyorg/ingest-types' + +import type { + DeploymentPickEvent, + DeploymentPickState +} from './deploymentPickState' +import { loadedEvent, reduceDeploymentPick } from './deploymentPickState' + +const deployment: WorkspaceDeployment = { + deployment_id: 'dep-1', + release_id: 'r-1', + build_name: 'Studio Build', + release_version: 1, + status: 'ready', + created_at: '2026-10-01T00:00:00Z' +} + +const loaded: DeploymentPickEvent = { + type: 'loaded', + deployments: [deployment], + pickedDeploymentId: 'dep-1', + pickSource: 'browser', + defaultDeploymentId: null, + buildsVisible: true +} + +const ready: DeploymentPickState = { + phase: 'ready', + deployments: [deployment], + pickedDeploymentId: 'dep-1', + pickSource: 'browser', + defaultDeploymentId: null, + buildsVisible: true +} + +describe('reduceDeploymentPick', () => { + const switching: DeploymentPickState = { + ...ready, + phase: 'switching', + target: null + } + + it('loads into ready, or into hidden when refused or failed with nothing shown', () => { + expect(reduceDeploymentPick({ phase: 'idle' }, loaded)).toEqual(ready) + expect(reduceDeploymentPick({ phase: 'hidden' }, loaded)).toEqual(ready) + for (const state of [ + { phase: 'idle' }, + { phase: 'hidden' } + ] satisfies DeploymentPickState[]) { + expect(reduceDeploymentPick(state, { type: 'loadRefused' })).toEqual({ + phase: 'hidden' + }) + expect(reduceDeploymentPick(state, { type: 'loadFailed' })).toEqual({ + phase: 'hidden' + }) + } + }) + + it('keeps a listing on screen when a reload of it fails, but hides on a refusal', () => { + expect(reduceDeploymentPick(ready, { type: 'loadFailed' })).toBe(ready) + expect(reduceDeploymentPick(switching, { type: 'loadFailed' })).toBe( + switching + ) + expect(reduceDeploymentPick(ready, { type: 'loadRefused' })).toEqual({ + phase: 'hidden' + }) + }) + + it('switches only from ready, and a failed switch returns to ready', () => { + expect( + reduceDeploymentPick(ready, { type: 'switchStarted', target: null }) + ).toEqual(switching) + expect(reduceDeploymentPick(switching, { type: 'switchFailed' })).toEqual( + ready + ) + + for (const state of [ + { phase: 'idle' }, + { phase: 'hidden' } + ] satisfies DeploymentPickState[]) { + expect( + reduceDeploymentPick(state, { type: 'switchStarted', target: 'dep-1' }) + ).toBe(state) + } + expect(reduceDeploymentPick(ready, { type: 'switchFailed' })).toBe(ready) + }) + + it('keeps a switch in flight when a listing lands, and takes the new listing', () => { + const newer: DeploymentPickEvent = { + ...loaded, + pickedDeploymentId: null, + pickSource: null, + defaultDeploymentId: 'dep-1' + } + const landed = reduceDeploymentPick( + { ...switching, target: 'dep-1' }, + newer + ) + expect(landed).toEqual({ + phase: 'switching', + target: 'dep-1', + deployments: [deployment], + pickedDeploymentId: null, + pickSource: null, + defaultDeploymentId: 'dep-1', + buildsVisible: true + }) + // A refused switch then returns to the newer listing, not the old one. + expect(reduceDeploymentPick(landed, { type: 'switchFailed' })).toEqual({ + ...ready, + pickedDeploymentId: null, + pickSource: null, + defaultDeploymentId: 'dep-1' + }) + }) + + it('a new default the server took ends the switch and shows at once', () => { + expect( + reduceDeploymentPick(switching, { + type: 'defaultChanged', + defaultDeploymentId: 'dep-1' + }) + ).toEqual({ ...ready, defaultDeploymentId: 'dep-1' }) + expect( + reduceDeploymentPick( + { ...switching, defaultDeploymentId: 'dep-1' }, + { type: 'defaultChanged', defaultDeploymentId: null } + ) + ).toEqual(ready) + // A refusal that landed meanwhile still hides it. + const hidden: DeploymentPickState = { phase: 'hidden' } + expect( + reduceDeploymentPick(hidden, { + type: 'defaultChanged', + defaultDeploymentId: 'dep-1' + }) + ).toBe(hidden) + }) +}) + +describe('loadedEvent', () => { + it('carries the listing, with absent fields as null', () => { + expect( + loadedEvent({ + items: [deployment], + pick_source: 'browser', + builds_visible: false + }) + ).toEqual({ + type: 'loaded', + deployments: [deployment], + pickedDeploymentId: null, + pickSource: 'browser', + defaultDeploymentId: null, + buildsVisible: false + }) + }) + + it('keeps the pick and the workspace default the listing names', () => { + expect( + loadedEvent({ + items: [deployment], + picked_deployment_id: 'dep-1', + pick_source: 'workspace_default', + default_deployment_id: 'dep-1', + builds_visible: true + }) + ).toMatchObject({ + pickedDeploymentId: 'dep-1', + pickSource: 'workspace_default', + defaultDeploymentId: 'dep-1' + }) + }) +}) diff --git a/src/platform/workspace/deploymentPickState.ts b/src/platform/workspace/deploymentPickState.ts new file mode 100644 index 00000000000..3b0f403a794 --- /dev/null +++ b/src/platform/workspace/deploymentPickState.ts @@ -0,0 +1,128 @@ +import type { + WorkspaceDeployment, + WorkspaceDeploymentList +} from '@comfyorg/ingest-types' + +/** + * Which developer-platform deployment this browser runs its Cloud jobs on, and + * the list it may pick from (FE-2434). A deployment keeps one URL while its + * owner updates it to new Releases, so a pick follows those updates. The pick + * itself is an HttpOnly cookie ingest sets; the editor learns it from the + * listing and never reads it. + */ +/** Where the current pick came from (BE-17480). */ +export type DeploymentPickSource = 'browser' | 'workspace_default' + +interface DeploymentListing { + deployments: WorkspaceDeployment[] + pickedDeploymentId: string | null + /** + * `browser` when this browser picked for itself (a deployment, or + * Comfy Cloud); `workspace_default` when it follows the workspace's default + * deployment; null when there is neither, so it runs on Comfy Cloud. + */ + pickSource: DeploymentPickSource | null + /** The workspace's default deployment an owner set, or null. */ + defaultDeploymentId: string | null + buildsVisible: boolean +} + +/** + * A reload of the listing does not change the state until it answers: the + * last listing stays on screen (or the switcher stays hidden) meanwhile, so + * reopening the popover never flashes "Comfy Cloud" or no default. A listing + * that lands while a switch is in flight updates what is shown but does not + * end the switch, so a second pick cannot go out before the first answers. + */ +export type DeploymentPickState = + /** Nothing has answered yet; the switcher is not shown. */ + | { phase: 'idle' } + /** + * The account is outside the rollout, the session cannot pick, or the + * first listing failed (for example ingest without these routes). + */ + | { phase: 'hidden' } + | ({ phase: 'ready' } & DeploymentListing) + /** + * A pick, a clear or a new default is in flight. A pick or a clear reloads + * the page on success; a new default reloads it only when this browser has + * no pick of its own, since only then does it change what this browser + * runs on. + */ + | ({ phase: 'switching'; target: string | null } & DeploymentListing) + +export type DeploymentPickEvent = + | ({ type: 'loaded' } & DeploymentListing) + /** A 403: the account is outside the rollout, whatever was shown before. */ + | { type: 'loadRefused' } + /** Any other failure: keep a listing already shown, else stay hidden. */ + | { type: 'loadFailed' } + | { type: 'switchStarted'; target: string | null } + /** The server refused the switch. */ + | { type: 'switchFailed' } + /** + * The server took a new workspace default (or its clearing) and this + * browser does not reload: show it now, whatever the refresh after it + * answers, and end the switch. + */ + | { type: 'defaultChanged'; defaultDeploymentId: string | null } + +/** The `loaded` event for a listing from GET /api/workspaces/{id}/deployments. */ +export function loadedEvent( + listing: WorkspaceDeploymentList +): DeploymentPickEvent { + return { + type: 'loaded', + deployments: listing.items, + pickedDeploymentId: listing.picked_deployment_id ?? null, + pickSource: listing.pick_source ?? null, + defaultDeploymentId: listing.default_deployment_id ?? null, + buildsVisible: listing.builds_visible + } +} + +/** The listing fields of a state or a `loaded` event, without the rest. */ +function listingOf(source: DeploymentListing): DeploymentListing { + return { + deployments: source.deployments, + pickedDeploymentId: source.pickedDeploymentId, + pickSource: source.pickSource, + defaultDeploymentId: source.defaultDeploymentId, + buildsVisible: source.buildsVisible + } +} + +export function reduceDeploymentPick( + state: DeploymentPickState, + event: DeploymentPickEvent +): DeploymentPickState { + switch (event.type) { + case 'loaded': + // A switch in flight stays in flight; it shows the newer listing. + if (state.phase === 'switching') { + return { + phase: 'switching', + target: state.target, + ...listingOf(event) + } + } + return { phase: 'ready', ...listingOf(event) } + case 'loadRefused': + return { phase: 'hidden' } + case 'loadFailed': + return 'deployments' in state ? state : { phase: 'hidden' } + case 'switchStarted': + if (state.phase !== 'ready') return state + return { phase: 'switching', target: event.target, ...listingOf(state) } + case 'switchFailed': + if (state.phase !== 'switching') return state + return { phase: 'ready', ...listingOf(state) } + case 'defaultChanged': + if (state.phase !== 'switching') return state + return { + phase: 'ready', + ...listingOf(state), + defaultDeploymentId: event.defaultDeploymentId + } + } +} diff --git a/src/platform/workspace/releasePickState.test.ts b/src/platform/workspace/releasePickState.test.ts deleted file mode 100644 index 11d2bdde705..00000000000 --- a/src/platform/workspace/releasePickState.test.ts +++ /dev/null @@ -1,83 +0,0 @@ -import { describe, expect, it } from 'vitest' - -import type { WorkspaceRelease } from '@comfyorg/ingest-types' - -import type { ReleasePickEvent, ReleasePickState } from './releasePickState' -import { reduceReleasePick } from './releasePickState' - -const release: WorkspaceRelease = { - release_id: 'r-1', - build_name: 'Studio Build', - version: 1, - deployed: true, - deployment_status: 'ready' -} - -const loaded: ReleasePickEvent = { - type: 'loaded', - releases: [release], - pickedReleaseId: 'r-1', - pickSource: 'browser', - defaultReleaseId: null, - buildsVisible: true -} - -const ready: ReleasePickState = { - phase: 'ready', - releases: [release], - pickedReleaseId: 'r-1', - pickSource: 'browser', - defaultReleaseId: null, - buildsVisible: true -} - -describe('reduceReleasePick', () => { - it('loads into ready, or into hidden or unavailable when refused or failed', () => { - expect( - reduceReleasePick({ phase: 'idle' }, { type: 'loadStarted' }) - ).toEqual({ phase: 'loading' }) - expect(reduceReleasePick({ phase: 'loading' }, loaded)).toEqual(ready) - expect( - reduceReleasePick({ phase: 'loading' }, { type: 'loadRefused' }) - ).toEqual({ phase: 'hidden' }) - expect( - reduceReleasePick( - { phase: 'loading' }, - { type: 'loadFailed', message: 'comfy-deploy is down' } - ) - ).toEqual({ phase: 'unavailable', message: 'comfy-deploy is down' }) - }) - - it('switches only from ready, and a failed switch returns to ready', () => { - const switching = reduceReleasePick(ready, { - type: 'switchStarted', - target: null - }) - expect(switching).toEqual({ ...ready, phase: 'switching', target: null }) - expect(reduceReleasePick(switching, { type: 'switchFailed' })).toEqual( - ready - ) - - for (const state of [ - { phase: 'idle' }, - { phase: 'loading' }, - { phase: 'hidden' }, - { phase: 'unavailable', message: 'x' } - ] satisfies ReleasePickState[]) { - expect( - reduceReleasePick(state, { type: 'switchStarted', target: 'r-1' }) - ).toBe(state) - } - expect(reduceReleasePick(ready, { type: 'switchFailed' })).toBe(ready) - }) - - it('does not drop an in-flight switch for a reload of the list', () => { - const switching = reduceReleasePick(ready, { - type: 'switchStarted', - target: 'r-1' - }) - expect(reduceReleasePick(switching, { type: 'loadStarted' })).toBe( - switching - ) - }) -}) diff --git a/src/platform/workspace/releasePickState.ts b/src/platform/workspace/releasePickState.ts deleted file mode 100644 index 54ea797a077..00000000000 --- a/src/platform/workspace/releasePickState.ts +++ /dev/null @@ -1,85 +0,0 @@ -import type { WorkspaceRelease } from '@comfyorg/ingest-types' - -/** - * Which developer-platform Release this browser runs its Cloud jobs on, and - * the list it may pick from (FE-2434). The pick itself is an HttpOnly cookie - * ingest sets; the editor learns it from the listing and never reads it. - */ -/** Where the current pick came from (BE-17480). */ -export type ReleasePickSource = 'browser' | 'workspace_default' - -export interface ReleaseListing { - releases: WorkspaceRelease[] - pickedReleaseId: string | null - /** - * `browser` when this browser picked for itself (a Release, or Comfy - * Cloud); `workspace_default` when it follows the workspace's default - * Release; null when there is neither, so it runs on Comfy Cloud. - */ - pickSource: ReleasePickSource | null - /** The workspace's default Release an owner set, or null. */ - defaultReleaseId: string | null - buildsVisible: boolean -} - -export type ReleasePickState = - | { phase: 'idle' } - | { phase: 'loading' } - /** The account is outside the rollout, or the session cannot pick. */ - | { phase: 'hidden' } - | { phase: 'unavailable'; message: string } - | ({ phase: 'ready' } & ReleaseListing) - /** A pick or a clear is in flight; on success the page reloads. */ - | ({ phase: 'switching'; target: string | null } & ReleaseListing) - -export type ReleasePickEvent = - | { type: 'loadStarted' } - | ({ type: 'loaded' } & ReleaseListing) - | { type: 'loadRefused' } - | { type: 'loadFailed'; message: string } - | { type: 'switchStarted'; target: string | null } - | { type: 'switchFailed' } - -export function reduceReleasePick( - state: ReleasePickState, - event: ReleasePickEvent -): ReleasePickState { - switch (event.type) { - case 'loadStarted': - return state.phase === 'switching' ? state : { phase: 'loading' } - case 'loaded': - return { - phase: 'ready', - releases: event.releases, - pickedReleaseId: event.pickedReleaseId, - pickSource: event.pickSource, - defaultReleaseId: event.defaultReleaseId, - buildsVisible: event.buildsVisible - } - case 'loadRefused': - return { phase: 'hidden' } - case 'loadFailed': - return { phase: 'unavailable', message: event.message } - case 'switchStarted': - if (state.phase !== 'ready') return state - return { - phase: 'switching', - target: event.target, - releases: state.releases, - pickedReleaseId: state.pickedReleaseId, - pickSource: state.pickSource, - defaultReleaseId: state.defaultReleaseId, - buildsVisible: state.buildsVisible - } - case 'switchFailed': - if (state.phase !== 'switching') return state - return { - phase: 'ready', - releases: state.releases, - pickedReleaseId: state.pickedReleaseId, - pickSource: state.pickSource, - defaultReleaseId: state.defaultReleaseId, - buildsVisible: state.buildsVisible - } - } -} diff --git a/src/platform/workspace/stores/deploymentPickStore.test.ts b/src/platform/workspace/stores/deploymentPickStore.test.ts new file mode 100644 index 00000000000..8b292a10e56 --- /dev/null +++ b/src/platform/workspace/stores/deploymentPickStore.test.ts @@ -0,0 +1,775 @@ +import { beforeEach, describe, expect, it, vi } from 'vitest' + +import type { WorkspaceDeploymentList } from '@comfyorg/ingest-types' + +import { WorkspaceApiError } from '@/platform/workspace/api/workspaceApi' + +import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' + +import { useDeploymentPickStore } from './deploymentPickStore' + +const mockWorkspaceApi = vi.hoisted(() => ({ + listDeployments: vi.fn(), + pickDeployment: vi.fn(), + clearDeployment: vi.fn(), + setDefaultDeployment: vi.fn(), + clearDefaultDeployment: vi.fn() +})) + +vi.mock(import('@/platform/workspace/api/workspaceApi'), async () => { + class WorkspaceApiError extends Error { + constructor( + message: string, + public readonly status?: number, + public readonly code?: string + ) { + super(message) + this.name = 'WorkspaceApiError' + } + } + return { workspaceApi: mockWorkspaceApi, WorkspaceApiError } +}) + +const listing: WorkspaceDeploymentList = { + builds_visible: true, + picked_deployment_id: 'dep-2', + pick_source: 'browser', + items: [ + { + deployment_id: 'dep-2', + release_id: 'r-2', + build_id: 'b-1', + build_name: 'Studio Build', + release_version: 2, + status: 'ready', + created_at: '2026-10-01T00:00:00Z' + }, + { + deployment_id: 'dep-1', + release_id: 'r-1', + build_id: 'b-1', + build_name: 'Studio Build', + release_version: 1, + status: 'stopped', + created_at: '2026-09-20T00:00:00Z' + } + ] +} + +describe('useDeploymentPickStore', () => { + const reload = vi.fn() + + beforeEach(() => { + Object.assign(useTeamWorkspaceStore(), { workspaceId: 'ws-1' }) + Object.defineProperty(window, 'location', { + value: { reload, origin: 'http://localhost' }, + writable: true, + configurable: true + }) + }) + + it('loads the listing and knows which deployment is picked', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue(listing) + const store = useDeploymentPickStore() + expect(store.isVisible).toBe(false) + + await store.load() + + expect(mockWorkspaceApi.listDeployments).toHaveBeenCalledWith('ws-1') + expect(store.state.phase).toBe('ready') + expect(store.isVisible).toBe(true) + expect(store.deployments).toHaveLength(2) + expect(store.pickedDeploymentId).toBe('dep-2') + expect(store.pickedDeployment?.build_name).toBe('Studio Build') + expect(store.pickSource).toBe('browser') + expect(store.followsWorkspace).toBe(false) + expect(store.defaultDeploymentId).toBeNull() + expect(store.canSetDefault).toBe(false) + }) + + it('follows the workspace default when the browser has no pick of its own', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue({ + ...listing, + pick_source: 'workspace_default', + default_deployment_id: 'dep-2' + }) + const store = useDeploymentPickStore() + await store.load() + + expect(store.pickedDeploymentId).toBe('dep-2') + expect(store.pickSource).toBe('workspace_default') + expect(store.followsWorkspace).toBe(true) + expect(store.defaultDeploymentId).toBe('dep-2') + expect(store.defaultDeployment?.release_version).toBe(2) + + // Already following: nothing to drop. + await expect(store.followWorkspace()).resolves.toBeNull() + expect(mockWorkspaceApi.clearDeployment).not.toHaveBeenCalled() + + // Picking Comfy Cloud is this browser's own choice, even though the + // browser runs on dep-2 only because it follows the default: it goes + // through the clear route and reloads. + mockWorkspaceApi.clearDeployment.mockResolvedValue(undefined) + await expect(store.pick(null)).resolves.toBeNull() + expect(mockWorkspaceApi.clearDeployment).toHaveBeenCalledWith('ws-1') + expect(reload).toHaveBeenCalledOnce() + }) + + it('drops its own pick to follow the workspace, through the clear route with follow=workspace', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue({ + ...listing, + picked_deployment_id: 'dep-1', + default_deployment_id: 'dep-2' + }) + mockWorkspaceApi.clearDeployment.mockResolvedValue(undefined) + const store = useDeploymentPickStore() + await store.load() + + await expect(store.followWorkspace()).resolves.toBeNull() + + expect(mockWorkspaceApi.clearDeployment).toHaveBeenCalledWith('ws-1', { + follow: 'workspace' + }) + expect(reload).toHaveBeenCalledOnce() + }) + + it('an owner sets the picked deployment as the workspace default and the listing refreshes', async () => { + Object.assign(useTeamWorkspaceStore(), { + workspaceId: 'ws-1', + activeWorkspace: { id: 'ws-1', role: 'owner' } + }) + mockWorkspaceApi.listDeployments + .mockResolvedValueOnce(listing) + .mockResolvedValueOnce({ ...listing, default_deployment_id: 'dep-2' }) + mockWorkspaceApi.setDefaultDeployment.mockResolvedValue(undefined) + const store = useDeploymentPickStore() + await store.load() + expect(store.canSetDefault).toBe(true) + + await expect(store.setDefault('dep-2')).resolves.toBeNull() + + expect(mockWorkspaceApi.setDefaultDeployment).toHaveBeenCalledWith('ws-1', { + deployment_id: 'dep-2' + }) + expect(reload).not.toHaveBeenCalled() + expect(store.state.phase).toBe('ready') + expect(store.defaultDeploymentId).toBe('dep-2') + + // Clearing it, likewise; setting what is already set is a no-op. + await expect(store.setDefault('dep-2')).resolves.toBeNull() + expect(mockWorkspaceApi.setDefaultDeployment).toHaveBeenCalledOnce() + mockWorkspaceApi.listDeployments.mockResolvedValueOnce(listing) + mockWorkspaceApi.clearDefaultDeployment.mockResolvedValue(undefined) + await expect(store.setDefault(null)).resolves.toBeNull() + expect(mockWorkspaceApi.clearDefaultDeployment).toHaveBeenCalledWith('ws-1') + expect(store.defaultDeploymentId).toBeNull() + }) + + it('a browser that follows the workspace reloads when its owner changes the default', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue({ + ...listing, + picked_deployment_id: undefined, + pick_source: undefined + }) + mockWorkspaceApi.setDefaultDeployment.mockResolvedValue(undefined) + const store = useDeploymentPickStore() + await store.load() + expect(store.followsWorkspace).toBe(true) + + await expect(store.setDefault('dep-2')).resolves.toBeNull() + expect(reload).toHaveBeenCalledOnce() + }) + + it("hands back the server's refusal of a default and stays ready", async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue(listing) + mockWorkspaceApi.setDefaultDeployment.mockRejectedValue( + new WorkspaceApiError( + 'only a workspace owner can set the default deployment', + 403 + ) + ) + const store = useDeploymentPickStore() + await store.load() + + await expect(store.setDefault('dep-1')).resolves.toBe( + 'only a workspace owner can set the default deployment' + ) + expect(store.state.phase).toBe('ready') + expect(store.defaultDeploymentId).toBeNull() + expect(reload).not.toHaveBeenCalled() + }) + + it('hides itself when the account is outside the rollout', async () => { + mockWorkspaceApi.listDeployments.mockRejectedValue( + new WorkspaceApiError( + 'not enabled for this account yet', + 403, + 'FORBIDDEN' + ) + ) + const store = useDeploymentPickStore() + await store.load() + expect(store.state.phase).toBe('hidden') + expect(store.isVisible).toBe(false) + }) + + it('picks a deployment and reloads the page', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue(listing) + mockWorkspaceApi.pickDeployment.mockResolvedValue(undefined) + const store = useDeploymentPickStore() + await store.load() + + await expect(store.pick('dep-1')).resolves.toBeNull() + + expect(mockWorkspaceApi.pickDeployment).toHaveBeenCalledWith('ws-1', { + deployment_id: 'dep-1' + }) + expect(reload).toHaveBeenCalledOnce() + }) + + it('clears the pick for Comfy Cloud and reloads', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue(listing) + mockWorkspaceApi.clearDeployment.mockResolvedValue(undefined) + const store = useDeploymentPickStore() + await store.load() + + await expect(store.pick(null)).resolves.toBeNull() + + expect(mockWorkspaceApi.clearDeployment).toHaveBeenCalledWith('ws-1') + expect(mockWorkspaceApi.pickDeployment).not.toHaveBeenCalled() + expect(reload).toHaveBeenCalledOnce() + }) + + it('hands back a refused pick and stays ready, without reloading', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue(listing) + mockWorkspaceApi.pickDeployment.mockRejectedValue( + new WorkspaceApiError( + "deployment dep-1 is not one of this workspace's", + 422 + ) + ) + const store = useDeploymentPickStore() + await store.load() + + await expect(store.pick('dep-1')).resolves.toBe( + "deployment dep-1 is not one of this workspace's" + ) + expect(store.state.phase).toBe('ready') + expect(store.pickedDeploymentId).toBe('dep-2') + expect(reload).not.toHaveBeenCalled() + }) + + it('picking the current deployment is a no-op', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue(listing) + const store = useDeploymentPickStore() + await store.load() + + await expect(store.pick('dep-2')).resolves.toBeNull() + expect(mockWorkspaceApi.pickDeployment).not.toHaveBeenCalled() + expect(reload).not.toHaveBeenCalled() + }) + + it('ignores a listing that arrives after the workspace changed', async () => { + let resolve: (value: WorkspaceDeploymentList) => void = () => {} + mockWorkspaceApi.listDeployments.mockReturnValue( + new Promise((r) => { + resolve = r + }) + ) + const store = useDeploymentPickStore() + const loading = store.load() + Object.assign(useTeamWorkspaceStore(), { workspaceId: 'ws-2' }) + resolve(listing) + await loading + + expect(store.state.phase).toBe('idle') + expect(store.deployments).toEqual([]) + }) + + it('does nothing without an active workspace', async () => { + Object.assign(useTeamWorkspaceStore(), { workspaceId: null }) + const store = useDeploymentPickStore() + await store.load() + expect(mockWorkspaceApi.listDeployments).not.toHaveBeenCalled() + expect(store.state.phase).toBe('idle') + }) + + describe('while the listing loads', () => { + it('stays hidden until the first listing answers', async () => { + const listed = deferred() + mockWorkspaceApi.listDeployments.mockReturnValue(listed.promise) + const store = useDeploymentPickStore() + + const loading = store.load() + expect(store.isVisible).toBe(false) + + listed.resolve(listing) + await loading + expect(store.isVisible).toBe(true) + }) + + it('stays hidden while it reloads for an account the last answer hid', async () => { + mockWorkspaceApi.listDeployments.mockRejectedValueOnce( + new WorkspaceApiError('not enabled for this account yet', 403) + ) + const store = useDeploymentPickStore() + await store.load() + expect(store.isVisible).toBe(false) + + // The popover remounts the switcher on every open, so every open reloads. + const listed = deferred() + mockWorkspaceApi.listDeployments.mockReturnValue(listed.promise) + void store.load() + expect(store.isVisible).toBe(false) + }) + + it('keeps the last listing on screen until the new one lands', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValueOnce({ + ...listing, + default_deployment_id: 'dep-1' + }) + const store = useDeploymentPickStore() + await store.load() + + const listed = deferred() + mockWorkspaceApi.listDeployments.mockReturnValue(listed.promise) + const reloading = store.load() + expect(store.isVisible).toBe(true) + expect(store.pickedDeploymentId).toBe('dep-2') + expect(store.defaultDeploymentId).toBe('dep-1') + expect(store.deployments).toHaveLength(2) + + listed.resolve({ ...listing, picked_deployment_id: 'dep-1' }) + await reloading + expect(store.pickedDeploymentId).toBe('dep-1') + }) + + it('shows the new default at once while the listing refreshes after an owner changes it', async () => { + Object.assign(useTeamWorkspaceStore(), { + workspaceId: 'ws-1', + activeWorkspace: { id: 'ws-1', role: 'owner' } + }) + mockWorkspaceApi.listDeployments.mockResolvedValueOnce({ + ...listing, + default_deployment_id: 'dep-1' + }) + mockWorkspaceApi.setDefaultDeployment.mockResolvedValue(undefined) + const store = useDeploymentPickStore() + await store.load() + + const listed = deferred() + mockWorkspaceApi.listDeployments.mockReturnValue(listed.promise) + const setting = store.setDefault('dep-2') + await vi.waitFor(() => + expect(mockWorkspaceApi.listDeployments).toHaveBeenCalledTimes(2) + ) + expect(store.defaultDeploymentId).toBe('dep-2') + expect(store.isSwitching).toBe(false) + + listed.resolve({ ...listing, default_deployment_id: 'dep-2' }) + await setting + expect(store.defaultDeploymentId).toBe('dep-2') + }) + + it('keeps the switcher locked when a listing lands while a pick is in flight', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValueOnce(listing) + const store = useDeploymentPickStore() + await store.load() + + // The popover was reopened: a reload is in flight, the rows are clickable. + const listed = deferred() + mockWorkspaceApi.listDeployments.mockReturnValueOnce(listed.promise) + const reloading = store.load() + const put = deferred() + mockWorkspaceApi.pickDeployment.mockReturnValueOnce(put.promise) + const picking = store.pick('dep-1') + + listed.resolve({ ...listing, default_deployment_id: 'dep-1' }) + await reloading + expect(store.isSwitching).toBe(true) + expect(store.state).toMatchObject({ phase: 'switching', target: 'dep-1' }) + expect(store.defaultDeploymentId).toBe('dep-1') + + // A second pick cannot go out while the first is in flight. + await expect(store.pick(null)).resolves.toBeNull() + expect(mockWorkspaceApi.clearDeployment).not.toHaveBeenCalled() + + put.resolve() + await picking + expect(mockWorkspaceApi.pickDeployment).toHaveBeenCalledOnce() + expect(reload).toHaveBeenCalledOnce() + }) + + it('returns to the newer listing when a pick that a listing overtook is refused', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValueOnce(listing) + const store = useDeploymentPickStore() + await store.load() + + const listed = deferred() + mockWorkspaceApi.listDeployments.mockReturnValueOnce(listed.promise) + const reloading = store.load() + const put = deferred() + mockWorkspaceApi.pickDeployment.mockReturnValueOnce(put.promise) + const picking = store.pick('dep-1') + listed.resolve({ ...listing, default_deployment_id: 'dep-1' }) + await reloading + + put.reject( + new WorkspaceApiError("deployment is not one of this workspace's", 422) + ) + await expect(picking).resolves.toBe( + "deployment is not one of this workspace's" + ) + expect(store.state.phase).toBe('ready') + expect(store.defaultDeploymentId).toBe('dep-1') + expect(reload).not.toHaveBeenCalled() + }) + }) + + describe('when the listing fails', () => { + it.for([ + ['a 400', new WorkspaceApiError('invalid workspace id', 400)], + ['a 401', new WorkspaceApiError('Authentication required', 401)], + ['a 403', new WorkspaceApiError('not enabled for this account yet', 403)], + [ + 'a 404 (ingest without the routes)', + new WorkspaceApiError('404 page not found', 404) + ], + ['a 500', new WorkspaceApiError('Failed to list deployments', 500)], + [ + 'a 503', + new WorkspaceApiError( + 'could not list deployments from comfy-deploy; try again', + 503 + ) + ], + ['a network error', new WorkspaceApiError('Network Error')], + ['no signed-in user', new Error('User not authenticated')] + ] as const)( + 'hides itself on a first load that fails with %s', + async ([, err]) => { + mockWorkspaceApi.listDeployments.mockRejectedValue(err) + const store = useDeploymentPickStore() + await store.load() + expect(store.state.phase).toBe('hidden') + expect(store.isVisible).toBe(false) + } + ) + + it('keeps the last listing when a refresh fails', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValueOnce(listing) + const store = useDeploymentPickStore() + await store.load() + + mockWorkspaceApi.listDeployments.mockRejectedValueOnce( + new WorkspaceApiError( + 'could not list deployments from comfy-deploy; try again', + 503 + ) + ) + await store.load() + expect(store.state.phase).toBe('ready') + expect(store.isVisible).toBe(true) + expect(store.pickedDeploymentId).toBe('dep-2') + }) + + it('hides itself when a refresh says the account left the rollout', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValueOnce(listing) + const store = useDeploymentPickStore() + await store.load() + + mockWorkspaceApi.listDeployments.mockRejectedValueOnce( + new WorkspaceApiError('not enabled for this account yet', 403) + ) + await store.load() + expect(store.isVisible).toBe(false) + }) + + it('ends the switch when the refresh after a new default fails', async () => { + Object.assign(useTeamWorkspaceStore(), { + workspaceId: 'ws-1', + activeWorkspace: { id: 'ws-1', role: 'owner' } + }) + mockWorkspaceApi.listDeployments + .mockResolvedValueOnce(listing) + .mockRejectedValueOnce(new WorkspaceApiError('Bad Gateway', 502)) + mockWorkspaceApi.setDefaultDeployment.mockResolvedValue(undefined) + const store = useDeploymentPickStore() + await store.load() + + await expect(store.setDefault('dep-2')).resolves.toBeNull() + expect(store.isSwitching).toBe(false) + expect(store.state.phase).toBe('ready') + }) + + it.for([ + ['sets', 'dep-2', 'dep-2'], + ['clears', null, null] + ] as const)( + 'shows the default an owner %s even when the refresh after it fails', + async ([, target, shown]) => { + Object.assign(useTeamWorkspaceStore(), { + workspaceId: 'ws-1', + activeWorkspace: { id: 'ws-1', role: 'owner' } + }) + mockWorkspaceApi.listDeployments + .mockResolvedValueOnce({ ...listing, default_deployment_id: 'dep-1' }) + .mockRejectedValueOnce( + new WorkspaceApiError( + 'could not list deployments from comfy-deploy; try again', + 503 + ) + ) + mockWorkspaceApi.setDefaultDeployment.mockResolvedValue(undefined) + mockWorkspaceApi.clearDefaultDeployment.mockResolvedValue(undefined) + const store = useDeploymentPickStore() + await store.load() + + await expect(store.setDefault(target)).resolves.toBeNull() + expect(mockWorkspaceApi.listDeployments).toHaveBeenCalledTimes(2) + expect(store.defaultDeploymentId).toBe(shown) + expect(store.state.phase).toBe('ready') + // This browser has its own pick, so the new default does not reload it. + expect(reload).not.toHaveBeenCalled() + } + ) + }) + + describe('when answers arrive out of order', () => { + it.for([ + [ + 'fails', + () => + mockWorkspaceApi.listDeployments.mockRejectedValueOnce( + new WorkspaceApiError( + 'could not list deployments from comfy-deploy; try again', + 503 + ) + ) + ], + [ + 'answers first', + () => + mockWorkspaceApi.listDeployments.mockResolvedValueOnce({ + ...listing, + default_deployment_id: 'dep-2' + }) + ] + ] as const)( + 'keeps a new default when a listing asked for before it lands last and the refresh %s', + async ([, queueRefresh]) => { + Object.assign(useTeamWorkspaceStore(), { + workspaceId: 'ws-1', + activeWorkspace: { id: 'ws-1', role: 'owner' } + }) + mockWorkspaceApi.listDeployments.mockResolvedValueOnce({ + ...listing, + default_deployment_id: 'dep-1' + }) + mockWorkspaceApi.setDefaultDeployment.mockResolvedValue(undefined) + const store = useDeploymentPickStore() + await store.load() + + // The popover was reopened: a listing with the old default is in flight. + const stale = deferred() + mockWorkspaceApi.listDeployments.mockReturnValueOnce(stale.promise) + const reloading = store.load() + + queueRefresh() + await expect(store.setDefault('dep-2')).resolves.toBeNull() + expect(store.defaultDeploymentId).toBe('dep-2') + + stale.resolve({ ...listing, default_deployment_id: 'dep-1' }) + await reloading + expect(store.defaultDeploymentId).toBe('dep-2') + expect(store.state.phase).toBe('ready') + } + ) + + it('keeps the newer listing when an older one lands after it', async () => { + const older = deferred() + mockWorkspaceApi.listDeployments + .mockReturnValueOnce(older.promise) + .mockResolvedValueOnce({ ...listing, picked_deployment_id: 'dep-1' }) + const store = useDeploymentPickStore() + const first = store.load() + await store.load() + expect(store.pickedDeploymentId).toBe('dep-1') + + older.resolve(listing) + await first + expect(store.pickedDeploymentId).toBe('dep-1') + }) + + it('stays visible when an older listing fails after a newer one answered', async () => { + const older = deferred() + mockWorkspaceApi.listDeployments + .mockReturnValueOnce(older.promise) + .mockResolvedValueOnce(listing) + const store = useDeploymentPickStore() + const first = store.load() + await store.load() + + older.reject( + new WorkspaceApiError('not enabled for this account yet', 403) + ) + await first + expect(store.isVisible).toBe(true) + expect(store.pickedDeploymentId).toBe('dep-2') + }) + + // The popover was closed and reopened before the first listing answered, + // so two listings are in flight on the first load. + it.for([ + ['a 503', new WorkspaceApiError('upstream', 503)], + ['a network error', new Error('Network Error')] + ] as const)( + 'shows an older listing that answered when the newer one fails with %s', + async ([, error]) => { + const newer = deferred() + mockWorkspaceApi.listDeployments + .mockResolvedValueOnce(listing) + .mockReturnValueOnce(newer.promise) + const store = useDeploymentPickStore() + const first = store.load() + const second = store.load() + await first + expect(store.isVisible).toBe(true) + expect(store.pickedDeploymentId).toBe('dep-2') + + newer.reject(error) + await second + expect(store.state.phase).toBe('ready') + expect(store.pickedDeploymentId).toBe('dep-2') + } + ) + + it('shows an older listing that answered while the newer one never answers', async () => { + mockWorkspaceApi.listDeployments + .mockResolvedValueOnce(listing) + .mockReturnValueOnce(new Promise(() => {})) + const store = useDeploymentPickStore() + const first = store.load() + void store.load() + await first + expect(store.state.phase).toBe('ready') + expect(store.pickedDeploymentId).toBe('dep-2') + }) + + it('shows an older listing that answers after the newer one failed', async () => { + const older = deferred() + mockWorkspaceApi.listDeployments + .mockReturnValueOnce(older.promise) + .mockRejectedValueOnce(new Error('Network Error')) + const store = useDeploymentPickStore() + const first = store.load() + await store.load() + expect(store.isVisible).toBe(false) + + older.resolve(listing) + await first + expect(store.state.phase).toBe('ready') + expect(store.pickedDeploymentId).toBe('dep-2') + }) + + it('hides itself when the newer listing says the account left the rollout', async () => { + const newer = deferred() + mockWorkspaceApi.listDeployments + .mockResolvedValueOnce(listing) + .mockReturnValueOnce(newer.promise) + const store = useDeploymentPickStore() + const first = store.load() + const second = store.load() + await first + + newer.reject( + new WorkspaceApiError('not enabled for this account yet', 403) + ) + await second + expect(store.state.phase).toBe('hidden') + }) + + it('takes an older 403 at once while a newer listing is still in flight', async () => { + const older = deferred() + const newer = deferred() + mockWorkspaceApi.listDeployments + .mockReturnValueOnce(older.promise) + .mockReturnValueOnce(newer.promise) + const store = useDeploymentPickStore() + const first = store.load() + const second = store.load() + + older.reject( + new WorkspaceApiError('not enabled for this account yet', 403) + ) + await first + // A refusal is an answer about the account, unlike a plain failure. + expect(store.state.phase).toBe('hidden') + + newer.resolve(listing) + await second + expect(store.state.phase).toBe('ready') + }) + + it('ignores an older failure while a newer listing is still in flight', async () => { + const older = deferred() + const newer = deferred() + mockWorkspaceApi.listDeployments + .mockReturnValueOnce(older.promise) + .mockReturnValueOnce(newer.promise) + const store = useDeploymentPickStore() + const first = store.load() + const second = store.load() + + older.reject(new Error('Network Error')) + await first + // Still waiting on the newer listing, not settled on "the load failed". + expect(store.state.phase).toBe('idle') + + newer.resolve(listing) + await second + expect(store.state.phase).toBe('ready') + }) + }) + + describe('clicking the row already checked', () => { + it('does nothing on Comfy Cloud with no pick and no default', async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue({ + ...listing, + picked_deployment_id: undefined, + pick_source: undefined + }) + const store = useDeploymentPickStore() + await store.load() + + await expect(store.pick(null)).resolves.toBeNull() + expect(mockWorkspaceApi.clearDeployment).not.toHaveBeenCalled() + expect(reload).not.toHaveBeenCalled() + }) + + it("does nothing on the workspace default's row, so the browser keeps following it", async () => { + mockWorkspaceApi.listDeployments.mockResolvedValue({ + ...listing, + pick_source: 'workspace_default', + default_deployment_id: 'dep-2' + }) + const store = useDeploymentPickStore() + await store.load() + + await expect(store.pick('dep-2')).resolves.toBeNull() + expect(mockWorkspaceApi.pickDeployment).not.toHaveBeenCalled() + expect(reload).not.toHaveBeenCalled() + expect(store.followsWorkspace).toBe(true) + }) + }) +}) + +function deferred() { + let resolve: (value: T) => void = () => {} + let reject: (err: unknown) => void = () => {} + const promise = new Promise((res, rej) => { + resolve = res + reject = rej + }) + return { promise, resolve, reject } +} diff --git a/src/platform/workspace/stores/deploymentPickStore.ts b/src/platform/workspace/stores/deploymentPickStore.ts new file mode 100644 index 00000000000..5b1b6230485 --- /dev/null +++ b/src/platform/workspace/stores/deploymentPickStore.ts @@ -0,0 +1,239 @@ +import { defineStore } from 'pinia' +import { computed, shallowRef } from 'vue' + +import { + WorkspaceApiError, + workspaceApi +} from '@/platform/workspace/api/workspaceApi' +import type { + DeploymentPickEvent, + DeploymentPickSource, + DeploymentPickState +} from '@/platform/workspace/deploymentPickState' +import { + loadedEvent, + reduceDeploymentPick +} from '@/platform/workspace/deploymentPickState' +import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' + +/** + * The deployment this browser runs on and the deployments it may pick + * (FE-2434), plus the workspace's default deployment an owner sets for + * members with no pick of their own (BE-17480). A deployment keeps its URL + * while its owner updates it to new Releases, so a pick follows those updates. + * + * A pick changes what the editor is served at boot (the node + * catalog of the Release the deployment runs and its packs' JavaScript), so a successful pick or clear reloads + * the page rather than patching the running editor. + */ +export const useDeploymentPickStore = defineStore('deploymentPick', () => { + const workspaceStore = useTeamWorkspaceStore() + + const state = shallowRef({ phase: 'idle' }) + + function dispatch(event: DeploymentPickEvent) { + state.value = reduceDeploymentPick(state.value, event) + } + + const deployments = computed(() => + 'deployments' in state.value ? state.value.deployments : [] + ) + const pickedDeploymentId = computed(() => + 'pickedDeploymentId' in state.value ? state.value.pickedDeploymentId : null + ) + const pickedDeployment = computed( + () => + deployments.value.find( + (d) => d.deployment_id === pickedDeploymentId.value + ) ?? null + ) + const pickSource = computed(() => + 'pickSource' in state.value ? state.value.pickSource : null + ) + const defaultDeploymentId = computed(() => + 'defaultDeploymentId' in state.value + ? state.value.defaultDeploymentId + : null + ) + const defaultDeployment = computed( + () => + deployments.value.find( + (d) => d.deployment_id === defaultDeploymentId.value + ) ?? null + ) + /** + * True when this browser has no pick of its own and so runs on whatever + * the workspace says: its default deployment, or Comfy Cloud without one. + */ + const followsWorkspace = computed(() => pickSource.value !== 'browser') + /** Only a workspace owner may set or clear the default deployment. */ + const canSetDefault = computed( + () => workspaceStore.activeWorkspace?.role === 'owner' + ) + const buildsVisible = computed(() => + 'buildsVisible' in state.value ? state.value.buildsVisible : true + ) + /** + * True once a listing has answered, and while a reload of it is in flight. + * False before any listing answers, when the account cannot pick, and when + * the load failed with no listing to show. A listing that answered is shown + * even when a newer load fails or never answers. + */ + const isVisible = computed(() => 'deployments' in state.value) + const isSwitching = computed(() => state.value.phase === 'switching') + + /** + * Orders the answers. Each `load()` takes the next number (`latestRequest`); + * `lastApplied` is the number of the newest answer put on screen. A listing + * or a 403 applies when it is newer than that, so a listing that answered + * stays shown when a newer load fails or never answers. A plain failure + * applies only when it is the latest load asked for and nothing newer has + * applied, so it never replaces a listing that may still arrive. A default + * the server took moves `lastApplied` up to `latestRequest`, which drops + * every listing asked for before the change. + */ + let latestRequest = 0 + let lastApplied = 0 + + async function load(): Promise { + const id = workspaceStore.workspaceId + if (!id) return + const request = ++latestRequest + let event: DeploymentPickEvent + try { + event = loadedEvent(await workspaceApi.listDeployments(id)) + } catch (err) { + event = loadFailure(err) + } + // The workspace may have changed while the listing was in flight. + if (workspaceStore.workspaceId !== id) return + if (request <= lastApplied) return + if (event.type === 'loadFailed') { + if (request === latestRequest) dispatch(event) + return + } + lastApplied = request + dispatch(event) + } + + /** + * Pick a deployment for this browser, or null for Comfy Cloud, then reload so + * the editor boots on it. Resolves to the server's refusal, or null when + * the pick took (the page is reloading) or there was nothing to do. + * Choosing what this browser already runs on does nothing, so a browser + * that follows the workspace default keeps following it. Picking Comfy + * Cloud while following a default is this browser's own choice: it wins + * over the default, until `followWorkspace` drops it. + */ + async function pick(deploymentId: string | null): Promise { + const id = workspaceStore.workspaceId + if (!id || state.value.phase !== 'ready') return null + if (deploymentId === pickedDeploymentId.value) return null + dispatch({ type: 'switchStarted', target: deploymentId }) + try { + if (deploymentId === null) { + await workspaceApi.clearDeployment(id) + } else { + await workspaceApi.pickDeployment(id, { deployment_id: deploymentId }) + } + } catch (err) { + dispatch({ type: 'switchFailed' }) + return errorMessage(err) + } + window.location.reload() + return null + } + + /** + * Drop this browser's own pick so it runs on whatever the workspace says + * (its default deployment, or Comfy Cloud), then reload. Resolves like `pick`. + */ + async function followWorkspace(): Promise { + const id = workspaceStore.workspaceId + if (!id || state.value.phase !== 'ready') return null + if (followsWorkspace.value) return null + dispatch({ type: 'switchStarted', target: defaultDeploymentId.value }) + try { + await workspaceApi.clearDeployment(id, { follow: 'workspace' }) + } catch (err) { + dispatch({ type: 'switchFailed' }) + return errorMessage(err) + } + window.location.reload() + return null + } + + /** + * Set the workspace's default deployment (owner only), or clear it with null. + * Members with no pick of their own move to it at their next boot. This + * browser reloads only when it has no pick of its own, since only then + * does the new default change what it runs on. Otherwise the new default + * shows at once and the listing is refreshed to confirm it; a failed + * refresh keeps the new default on screen, since the server has it, and a + * listing asked for before the change is dropped when it lands. + * Resolves to the server's refusal, or null when the default took. + */ + async function setDefault( + deploymentId: string | null + ): Promise { + const id = workspaceStore.workspaceId + if (!id || state.value.phase !== 'ready') return null + if (deploymentId === defaultDeploymentId.value) return null + dispatch({ type: 'switchStarted', target: pickedDeploymentId.value }) + try { + if (deploymentId === null) { + await workspaceApi.clearDefaultDeployment(id) + } else { + await workspaceApi.setDefaultDeployment(id, { + deployment_id: deploymentId + }) + } + } catch (err) { + dispatch({ type: 'switchFailed' }) + return errorMessage(err) + } + if (followsWorkspace.value) { + window.location.reload() + return null + } + lastApplied = latestRequest + dispatch({ type: 'defaultChanged', defaultDeploymentId: deploymentId }) + await load() + return null + } + + return { + state, + deployments, + pickedDeploymentId, + pickedDeployment, + pickSource, + defaultDeploymentId, + defaultDeployment, + followsWorkspace, + canSetDefault, + buildsVisible, + isVisible, + isSwitching, + load, + pick, + followWorkspace, + setDefault + } +}) + +/** + * A 403 means the account is outside the rollout: hide the switcher. Any + * other failure (a 404 from an ingest without these routes, a 5xx, a network + * error, no signed-in user) hides it too unless a listing is already shown. + */ +function loadFailure(err: unknown): DeploymentPickEvent { + if (err instanceof WorkspaceApiError && err.status === 403) { + return { type: 'loadRefused' } + } + return { type: 'loadFailed' } +} + +function errorMessage(err: unknown): string { + return err instanceof Error ? err.message : String(err) +} diff --git a/src/platform/workspace/stores/releasePickStore.test.ts b/src/platform/workspace/stores/releasePickStore.test.ts deleted file mode 100644 index 7ef4ba4cbce..00000000000 --- a/src/platform/workspace/stores/releasePickStore.test.ts +++ /dev/null @@ -1,308 +0,0 @@ -import { beforeEach, describe, expect, it, vi } from 'vitest' - -import type { WorkspaceReleaseList } from '@comfyorg/ingest-types' - -import { WorkspaceApiError } from '@/platform/workspace/api/workspaceApi' - -import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' - -import { useReleasePickStore } from './releasePickStore' - -const mockWorkspaceApi = vi.hoisted(() => ({ - listReleases: vi.fn(), - pickRelease: vi.fn(), - clearRelease: vi.fn(), - setDefaultRelease: vi.fn(), - clearDefaultRelease: vi.fn() -})) - -vi.mock(import('@/platform/workspace/api/workspaceApi'), async () => { - class WorkspaceApiError extends Error { - constructor( - message: string, - public readonly status?: number, - public readonly code?: string - ) { - super(message) - this.name = 'WorkspaceApiError' - } - } - return { workspaceApi: mockWorkspaceApi, WorkspaceApiError } -}) - -const listing: WorkspaceReleaseList = { - builds_visible: true, - picked_release_id: 'r-2', - pick_source: 'browser', - releases: [ - { - release_id: 'r-2', - build_id: 'b-1', - build_name: 'Studio Build', - version: 2, - deployed: true, - deployment_status: 'ready' - }, - { - release_id: 'r-1', - build_id: 'b-1', - build_name: 'Studio Build', - version: 1, - deployed: false - } - ] -} - -describe('useReleasePickStore', () => { - const reload = vi.fn() - - beforeEach(() => { - Object.assign(useTeamWorkspaceStore(), { workspaceId: 'ws-1' }) - Object.defineProperty(window, 'location', { - value: { reload, origin: 'http://localhost' }, - writable: true, - configurable: true - }) - }) - - it('loads the listing and knows which Release is picked', async () => { - mockWorkspaceApi.listReleases.mockResolvedValue(listing) - const store = useReleasePickStore() - expect(store.isVisible).toBe(false) - - await store.load() - - expect(mockWorkspaceApi.listReleases).toHaveBeenCalledWith('ws-1') - expect(store.state.phase).toBe('ready') - expect(store.isVisible).toBe(true) - expect(store.releases).toHaveLength(2) - expect(store.pickedReleaseId).toBe('r-2') - expect(store.pickedRelease?.build_name).toBe('Studio Build') - expect(store.pickSource).toBe('browser') - expect(store.followsWorkspace).toBe(false) - expect(store.defaultReleaseId).toBeNull() - expect(store.canSetDefault).toBe(false) - }) - - it('follows the workspace default when the browser has no pick of its own', async () => { - mockWorkspaceApi.listReleases.mockResolvedValue({ - ...listing, - pick_source: 'workspace_default', - default_release_id: 'r-2' - }) - const store = useReleasePickStore() - await store.load() - - expect(store.pickedReleaseId).toBe('r-2') - expect(store.pickSource).toBe('workspace_default') - expect(store.followsWorkspace).toBe(true) - expect(store.defaultReleaseId).toBe('r-2') - expect(store.defaultRelease?.version).toBe(2) - - // Already following: nothing to drop. - await expect(store.followWorkspace()).resolves.toBeNull() - expect(mockWorkspaceApi.clearRelease).not.toHaveBeenCalled() - - // Picking Comfy Cloud is this browser's own choice, even though nothing - // is "picked" yet: it goes through the clear route and reloads. - mockWorkspaceApi.clearRelease.mockResolvedValue(undefined) - await expect(store.pick(null)).resolves.toBeNull() - expect(mockWorkspaceApi.clearRelease).toHaveBeenCalledWith('ws-1') - expect(reload).toHaveBeenCalledOnce() - }) - - it('drops its own pick to follow the workspace, through the clear route with follow=workspace', async () => { - mockWorkspaceApi.listReleases.mockResolvedValue({ - ...listing, - picked_release_id: 'r-1', - default_release_id: 'r-2' - }) - mockWorkspaceApi.clearRelease.mockResolvedValue(undefined) - const store = useReleasePickStore() - await store.load() - - await expect(store.followWorkspace()).resolves.toBeNull() - - expect(mockWorkspaceApi.clearRelease).toHaveBeenCalledWith('ws-1', { - follow: 'workspace' - }) - expect(reload).toHaveBeenCalledOnce() - }) - - it('an owner sets the picked Release as the workspace default and the listing refreshes', async () => { - Object.assign(useTeamWorkspaceStore(), { - workspaceId: 'ws-1', - activeWorkspace: { id: 'ws-1', role: 'owner' } - }) - mockWorkspaceApi.listReleases - .mockResolvedValueOnce(listing) - .mockResolvedValueOnce({ ...listing, default_release_id: 'r-2' }) - mockWorkspaceApi.setDefaultRelease.mockResolvedValue(undefined) - const store = useReleasePickStore() - await store.load() - expect(store.canSetDefault).toBe(true) - - await expect(store.setDefault('r-2')).resolves.toBeNull() - - expect(mockWorkspaceApi.setDefaultRelease).toHaveBeenCalledWith('ws-1', { - release_id: 'r-2' - }) - expect(reload).not.toHaveBeenCalled() - expect(store.state.phase).toBe('ready') - expect(store.defaultReleaseId).toBe('r-2') - - // Clearing it, likewise; setting what is already set is a no-op. - await expect(store.setDefault('r-2')).resolves.toBeNull() - expect(mockWorkspaceApi.setDefaultRelease).toHaveBeenCalledOnce() - mockWorkspaceApi.listReleases.mockResolvedValueOnce(listing) - mockWorkspaceApi.clearDefaultRelease.mockResolvedValue(undefined) - await expect(store.setDefault(null)).resolves.toBeNull() - expect(mockWorkspaceApi.clearDefaultRelease).toHaveBeenCalledWith('ws-1') - expect(store.defaultReleaseId).toBeNull() - }) - - it('a browser that follows the workspace reloads when its owner changes the default', async () => { - mockWorkspaceApi.listReleases.mockResolvedValue({ - ...listing, - picked_release_id: undefined, - pick_source: undefined - }) - mockWorkspaceApi.setDefaultRelease.mockResolvedValue(undefined) - const store = useReleasePickStore() - await store.load() - expect(store.followsWorkspace).toBe(true) - - await expect(store.setDefault('r-2')).resolves.toBeNull() - expect(reload).toHaveBeenCalledOnce() - }) - - it("hands back the server's refusal of a default and stays ready", async () => { - mockWorkspaceApi.listReleases.mockResolvedValue(listing) - mockWorkspaceApi.setDefaultRelease.mockRejectedValue( - new WorkspaceApiError( - 'only a workspace owner can set the default release', - 403 - ) - ) - const store = useReleasePickStore() - await store.load() - - await expect(store.setDefault('r-1')).resolves.toBe( - 'only a workspace owner can set the default release' - ) - expect(store.state.phase).toBe('ready') - expect(store.defaultReleaseId).toBeNull() - expect(reload).not.toHaveBeenCalled() - }) - - it('hides itself when the account is outside the rollout', async () => { - mockWorkspaceApi.listReleases.mockRejectedValue( - new WorkspaceApiError( - 'not enabled for this account yet', - 403, - 'FORBIDDEN' - ) - ) - const store = useReleasePickStore() - await store.load() - expect(store.state.phase).toBe('hidden') - expect(store.isVisible).toBe(false) - }) - - it('is unavailable, with the message, when the platform cannot be asked', async () => { - mockWorkspaceApi.listReleases.mockRejectedValue( - new WorkspaceApiError( - 'could not list releases from comfy-deploy; try again', - 503 - ) - ) - const store = useReleasePickStore() - await store.load() - expect(store.state).toEqual({ - phase: 'unavailable', - message: 'could not list releases from comfy-deploy; try again' - }) - expect(store.isVisible).toBe(true) - }) - - it('picks a Release and reloads the page', async () => { - mockWorkspaceApi.listReleases.mockResolvedValue(listing) - mockWorkspaceApi.pickRelease.mockResolvedValue(undefined) - const store = useReleasePickStore() - await store.load() - - await expect(store.pick('r-1')).resolves.toBeNull() - - expect(mockWorkspaceApi.pickRelease).toHaveBeenCalledWith('ws-1', { - release_id: 'r-1' - }) - expect(reload).toHaveBeenCalledOnce() - }) - - it('clears the pick for Comfy Cloud and reloads', async () => { - mockWorkspaceApi.listReleases.mockResolvedValue(listing) - mockWorkspaceApi.clearRelease.mockResolvedValue(undefined) - const store = useReleasePickStore() - await store.load() - - await expect(store.pick(null)).resolves.toBeNull() - - expect(mockWorkspaceApi.clearRelease).toHaveBeenCalledWith('ws-1') - expect(mockWorkspaceApi.pickRelease).not.toHaveBeenCalled() - expect(reload).toHaveBeenCalledOnce() - }) - - it('hands back a refused pick and stays ready, without reloading', async () => { - mockWorkspaceApi.listReleases.mockResolvedValue(listing) - mockWorkspaceApi.pickRelease.mockRejectedValue( - new WorkspaceApiError( - 'release r-1 has no deployment; deploy it first', - 422 - ) - ) - const store = useReleasePickStore() - await store.load() - - await expect(store.pick('r-1')).resolves.toBe( - 'release r-1 has no deployment; deploy it first' - ) - expect(store.state.phase).toBe('ready') - expect(store.pickedReleaseId).toBe('r-2') - expect(reload).not.toHaveBeenCalled() - }) - - it('picking the current Release is a no-op', async () => { - mockWorkspaceApi.listReleases.mockResolvedValue(listing) - const store = useReleasePickStore() - await store.load() - - await expect(store.pick('r-2')).resolves.toBeNull() - expect(mockWorkspaceApi.pickRelease).not.toHaveBeenCalled() - expect(reload).not.toHaveBeenCalled() - }) - - it('ignores a listing that arrives after the workspace changed', async () => { - let resolve: (value: WorkspaceReleaseList) => void = () => {} - mockWorkspaceApi.listReleases.mockReturnValue( - new Promise((r) => { - resolve = r - }) - ) - const store = useReleasePickStore() - const loading = store.load() - Object.assign(useTeamWorkspaceStore(), { workspaceId: 'ws-2' }) - resolve(listing) - await loading - - expect(store.state.phase).toBe('loading') - expect(store.releases).toEqual([]) - }) - - it('does nothing without an active workspace', async () => { - Object.assign(useTeamWorkspaceStore(), { workspaceId: null }) - const store = useReleasePickStore() - await store.load() - expect(mockWorkspaceApi.listReleases).not.toHaveBeenCalled() - expect(store.state.phase).toBe('idle') - }) -}) diff --git a/src/platform/workspace/stores/releasePickStore.ts b/src/platform/workspace/stores/releasePickStore.ts deleted file mode 100644 index cdc1a775c2c..00000000000 --- a/src/platform/workspace/stores/releasePickStore.ts +++ /dev/null @@ -1,198 +0,0 @@ -import { defineStore } from 'pinia' -import { computed, shallowRef } from 'vue' - -import { - WorkspaceApiError, - workspaceApi -} from '@/platform/workspace/api/workspaceApi' -import type { - ReleasePickEvent, - ReleasePickSource, - ReleasePickState -} from '@/platform/workspace/releasePickState' -import { reduceReleasePick } from '@/platform/workspace/releasePickState' -import { useTeamWorkspaceStore } from '@/platform/workspace/stores/teamWorkspaceStore' - -/** - * The Release this browser runs on and the Releases it may pick (FE-2434), - * plus the workspace's default Release an owner sets for members with no - * pick of their own (BE-17480). - * - * A pick changes what the editor is served at boot (the Release's node - * catalog and its packs' JavaScript), so a successful pick or clear reloads - * the page rather than patching the running editor. - */ -export const useReleasePickStore = defineStore('releasePick', () => { - const workspaceStore = useTeamWorkspaceStore() - - const state = shallowRef({ phase: 'idle' }) - - function dispatch(event: ReleasePickEvent) { - state.value = reduceReleasePick(state.value, event) - } - - const releases = computed(() => - 'releases' in state.value ? state.value.releases : [] - ) - const pickedReleaseId = computed(() => - 'pickedReleaseId' in state.value ? state.value.pickedReleaseId : null - ) - const pickedRelease = computed( - () => - releases.value.find((r) => r.release_id === pickedReleaseId.value) ?? null - ) - const pickSource = computed(() => - 'pickSource' in state.value ? state.value.pickSource : null - ) - const defaultReleaseId = computed(() => - 'defaultReleaseId' in state.value ? state.value.defaultReleaseId : null - ) - const defaultRelease = computed( - () => - releases.value.find((r) => r.release_id === defaultReleaseId.value) ?? - null - ) - /** - * True when this browser has no pick of its own and so runs on whatever - * the workspace says: its default Release, or Comfy Cloud without one. - */ - const followsWorkspace = computed(() => pickSource.value !== 'browser') - /** Only a workspace owner may set or clear the default Release. */ - const canSetDefault = computed( - () => workspaceStore.activeWorkspace?.role === 'owner' - ) - const buildsVisible = computed(() => - 'buildsVisible' in state.value ? state.value.buildsVisible : true - ) - /** False until the listing has answered, and when the account cannot pick. */ - const isVisible = computed( - () => state.value.phase !== 'idle' && state.value.phase !== 'hidden' - ) - const isSwitching = computed(() => state.value.phase === 'switching') - - async function load(): Promise { - const id = workspaceStore.workspaceId - if (!id) return - dispatch({ type: 'loadStarted' }) - try { - const listing = await workspaceApi.listReleases(id) - if (workspaceStore.workspaceId !== id) return - dispatch({ - type: 'loaded', - releases: listing.releases, - pickedReleaseId: listing.picked_release_id ?? null, - pickSource: listing.pick_source ?? null, - defaultReleaseId: listing.default_release_id ?? null, - buildsVisible: listing.builds_visible - }) - } catch (err) { - if (workspaceStore.workspaceId !== id) return - if (err instanceof WorkspaceApiError && err.status === 403) { - dispatch({ type: 'loadRefused' }) - return - } - dispatch({ type: 'loadFailed', message: errorMessage(err) }) - } - } - - /** - * Pick a Release for this browser, or null for Comfy Cloud, then reload so - * the editor boots on it. Resolves to the server's refusal, or null when - * the pick took (the page is reloading). Picking Comfy Cloud is this - * browser's own choice: with a workspace default set it still wins over - * the default, until `followWorkspace` drops it. - */ - async function pick(releaseId: string | null): Promise { - const id = workspaceStore.workspaceId - if (!id || state.value.phase !== 'ready') return null - if (releaseId === pickedReleaseId.value && !followsWorkspace.value) { - return null - } - dispatch({ type: 'switchStarted', target: releaseId }) - try { - if (releaseId === null) { - await workspaceApi.clearRelease(id) - } else { - await workspaceApi.pickRelease(id, { release_id: releaseId }) - } - } catch (err) { - dispatch({ type: 'switchFailed' }) - return errorMessage(err) - } - window.location.reload() - return null - } - - /** - * Drop this browser's own pick so it runs on whatever the workspace says - * (its default Release, or Comfy Cloud), then reload. Resolves like `pick`. - */ - async function followWorkspace(): Promise { - const id = workspaceStore.workspaceId - if (!id || state.value.phase !== 'ready') return null - if (followsWorkspace.value) return null - dispatch({ type: 'switchStarted', target: defaultReleaseId.value }) - try { - await workspaceApi.clearRelease(id, { follow: 'workspace' }) - } catch (err) { - dispatch({ type: 'switchFailed' }) - return errorMessage(err) - } - window.location.reload() - return null - } - - /** - * Set the workspace's default Release (owner only), or clear it with null. - * Members with no pick of their own move to it at their next boot. This - * browser reloads only when it follows the workspace, since nothing else - * about what it runs on changed; otherwise the listing is refreshed. - * Resolves to the server's refusal, or null when the default took. - */ - async function setDefault(releaseId: string | null): Promise { - const id = workspaceStore.workspaceId - if (!id || state.value.phase !== 'ready') return null - if (releaseId === defaultReleaseId.value) return null - dispatch({ type: 'switchStarted', target: pickedReleaseId.value }) - try { - if (releaseId === null) { - await workspaceApi.clearDefaultRelease(id) - } else { - await workspaceApi.setDefaultRelease(id, { release_id: releaseId }) - } - } catch (err) { - dispatch({ type: 'switchFailed' }) - return errorMessage(err) - } - if (followsWorkspace.value) { - window.location.reload() - return null - } - dispatch({ type: 'switchFailed' }) - await load() - return null - } - - return { - state, - releases, - pickedReleaseId, - pickedRelease, - pickSource, - defaultReleaseId, - defaultRelease, - followsWorkspace, - canSetDefault, - buildsVisible, - isVisible, - isSwitching, - load, - pick, - followWorkspace, - setDefault - } -}) - -function errorMessage(err: unknown): string { - return err instanceof Error ? err.message : String(err) -} From 73ad909c86fe28631c97d2d3eed5c85fd3e65d33 Mon Sep 17 00:00:00 2001 From: Vinh Trinh Date: Sun, 4 Oct 2026 16:18:03 -0400 Subject: [PATCH 04/33] fix(workspace): a picked deployment that no longer exists shows as Comfy Cloud (FE-2434) Ingest serves a browser whose pick (its own, or the workspace default it follows) names a deployment that is gone the Cloud catalog, and runs its jobs on Cloud. The switcher said "Running on / Deployment dep-..." for it, checked no row, and offered an owner "Set as workspace default" for the gone deployment. Now, when the listing no longer has the picked deployment: - the trigger says "Running on / Comfy Cloud", with one line under it: "The deployment you picked no longer exists." (own pick) or "The workspace's default deployment no longer exists." (followed default); - the Comfy Cloud row is checked; - the owner footer does not offer the gone deployment as the default. Clicking the Comfy Cloud row still clears the stale pick. A gone workspace default still shows as "Deployment dep-..." in the owner footer and in "Use the workspace default"; not changed here. --- src/locales/en/main.json | 2 + .../components/DeploymentSwitcher.test.ts | 45 +++++++++++++++++++ .../components/DeploymentSwitcher.vue | 20 +++++++-- .../components/DeploymentSwitcherList.vue | 3 +- .../composables/useDeploymentLabels.ts | 13 +++--- .../workspace/stores/deploymentPickStore.ts | 10 +++++ 6 files changed, 82 insertions(+), 11 deletions(-) diff --git a/src/locales/en/main.json b/src/locales/en/main.json index 11c2247857f..f852acd9ab2 100644 --- a/src/locales/en/main.json +++ b/src/locales/en/main.json @@ -3872,6 +3872,8 @@ "comfyCloudCaption": "Comfy's own node set", "deployment": "{build} v{version}", "unnamedDeployment": "Deployment {id}", + "pickGone": "The deployment you picked no longer exists.", + "defaultGone": "The workspace's default deployment no longer exists.", "caption": "{id}, {status}", "noDeployments": "This workspace has no deployments yet. Deploy a Release on the Developer Platform first.", "buildsHidden": "Build names are not visible to this account.", diff --git a/src/platform/workspace/components/DeploymentSwitcher.test.ts b/src/platform/workspace/components/DeploymentSwitcher.test.ts index f467d919b4a..6533215dcda 100644 --- a/src/platform/workspace/components/DeploymentSwitcher.test.ts +++ b/src/platform/workspace/components/DeploymentSwitcher.test.ts @@ -45,6 +45,7 @@ const i18n = createI18n({ const D2 = 'dep-a2a2a2a2-0000-4000-8000-000000000002' const D1 = 'dep-a1a1a1a1-0000-4000-8000-000000000001' const D9 = 'dep-b9b9b9b9-0000-4000-8000-000000000009' +const GONE = 'dep-0e0e0e0e-0000-4000-8000-0000000000a2' const listing: WorkspaceDeploymentList = { builds_visible: true, @@ -150,6 +151,50 @@ describe('DeploymentSwitcher', () => { ) }) + it.for([ + { + pick_source: 'browser' as const, + default_deployment_id: undefined, + line: 'The deployment you picked no longer exists.' + }, + { + pick_source: 'workspace_default' as const, + default_deployment_id: GONE, + line: "The workspace's default deployment no longer exists." + } + ])( + 'says Comfy Cloud when the $pick_source pick is no longer listed, and offers it to no one', + async ({ pick_source, default_deployment_id, line }) => { + Object.assign(useTeamWorkspaceStore(), { + workspaceId: 'ws-1', + activeWorkspace: { id: 'ws-1', role: 'owner' } + }) + mockWorkspaceApi.listDeployments.mockResolvedValue({ + ...listing, + picked_deployment_id: GONE, + pick_source, + default_deployment_id + }) + renderSwitcher() + + await waitFor(() => + expect( + screen.getByTestId('deployment-switcher-current') + ).toHaveTextContent('Comfy Cloud') + ) + expect(screen.getByTestId('deployment-switcher-gone')).toHaveTextContent( + line + ) + expect(screen.queryByTestId('deployment-switcher-following')).toBeNull() + await userEvent.click(screen.getByTestId('deployment-switcher-trigger')) + expect(screen.getByTestId('deployment-row-cloud')).toHaveAttribute( + 'aria-checked', + 'true' + ) + expect(screen.queryByTestId('deployment-switcher-set-default')).toBeNull() + } + ) + it('picks a deployment, which reloads the editor', async () => { mockWorkspaceApi.listDeployments.mockResolvedValue(listing) mockWorkspaceApi.pickDeployment.mockResolvedValue(undefined) diff --git a/src/platform/workspace/components/DeploymentSwitcher.vue b/src/platform/workspace/components/DeploymentSwitcher.vue index ac8531aa0ac..78b21b20180 100644 --- a/src/platform/workspace/components/DeploymentSwitcher.vue +++ b/src/platform/workspace/components/DeploymentSwitcher.vue @@ -7,7 +7,8 @@ that answered stays shown when a newer load fails or never answers. Shows the workspace's default deployment when an owner set one (BE-17480): a browser with no pick of its own follows it, and an owner sets or - clears it from the panel's footer. --> + clears it from the panel's footer. A pick the listing no longer has + shows as Comfy Cloud, which is what ingest serves it. -->