@taskforcehq/taskforce 0.3.170 → 0.3.301

package/dist/server/index.test.js

@@ -1,5 +1,5 @@
-import { describe, expect, it } from 'vitest';
-import { ensureBillingWebhookAuthExclusion, isBillingWebhookPath, shouldApplyAuthRateLimitForPath } from './index.js';
+import { describe, expect, it, vi } from 'vitest';
+import { ensureBillingWebhookAuthExclusion, ensurePublicSiteConfigAuthExclusion, isBillingWebhookPath, resolveAuthorizedWorkspaceAccess, shouldApplyAuthRateLimitForPath, shouldProxyCloudPath, writeJsonErrorIfPossible } from './index.js';
 describe('server index helper policies', () => {
     it('adds webhook path to auth exclusions without duplicates', () => {
         const base = ['/api/taskforce/health', '/api/taskforce/auth'];
@@ -7,6 +7,14 @@ describe('server index helper policies', () => {
         expect(next).toContain('/api/taskforce/billing/webhook');
         expect(next.filter((entry) => entry === '/api/taskforce/billing/webhook')).toHaveLength(1);
     });
+    it('adds public site config path to auth exclusions without duplicates', () => {
+        const base = ['/api/taskforce/health', '/api/taskforce/auth'];
+        const next = ensurePublicSiteConfigAuthExclusion(base);
+        expect(next).toContain('/api/taskforce/public/site-config');
+        expect(next.filter((entry) => entry === '/api/taskforce/public/site-config')).toHaveLength(1);
+        expect(next).toContain('/api/taskforce/public/site-config-script');
+        expect(next.filter((entry) => entry === '/api/taskforce/public/site-config-script')).toHaveLength(1);
+    });
     it('identifies billing webhook path exactly', () => {
         expect(isBillingWebhookPath('/api/taskforce/billing/webhook')).toBe(true);
         expect(isBillingWebhookPath('/api/taskforce/billing/webhook/v2')).toBe(false);
@@ -16,4 +24,127 @@ describe('server index helper policies', () => {
         expect(shouldApplyAuthRateLimitForPath('/api/taskforce/auth/session')).toBe(false);
         expect(shouldApplyAuthRateLimitForPath('/api/taskforce/billing/webhook')).toBe(false);
     });
+    it('writes a json error when headers are still available', () => {
+        let headersSent = false;
+        let writableEnded = false;
+        const res = {
+            writeHead: vi.fn(() => {
+                headersSent = true;
+            }),
+            end: vi.fn(() => {
+                writableEnded = true;
+            })
+        };
+        Object.defineProperty(res, 'headersSent', {
+            configurable: true,
+            get: () => headersSent
+        });
+        Object.defineProperty(res, 'writableEnded', {
+            configurable: true,
+            get: () => writableEnded
+        });
+        expect(writeJsonErrorIfPossible(res, 502, { error: 'Cloud proxy request failed.' })).toBe(true);
+        expect(res.writeHead).toHaveBeenCalledWith(502, { 'Content-Type': 'application/json' });
+        expect(res.end).toHaveBeenCalledWith(JSON.stringify({ error: 'Cloud proxy request failed.' }));
+    });
+    it('skips json error writes after headers are already sent', () => {
+        const res = {
+            writeHead: vi.fn(),
+            end: vi.fn()
+        };
+        Object.defineProperty(res, 'headersSent', {
+            configurable: true,
+            get: () => true
+        });
+        Object.defineProperty(res, 'writableEnded', {
+            configurable: true,
+            get: () => false
+        });
+        expect(writeJsonErrorIfPossible(res, 502, { error: 'Cloud proxy request failed.' })).toBe(false);
+        expect(res.writeHead).not.toHaveBeenCalled();
+        expect(res.end).not.toHaveBeenCalled();
+    });
+});
+describe('shouldProxyCloudPath', () => {
+    it('returns false for empty or null pathname', () => {
+        expect(shouldProxyCloudPath('')).toBe(false);
+        expect(shouldProxyCloudPath(null)).toBe(false);
+    });
+    it('does not proxy local-only sync routes', () => {
+        expect(shouldProxyCloudPath('/api/taskforce/auth/runtime-config')).toBe(false);
+        expect(shouldProxyCloudPath('/api/taskforce/sync/workspace/apply-local')).toBe(false);
+        expect(shouldProxyCloudPath('/api/taskforce/sync/workspace/documents')).toBe(false);
+        expect(shouldProxyCloudPath('/api/taskforce/sync/workspace/assets')).toBe(false);
+        expect(shouldProxyCloudPath('/api/taskforce/sync/workspace/ai-profiles')).toBe(false);
+        expect(shouldProxyCloudPath('/api/taskforce/sync/events')).toBe(false);
+    });
+    it('proxies cloud-owned sync routes', () => {
+        expect(shouldProxyCloudPath('/api/taskforce/sync/workspace/pull')).toBe(true);
+        expect(shouldProxyCloudPath('/api/taskforce/sync/workspace/push')).toBe(true);
+    });
+    it('proxies admin, billing, and auth routes', () => {
+        expect(shouldProxyCloudPath('/api/taskforce/admin/users')).toBe(true);
+        expect(shouldProxyCloudPath('/api/taskforce/billing/plans')).toBe(true);
+        expect(shouldProxyCloudPath('/api/taskforce/auth/login')).toBe(true);
+        expect(shouldProxyCloudPath('/api/taskforce/public/site-config')).toBe(true);
+        expect(shouldProxyCloudPath('/api/taskforce/public/site-config-script')).toBe(true);
+    });
+});
+describe('resolveAuthorizedWorkspaceAccess', () => {
+    it('prefers an explicitly requested workspace when the user is authorized for it', () => {
+        const core = {
+            resolveUserAccess: vi.fn((userId, workspaceId, role) => {
+                if (workspaceId !== 'workspace-team')
+                    return null;
+                return {
+                    userId,
+                    workspaceId,
+                    role,
+                    permissionMode: 'read-write',
+                    disabled: false,
+                    betaAccess: true
+                };
+            }),
+            getSystemRole: vi.fn(() => 'user')
+        };
+        const next = resolveAuthorizedWorkspaceAccess(core, {
+            authenticated: true,
+            sessionId: 'session-1',
+            userId: 'user-1',
+            workspaceId: 'workspace-personal',
+            role: 'member',
+            systemRole: 'user'
+        }, 'workspace-team');
+        expect(core.resolveUserAccess).toHaveBeenCalledWith('user-1', 'workspace-team', 'member');
+        expect(next.workspaceId).toBe('workspace-team');
+        expect(next.userId).toBe('user-1');
+    });
+    it('falls back to the session workspace when the requested workspace is not authorized', () => {
+        const core = {
+            resolveUserAccess: vi.fn((userId, workspaceId, role) => {
+                if (workspaceId !== 'workspace-personal')
+                    return null;
+                return {
+                    userId,
+                    workspaceId,
+                    role,
+                    permissionMode: 'read-write',
+                    disabled: false,
+                    betaAccess: true
+                };
+            }),
+            getSystemRole: vi.fn(() => 'user')
+        };
+        const next = resolveAuthorizedWorkspaceAccess(core, {
+            authenticated: true,
+            sessionId: 'session-1',
+            userId: 'user-1',
+            workspaceId: 'workspace-personal',
+            role: 'member',
+            systemRole: 'user'
+        }, 'workspace-team');
+        expect(core.resolveUserAccess).toHaveBeenNthCalledWith(1, 'user-1', 'workspace-team', 'member');
+        expect(core.resolveUserAccess).toHaveBeenNthCalledWith(2, 'user-1', 'workspace-personal', 'member');
+        expect(next.workspaceId).toBe('workspace-personal');
+    });
 });

package/dist/server/mockStripe.d.ts

@@ -0,0 +1,72 @@
+import Stripe from 'stripe';
+export type MockStripeInterval = 'month' | 'year';
+type MockStripeCheckoutSessionRecord = {
+    id: string;
+    customerId: string;
+    customerEmail: string | null;
+    priceId: string;
+    interval: MockStripeInterval;
+    metadata: Record<string, string>;
+    subscriptionMetadata: Record<string, string>;
+    successUrl: string;
+    cancelUrl: string;
+    subscriptionId: string | null;
+    paymentStatus: 'unpaid' | 'paid';
+    status: 'open' | 'complete' | 'expired';
+};
+declare const MOCK_STRIPE_MARKER: unique symbol;
+export declare function isMockStripeEnabled(secretKeyRaw?: unknown): boolean;
+export declare function buildMockStripeHostedCheckoutUrl(baseUrl: string, sessionId: string): string;
+export declare function readMockStripeCheckoutSession(sessionIdRaw: unknown): MockStripeCheckoutSessionRecord | null;
+export declare function completeMockStripeCheckoutSession(sessionIdRaw: unknown): MockStripeCheckoutSessionRecord;
+export declare function renderMockStripeCheckoutHtml(input: {
+    sessionId: string;
+    planVersionId: string | null;
+    interval: MockStripeInterval;
+}): string;
+export interface MockStripeClient {
+    [MOCK_STRIPE_MARKER]: true;
+    checkout: {
+        sessions: {
+            create(params: Record<string, any>): Promise<Stripe.Checkout.Session>;
+            retrieve(id: string, params?: {
+                expand?: string[];
+            }): Promise<Stripe.Checkout.Session>;
+        };
+    };
+    subscriptions: {
+        list(params: Record<string, any>): Promise<{
+            data: Stripe.Subscription[];
+        }>;
+        retrieve(id: string): Promise<Stripe.Subscription>;
+        update(id: string, params: Record<string, any>): Promise<Stripe.Subscription>;
+    };
+    customers: {
+        list(params: Record<string, any>): Promise<{
+            data: Array<{
+                id: string;
+                email: string | null;
+            }>;
+        }>;
+    };
+    billingPortal: {
+        sessions: {
+            create(params: Record<string, any>): Promise<{
+                url: string;
+            }>;
+        };
+    };
+    prices: {
+        list(params: Record<string, any>): Promise<{
+            data: any[];
+            has_more: boolean;
+        }>;
+        retrieve(id: string): Promise<any>;
+    };
+    webhooks: {
+        constructEvent(payload: Buffer | string, _signature: string, _secret: string): any;
+    };
+}
+export declare function isMockStripeClient(value: unknown): value is MockStripeClient;
+export declare function createMockStripeClient(): MockStripeClient;
+export {};

package/dist/server/mockStripe.js

@@ -0,0 +1,357 @@
+const GLOBAL_STATE_KEY = '__taskforce_mock_stripe_state__';
+const MOCK_STRIPE_MARKER = Symbol.for('taskforce.mock.stripe');
+function normalizeEmail(raw) {
+    return String(raw || '').trim().toLowerCase();
+}
+function inferInterval(priceIdRaw, metadata) {
+    const metadataInterval = String(metadata?.billingInterval || metadata?.billing_interval || '').trim().toLowerCase();
+    if (metadataInterval === 'year')
+        return 'year';
+    if (metadataInterval === 'month')
+        return 'month';
+    const priceId = String(priceIdRaw || '').trim().toLowerCase();
+    if (priceId.includes('year') || priceId.endsWith('_yr') || priceId.endsWith('_annual'))
+        return 'year';
+    return 'month';
+}
+function createInitialState() {
+    return {
+        counters: {},
+        customers: new Map(),
+        customerIdsByEmail: new Map(),
+        subscriptions: new Map(),
+        sessions: new Map(),
+        prices: new Map()
+    };
+}
+function getMockStripeState() {
+    const root = globalThis;
+    if (!root[GLOBAL_STATE_KEY]) {
+        root[GLOBAL_STATE_KEY] = createInitialState();
+    }
+    return root[GLOBAL_STATE_KEY];
+}
+function nextId(prefix) {
+    const state = getMockStripeState();
+    const nextValue = Number(state.counters[prefix] || 0) + 1;
+    state.counters[prefix] = nextValue;
+    return `${prefix}_${nextValue.toString().padStart(6, '0')}`;
+}
+function ensureMockPrice(priceIdRaw, metadata) {
+    const state = getMockStripeState();
+    const priceId = String(priceIdRaw || '').trim();
+    const interval = inferInterval(priceId, metadata);
+    const existing = state.prices.get(priceId);
+    if (existing)
+        return existing;
+    const created = {
+        id: priceId,
+        interval
+    };
+    state.prices.set(priceId, created);
+    return created;
+}
+function findOrCreateCustomer(input) {
+    const state = getMockStripeState();
+    const explicitCustomerId = String(input.customerId || '').trim();
+    if (explicitCustomerId) {
+        const existing = state.customers.get(explicitCustomerId);
+        if (existing)
+            return existing;
+        const created = { id: explicitCustomerId, email: normalizeEmail(input.customerEmail) || null };
+        state.customers.set(created.id, created);
+        if (created.email)
+            state.customerIdsByEmail.set(created.email, created.id);
+        return created;
+    }
+    const normalizedEmail = normalizeEmail(input.customerEmail);
+    if (normalizedEmail) {
+        const existingId = state.customerIdsByEmail.get(normalizedEmail);
+        if (existingId) {
+            return state.customers.get(existingId);
+        }
+    }
+    const created = {
+        id: nextId('cus_mock'),
+        email: normalizedEmail || null
+    };
+    state.customers.set(created.id, created);
+    if (created.email)
+        state.customerIdsByEmail.set(created.email, created.id);
+    return created;
+}
+function formatMockSubscription(record) {
+    const priceRecord = ensureMockPrice(record.priceId, { billingInterval: record.interval });
+    return {
+        id: record.id,
+        object: 'subscription',
+        customer: record.customerId,
+        status: record.status,
+        metadata: { ...record.metadata },
+        trial_end: record.trialEnd,
+        items: {
+            object: 'list',
+            data: [
+                {
+                    id: `si_${record.id}`,
+                    object: 'subscription_item',
+                    current_period_end: record.currentPeriodEnd,
+                    price: {
+                        id: priceRecord.id,
+                        object: 'price',
+                        active: true,
+                        currency: 'usd',
+                        recurring: {
+                            interval: priceRecord.interval
+                        }
+                    }
+                }
+            ],
+            has_more: false,
+            url: ''
+        }
+    };
+}
+function formatMockCheckoutSession(record, expandSubscription = false) {
+    return {
+        id: record.id,
+        object: 'checkout.session',
+        mode: 'subscription',
+        customer: record.customerId,
+        customer_email: record.customerEmail,
+        metadata: { ...record.metadata },
+        payment_status: record.paymentStatus,
+        status: record.status,
+        subscription: record.subscriptionId
+            ? (expandSubscription ? formatMockSubscription(getMockStripeSubscription(record.subscriptionId)) : record.subscriptionId)
+            : null
+    };
+}
+function getMockStripeSubscription(subscriptionIdRaw) {
+    const state = getMockStripeState();
+    const subscriptionId = String(subscriptionIdRaw || '').trim();
+    const record = state.subscriptions.get(subscriptionId);
+    if (!record) {
+        const error = new Error(`No such mock subscription: ${subscriptionId}`);
+        error.code = 'resource_missing';
+        throw error;
+    }
+    return record;
+}
+export function isMockStripeEnabled(secretKeyRaw = process.env.TASKFORCE_STRIPE_SECRET_KEY) {
+    return String(secretKeyRaw || '').trim().toLowerCase() === 'mock';
+}
+export function buildMockStripeHostedCheckoutUrl(baseUrl, sessionId) {
+    return `${String(baseUrl || '').replace(/\/+$/, '')}/__taskforce/mock-stripe/checkout?session_id=${encodeURIComponent(sessionId)}`;
+}
+export function readMockStripeCheckoutSession(sessionIdRaw) {
+    const sessionId = String(sessionIdRaw || '').trim();
+    if (!sessionId)
+        return null;
+    return getMockStripeState().sessions.get(sessionId) || null;
+}
+export function completeMockStripeCheckoutSession(sessionIdRaw) {
+    const state = getMockStripeState();
+    const sessionId = String(sessionIdRaw || '').trim();
+    const session = state.sessions.get(sessionId);
+    if (!session) {
+        throw new Error(`No such mock checkout session: ${sessionId}`);
+    }
+    if (!session.subscriptionId) {
+        const subscriptionId = nextId('sub_mock');
+        state.subscriptions.set(subscriptionId, {
+            id: subscriptionId,
+            customerId: session.customerId,
+            status: 'active',
+            priceId: session.priceId,
+            interval: session.interval,
+            metadata: { ...session.subscriptionMetadata },
+            currentPeriodEnd: Math.floor(Date.now() / 1000) + (session.interval === 'year' ? 365 * 24 * 60 * 60 : 30 * 24 * 60 * 60),
+            trialEnd: null
+        });
+        session.subscriptionId = subscriptionId;
+    }
+    session.paymentStatus = 'paid';
+    session.status = 'complete';
+    state.sessions.set(session.id, session);
+    return session;
+}
+export function renderMockStripeCheckoutHtml(input) {
+    const planVersionId = String(input.planVersionId || '').trim() || 'selected-plan';
+    const intervalLabel = input.interval === 'year' ? 'Yearly' : 'Monthly';
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Mock Stripe Checkout</title>
+    <style>
+      body { font-family: ui-sans-serif, system-ui, sans-serif; background: #0b1220; color: #f8fafc; margin: 0; padding: 48px 24px; }
+      .shell { max-width: 640px; margin: 0 auto; background: #111827; border: 1px solid #1f2937; border-radius: 20px; padding: 32px; box-shadow: 0 24px 80px rgba(0,0,0,.35); }
+      h1 { margin: 0 0 12px; font-size: 28px; }
+      p { margin: 0 0 16px; color: #cbd5e1; line-height: 1.5; }
+      .meta { font-size: 14px; color: #94a3b8; margin-bottom: 24px; }
+      .actions { display: flex; gap: 12px; margin-top: 24px; }
+      a, button { appearance: none; border: 0; border-radius: 999px; padding: 12px 18px; font-weight: 600; cursor: pointer; text-decoration: none; }
+      .primary { background: #22c55e; color: #052e16; }
+      .secondary { background: transparent; color: #f8fafc; border: 1px solid #475569; }
+    </style>
+  </head>
+  <body>
+    <main class="shell">
+      <h1>Mock Stripe Checkout</h1>
+      <p>This test checkout page is standing in for Stripe so we can exercise the real Taskforce billing flow end to end.</p>
+      <div class="meta">Plan version: <strong>${planVersionId}</strong><br />Interval: <strong>${intervalLabel}</strong></div>
+      <div class="actions">
+        <a data-testid="mock-stripe-complete" class="primary" href="/__taskforce/mock-stripe/checkout/complete?session_id=${encodeURIComponent(input.sessionId)}">Complete purchase</a>
+        <a data-testid="mock-stripe-cancel" class="secondary" href="/__taskforce/mock-stripe/checkout/cancel?session_id=${encodeURIComponent(input.sessionId)}">Cancel</a>
+      </div>
+    </main>
+  </body>
+</html>`;
+}
+export function isMockStripeClient(value) {
+    return Boolean(value && typeof value === 'object' && value[MOCK_STRIPE_MARKER] === true);
+}
+export function createMockStripeClient() {
+    return {
+        [MOCK_STRIPE_MARKER]: true,
+        checkout: {
+            sessions: {
+                async create(params) {
+                    const customer = findOrCreateCustomer({
+                        customerId: params.customer,
+                        customerEmail: params.customer_email
+                    });
+                    const priceId = String(params.line_items?.[0]?.price || '').trim();
+                    const subscriptionMetadata = params.subscription_data?.metadata && typeof params.subscription_data.metadata === 'object'
+                        ? Object.fromEntries(Object.entries(params.subscription_data.metadata).map(([key, value]) => [key, String(value ?? '')]))
+                        : {};
+                    const interval = inferInterval(priceId, subscriptionMetadata);
+                    ensureMockPrice(priceId, subscriptionMetadata);
+                    const sessionId = nextId('cs_mock');
+                    const session = {
+                        id: sessionId,
+                        customerId: customer.id,
+                        customerEmail: customer.email,
+                        priceId,
+                        interval,
+                        metadata: params.metadata && typeof params.metadata === 'object'
+                            ? Object.fromEntries(Object.entries(params.metadata).map(([key, value]) => [key, String(value ?? '')]))
+                            : {},
+                        subscriptionMetadata,
+                        successUrl: String(params.success_url || '').trim(),
+                        cancelUrl: String(params.cancel_url || '').trim(),
+                        subscriptionId: null,
+                        paymentStatus: 'unpaid',
+                        status: 'open'
+                    };
+                    getMockStripeState().sessions.set(sessionId, session);
+                    return formatMockCheckoutSession(session);
+                },
+                async retrieve(id, params) {
+                    const record = readMockStripeCheckoutSession(id);
+                    if (!record) {
+                        const error = new Error(`No such mock checkout session: ${id}`);
+                        error.code = 'resource_missing';
+                        throw error;
+                    }
+                    const expandSubscription = Array.isArray(params?.expand) && params?.expand.includes('subscription');
+                    return formatMockCheckoutSession(record, expandSubscription);
+                }
+            }
+        },
+        subscriptions: {
+            async list(params) {
+                const customerId = String(params.customer || '').trim();
+                const status = String(params.status || 'all').trim().toLowerCase();
+                const subscriptions = Array.from(getMockStripeState().subscriptions.values())
+                    .filter((record) => !customerId || record.customerId === customerId)
+                    .filter((record) => status === 'all' || record.status === status)
+                    .map((record) => formatMockSubscription(record));
+                return { data: subscriptions };
+            },
+            async retrieve(id) {
+                return formatMockSubscription(getMockStripeSubscription(id));
+            },
+            async update(id, params) {
+                const state = getMockStripeState();
+                const record = getMockStripeSubscription(id);
+                const nextPriceId = String(params.items?.[0]?.price || record.priceId).trim();
+                const nextMetadata = params.metadata && typeof params.metadata === 'object'
+                    ? Object.fromEntries(Object.entries(params.metadata).map(([key, value]) => [key, String(value ?? '')]))
+                    : record.metadata;
+                const priceRecord = ensureMockPrice(nextPriceId, nextMetadata);
+                const updated = {
+                    ...record,
+                    priceId: nextPriceId,
+                    interval: priceRecord.interval,
+                    metadata: nextMetadata,
+                    status: record.status === 'canceled' ? 'active' : record.status,
+                    currentPeriodEnd: Math.floor(Date.now() / 1000) + (priceRecord.interval === 'year' ? 365 * 24 * 60 * 60 : 30 * 24 * 60 * 60)
+                };
+                state.subscriptions.set(id, updated);
+                return formatMockSubscription(updated);
+            }
+        },
+        customers: {
+            async list(params) {
+                const email = normalizeEmail(params.email);
+                const customers = Array.from(getMockStripeState().customers.values())
+                    .filter((record) => !email || normalizeEmail(record.email) === email)
+                    .map((record) => ({ id: record.id, email: record.email }));
+                return { data: customers };
+            }
+        },
+        billingPortal: {
+            sessions: {
+                async create(params) {
+                    return { url: String(params.return_url || '').trim() };
+                }
+            }
+        },
+        prices: {
+            async list(params) {
+                const interval = inferInterval('', params);
+                const data = Array.from(getMockStripeState().prices.values())
+                    .filter((record) => !params?.recurring?.interval || record.interval === interval)
+                    .map((record) => ({
+                    id: record.id,
+                    active: true,
+                    currency: 'usd',
+                    nickname: null,
+                    recurring: {
+                        interval: record.interval
+                    },
+                    product: {
+                        id: `prod_${record.id}`,
+                        name: record.id
+                    },
+                    unit_amount: null
+                }));
+                return {
+                    data,
+                    has_more: false
+                };
+            },
+            async retrieve(id) {
+                const record = ensureMockPrice(id);
+                return {
+                    id: record.id,
+                    active: true,
+                    currency: 'usd',
+                    recurring: {
+                        interval: record.interval
+                    },
+                    unit_amount: null
+                };
+            }
+        },
+        webhooks: {
+            constructEvent(payload) {
+                const raw = Buffer.isBuffer(payload) ? payload.toString('utf8') : String(payload || '');
+                return raw ? JSON.parse(raw) : {};
+            }
+        }
+    };
+}

package/dist/server/realtimeSyncWs.js

@@ -202,6 +202,10 @@ export function createRealtimeSyncWsManager(core, authConfig, logger = console,
             }
             const messageType = String(payload.type || '').trim();
             if (messageType === 'taskforce:subscribe') {
+                const clientProvidedUserId = typeof payload.userId === 'string' ? payload.userId.trim() : '';
+                if (clientProvidedUserId && state.userId === 'anonymous' && clientProvidedUserId.length < 100 && !/\s/.test(clientProvidedUserId)) {
+                    state.userId = clientProvidedUserId;
+                }
                 subscribeWorkspace(ws, state, parseWorkspaceId(payload.workspaceId));
                 return;
             }