@taskforcehq/taskforce 0.3.309 → 0.3.313

package/dist/hooks/useRealtimeSync.test.js

@@ -1,311 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { act, renderHook, waitFor } from '@testing-library/react';
-import { useRealtimeSync } from './useRealtimeSync';
-class MockWebSocket {
-    static instances = [];
-    static OPEN = 1;
-    static CLOSED = 3;
-    url;
-    readyState = 0;
-    sent = [];
-    listeners = {
-        open: [],
-        message: [],
-        close: [],
-        error: []
-    };
-    constructor(url) {
-        this.url = url;
-        MockWebSocket.instances.push(this);
-    }
-    addEventListener(type, listener) {
-        this.listeners[type] = this.listeners[type] || [];
-        this.listeners[type].push(listener);
-    }
-    close() {
-        this.readyState = MockWebSocket.CLOSED;
-        this.emit('close', {});
-    }
-    send(payload) {
-        this.sent.push(payload);
-    }
-    emit(type, event) {
-        const handlers = this.listeners[type] || [];
-        handlers.forEach((handler) => handler(event));
-    }
-    open() {
-        this.readyState = MockWebSocket.OPEN;
-        this.emit('open', {});
-    }
-    message(payload) {
-        this.emit('message', { data: JSON.stringify(payload) });
-    }
-}
-describe('useRealtimeSync', () => {
-    afterEach(() => {
-        vi.useRealTimers();
-        vi.unstubAllGlobals();
-        MockWebSocket.instances = [];
-    });
-    it('connects, subscribes, and emits coalesced signal on update', async () => {
-        vi.stubGlobal('WebSocket', MockWebSocket);
-        const onSignal = vi.fn();
-        const { result } = renderHook(() => useRealtimeSync({
-            enabled: true,
-            workspaceId: 'ws-1',
-            websocketUrl: 'wss://example.com/taskforce-ws',
-            onSignal
-        }));
-        expect(MockWebSocket.instances).toHaveLength(1);
-        const socket = MockWebSocket.instances[0];
-        act(() => {
-            socket.open();
-            socket.message({ type: 'taskforce:update', workspaceId: 'ws-1' });
-            socket.message({ type: 'taskforce:update', workspaceId: 'ws-1' });
-        });
-        await waitFor(() => {
-            expect(result.current.connectionState).toBe('connected');
-        });
-        await waitFor(() => {
-            expect(onSignal).toHaveBeenCalledTimes(1);
-        });
-        const outboundTypes = socket.sent.map((entry) => JSON.parse(entry).type);
-        expect(outboundTypes).toContain('taskforce:subscribe');
-        expect(outboundTypes).toContain('taskforce:replay');
-    });
-    it('includes the resolved authenticated userId in subscribe payloads', async () => {
-        vi.stubGlobal('WebSocket', MockWebSocket);
-        renderHook(() => useRealtimeSync({
-            enabled: true,
-            workspaceId: 'ws-1',
-            websocketUrl: 'wss://example.com/taskforce-ws',
-            userId: 'user-42'
-        }));
-        const socket = MockWebSocket.instances[0];
-        act(() => {
-            socket.open();
-        });
-        await waitFor(() => {
-            expect(socket.sent.length).toBeGreaterThan(0);
-        });
-        const subscribePayload = socket.sent
-            .map((entry) => JSON.parse(entry))
-            .find((entry) => entry.type === 'taskforce:subscribe');
-        expect(subscribePayload).toMatchObject({
-            type: 'taskforce:subscribe',
-            workspaceId: 'ws-1',
-            userId: 'user-42'
-        });
-    });
-    it('reconnects with backoff and degrades after threshold', async () => {
-        vi.useFakeTimers();
-        vi.stubGlobal('WebSocket', MockWebSocket);
-        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
-        const { result } = renderHook(() => useRealtimeSync({
-            enabled: true,
-            workspaceId: 'ws-1',
-            websocketUrl: 'wss://example.com/taskforce-ws',
-            reconnectBaseMs: 100,
-            reconnectMaxMs: 100,
-            degradeAfterAttempts: 2
-        }));
-        const first = MockWebSocket.instances[0];
-        act(() => {
-            first.open();
-            first.emit('close', { code: 1006, reason: 'transport-lost' });
-        });
-        expect(result.current.connectionState).toBe('reconnecting');
-        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Realtime socket closed workspace=ws-1'));
-        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('code=1006'));
-        act(() => {
-            vi.advanceTimersByTime(100);
-        });
-        expect(MockWebSocket.instances).toHaveLength(2);
-        const second = MockWebSocket.instances[1];
-        act(() => {
-            second.close();
-        });
-        expect(result.current.connectionState).toBe('degraded-fallback');
-    });
-    it('does not connect when disabled', () => {
-        vi.stubGlobal('WebSocket', MockWebSocket);
-        const { result } = renderHook(() => useRealtimeSync({
-            enabled: false,
-            workspaceId: 'ws-1',
-            websocketUrl: 'wss://example.com/taskforce-ws'
-        }));
-        expect(MockWebSocket.instances).toHaveLength(0);
-        expect(result.current.connectionState).toBe('degraded-fallback');
-    });
-    it('resumes replay from last acknowledged cursor after reconnect', async () => {
-        vi.stubGlobal('WebSocket', MockWebSocket);
-        renderHook(() => useRealtimeSync({
-            enabled: true,
-            workspaceId: 'ws-1',
-            websocketUrl: 'wss://example.com/taskforce-ws'
-        }));
-        const first = MockWebSocket.instances[0];
-        act(() => {
-            first.open();
-            first.message({
-                type: 'taskforce:mutation',
-                workspaceId: 'ws-1',
-                serverEpoch: 'epoch-1',
-                seq: 5
-            });
-            first.close();
-        });
-        await waitFor(() => {
-            expect(MockWebSocket.instances.length).toBeGreaterThanOrEqual(2);
-        });
-        const second = MockWebSocket.instances[1];
-        act(() => {
-            second.open();
-        });
-        const replayPayloads = second.sent
-            .map((entry) => JSON.parse(entry))
-            .filter((entry) => entry.type === 'taskforce:replay');
-        expect(replayPayloads.length).toBeGreaterThanOrEqual(1);
-        expect(replayPayloads[0].cursor).toBe('epoch-1:5');
-    });
-    it('triggers full-resync signal once on replay-gap/reset until cursor recovers', async () => {
-        vi.stubGlobal('WebSocket', MockWebSocket);
-        const onSignal = vi.fn();
-        renderHook(() => useRealtimeSync({
-            enabled: true,
-            workspaceId: 'ws-1',
-            websocketUrl: 'wss://example.com/taskforce-ws',
-            onSignal
-        }));
-        const socket = MockWebSocket.instances[0];
-        act(() => {
-            socket.open();
-            socket.message({ type: 'taskforce:replay-gap', workspaceId: 'ws-1' });
-            socket.message({ type: 'taskforce:replay-reset', workspaceId: 'ws-1' });
-        });
-        await waitFor(() => {
-            expect(onSignal).toHaveBeenCalledTimes(1);
-        });
-        expect(onSignal.mock.calls[0][0]?.type).toBe('taskforce:replay-gap');
-        act(() => {
-            socket.message({
-                type: 'taskforce:mutation',
-                workspaceId: 'ws-1',
-                serverEpoch: 'epoch-2',
-                seq: 1
-            });
-            socket.message({ type: 'taskforce:replay-reset', workspaceId: 'ws-1' });
-        });
-        await waitFor(() => {
-            expect(onSignal.mock.calls.length).toBeGreaterThanOrEqual(2);
-        });
-        expect(onSignal.mock.calls[1][0]?.type).toBe('taskforce:replay-reset');
-    });
-    it('converts out-of-order mutation delivery into replay-gap recovery signal and telemetry', async () => {
-        vi.stubGlobal('WebSocket', MockWebSocket);
-        const onSignal = vi.fn();
-        const onTelemetry = vi.fn();
-        renderHook(() => useRealtimeSync({
-            enabled: true,
-            workspaceId: 'ws-1',
-            websocketUrl: 'wss://example.com/taskforce-ws',
-            onSignal,
-            onTelemetry
-        }));
-        const socket = MockWebSocket.instances[0];
-        act(() => {
-            socket.open();
-            socket.message({
-                type: 'taskforce:mutation',
-                workspaceId: 'ws-1',
-                eventId: 'epoch-1:1',
-                serverEpoch: 'epoch-1',
-                seq: 1
-            });
-            socket.message({
-                type: 'taskforce:mutation',
-                workspaceId: 'ws-1',
-                eventId: 'epoch-1:3',
-                serverEpoch: 'epoch-1',
-                seq: 3
-            });
-        });
-        await waitFor(() => {
-            expect(onSignal.mock.calls.some((call) => call?.[0]?.type === 'taskforce:replay-gap')).toBe(true);
-        });
-        await waitFor(() => {
-            expect(onTelemetry).toHaveBeenCalled();
-        });
-        const lastTelemetry = onTelemetry.mock.calls.at(-1)?.[0];
-        expect(lastTelemetry?.outOfOrderDiscarded).toBeGreaterThanOrEqual(1);
-        expect(lastTelemetry?.recoveryTriggered).toBeGreaterThanOrEqual(1);
-    });
-    it('prioritizes mutation over trailing update and keeps mutation eventId', async () => {
-        vi.stubGlobal('WebSocket', MockWebSocket);
-        const onSignal = vi.fn();
-        renderHook(() => useRealtimeSync({
-            enabled: true,
-            workspaceId: 'ws-1',
-            websocketUrl: 'wss://example.com/taskforce-ws',
-            onSignal
-        }));
-        const socket = MockWebSocket.instances[0];
-        act(() => {
-            socket.open();
-            socket.message({
-                type: 'taskforce:mutation',
-                workspaceId: 'ws-1',
-                eventId: 'epoch-1:10',
-                serverEpoch: 'epoch-1',
-                seq: 10
-            });
-            socket.message({
-                type: 'taskforce:update',
-                workspaceId: 'ws-1'
-            });
-        });
-        await waitFor(() => {
-            expect(onSignal).toHaveBeenCalledTimes(1);
-        });
-        expect(onSignal.mock.calls[0][0]).toMatchObject({
-            type: 'taskforce:mutation',
-            workspaceId: 'ws-1',
-            eventId: 'epoch-1:10'
-        });
-    });
-    it('does not emit replay signal for duplicate-only replay batch', async () => {
-        vi.stubGlobal('WebSocket', MockWebSocket);
-        const onSignal = vi.fn();
-        renderHook(() => useRealtimeSync({
-            enabled: true,
-            workspaceId: 'ws-1',
-            websocketUrl: 'wss://example.com/taskforce-ws',
-            onSignal
-        }));
-        const socket = MockWebSocket.instances[0];
-        act(() => {
-            socket.open();
-            socket.message({
-                type: 'taskforce:replay',
-                workspaceId: 'ws-1',
-                events: [
-                    { eventId: 'epoch-1:1', serverEpoch: 'epoch-1', seq: 1 }
-                ]
-            });
-            socket.message({
-                type: 'taskforce:replay',
-                workspaceId: 'ws-1',
-                events: [
-                    { eventId: 'epoch-1:1', serverEpoch: 'epoch-1', seq: 1 }
-                ]
-            });
-        });
-        await waitFor(() => {
-            expect(onSignal).toHaveBeenCalledTimes(1);
-        });
-        expect(onSignal.mock.calls[0][0]).toMatchObject({
-            type: 'taskforce:replay',
-            workspaceId: 'ws-1'
-        });
-    });
-});

package/dist/hooks/useSyncOrchestrator.aiProfiles.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/useSyncOrchestrator.aiProfiles.test.js

@@ -1,54 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { normalizeWorkspaceSyncAiProfileSnapshotEntry } from './useSyncOrchestrator';
-describe('normalizeWorkspaceSyncAiProfileSnapshotEntry', () => {
-    it('accepts snake_case ai profile payloads from sync snapshot routes', () => {
-        const entry = normalizeWorkspaceSyncAiProfileSnapshotEntry({
-            id: 'ai-profile-codex',
-            workspace_id: 'workspace-local-active',
-            profile_token: 'token-codex',
-            name: 'Codex',
-            username: 'codex',
-            icon: 'Bot',
-            color: '#0ea5e9',
-            description: 'Terminal-first coding agent',
-            role: 'Implementer',
-            provider: 'OpenAI',
-            model: 'gpt-5.4',
-            surface_type: 'coding_tool',
-            seat_scope: 'cloud_metered',
-            provider_metadata: { source: 'test' },
-            archived_at: '2026-03-16T18:00:00.000Z',
-            archived_by: 'owner-1',
-            archived_reason: 'manual_archive',
-            merged_into_profile_id: 'ai-profile-keeper',
-            roster_state_updated_at: '2026-03-16T18:00:00.000Z',
-            created_at: '2026-03-15T18:00:00.000Z',
-            updated_at: '2026-03-15T18:30:00.000Z',
-            last_active_at: '2026-03-15T18:45:00.000Z'
-        });
-        expect(entry).toEqual({
-            id: 'ai-profile-codex',
-            workspaceId: 'workspace-local-active',
-            profileToken: 'token-codex',
-            name: 'Codex',
-            username: 'codex',
-            icon: 'Bot',
-            color: '#0ea5e9',
-            description: 'Terminal-first coding agent',
-            role: 'Implementer',
-            provider: 'OpenAI',
-            model: 'gpt-5.4',
-            surfaceType: 'coding_tool',
-            seatScope: 'cloud_metered',
-            providerMetadata: { source: 'test' },
-            archivedAt: '2026-03-16T18:00:00.000Z',
-            archivedBy: 'owner-1',
-            archivedReason: 'manual_archive',
-            mergedIntoProfileId: 'ai-profile-keeper',
-            rosterStateUpdatedAt: '2026-03-16T18:00:00.000Z',
-            createdAt: '2026-03-15T18:00:00.000Z',
-            updatedAt: '2026-03-15T18:30:00.000Z',
-            lastActiveAt: '2026-03-15T18:45:00.000Z'
-        });
-    });
-});

package/dist/hooks/useSyncOrchestrator.context-assets.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hooks/useSyncOrchestrator.context-assets.test.js

@@ -1,228 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { act, renderHook, waitFor } from '@testing-library/react';
-import { useSyncOrchestrator } from './useSyncOrchestrator';
-const { ensureCloudWorkspaceReadyForSyncServiceMock, runWorkspacePullSyncServiceMock, runWorkspacePushSyncServiceMock, syncUserGlobalSettingsServiceMock } = vi.hoisted(() => ({
-    ensureCloudWorkspaceReadyForSyncServiceMock: vi.fn(),
-    runWorkspacePullSyncServiceMock: vi.fn(),
-    runWorkspacePushSyncServiceMock: vi.fn(),
-    syncUserGlobalSettingsServiceMock: vi.fn()
-}));
-vi.mock('../sync/syncService', async () => {
-    const actual = await vi.importActual('../sync/syncService');
-    return {
-        ...actual,
-        calculateWorkspaceRetryDelayMs: vi.fn(() => 100),
-        ensureCloudWorkspaceReadyForSyncService: ensureCloudWorkspaceReadyForSyncServiceMock,
-        runWorkspacePullSyncService: runWorkspacePullSyncServiceMock,
-        runWorkspacePushSyncService: runWorkspacePushSyncServiceMock,
-        syncUserGlobalSettingsService: syncUserGlobalSettingsServiceMock
-    };
-});
-function buildInput(overrides) {
-    return {
-        currentWorkspaceId: 'workspace-local-active',
-        cloudAuthConfigured: true,
-        runtimeMode: 'local',
-        authSessionResolved: true,
-        isAuthenticated: true,
-        authUserId: 'user-1',
-        projectName: 'Test Project',
-        resolveCloudAuthUrl: (path) => `https://cloud.example.com${path}`,
-        resolveWebSocketUrl: (path) => `wss://api.example.com${path}`,
-        realtimeSyncEnabled: false,
-        tasks: [],
-        archivedTasks: [],
-        initiatives: [],
-        workstreams: [],
-        taxonomies: [],
-        setupState: null,
-        globalTheme: 'dark',
-        locale: 'en-US',
-        globalWeekStartsOn: 'monday',
-        themeUseGlobalDefault: true,
-        setTasks: vi.fn(),
-        setArchivedTasks: vi.fn(),
-        setAuthBlocked: vi.fn(),
-        setIsAuthenticated: vi.fn(),
-        checkAuthSession: vi.fn(async () => true),
-        setGlobalTheme: vi.fn(),
-        setCurrentTheme: vi.fn(),
-        setSetupState: vi.fn(),
-        setLocale: vi.fn(),
-        setGlobalWeekStartsOn: vi.fn(),
-        fetchPlanningEntities: vi.fn(async () => { }),
-        ...overrides
-    };
-}
-describe('useSyncOrchestrator context asset refreshes', () => {
-    beforeEach(() => {
-        ensureCloudWorkspaceReadyForSyncServiceMock.mockReset();
-        runWorkspacePullSyncServiceMock.mockReset();
-        runWorkspacePushSyncServiceMock.mockReset();
-        syncUserGlobalSettingsServiceMock.mockReset();
-        ensureCloudWorkspaceReadyForSyncServiceMock.mockResolvedValue({ success: true });
-        runWorkspacePullSyncServiceMock.mockResolvedValue({
-            success: true,
-            syncedAt: '2026-03-15T18:00:00.000Z',
-            cursor: null,
-            pages: 0,
-            appliedChanges: 0,
-            pullRequestMs: 1,
-            applyMs: 0,
-            pulledDeleteTaskIds: new Set(),
-            pulledActiveUpserts: false,
-            pulledArchivedUpserts: false,
-            documentDecryptFailures: []
-        });
-        runWorkspacePushSyncServiceMock.mockResolvedValue({
-            success: true,
-            syncedAt: '2026-03-15T18:00:00.000Z',
-            requestMs: 1,
-            changeCount: 0,
-            deleteCount: 0,
-            currentTaskIds: new Set(),
-            currentInitiativeIds: new Set(),
-            currentInitiativeWatermarks: new Map(),
-            currentWorkstreamIds: new Set(),
-            currentWorkstreamWatermarks: new Map(),
-            currentAiProfileIds: new Set(),
-            currentAiProfileWatermarks: new Map(),
-            currentDocumentPaths: new Set(),
-            currentDocumentWatermarks: new Map(),
-            currentAssetPaths: new Set(),
-            currentAssetWatermarks: new Map(),
-            currentDocumentReviewSessionIds: new Set(),
-            currentDocumentReviewSessionWatermarks: new Map(),
-            currentDocumentReviewCommentIds: new Set(),
-            currentDocumentReviewCommentWatermarks: new Map(),
-            currentAnnotatedAttachmentSessionIds: new Set(),
-            currentAnnotatedAttachmentSessionWatermarks: new Map(),
-            currentTaskEventWatermarks: new Map(),
-            deleteTaskIds: new Set(),
-            pushedWatermarks: new Map(),
-            emittedEventIds: []
-        });
-        syncUserGlobalSettingsServiceMock.mockResolvedValue({
-            success: true,
-            mode: 'pulled',
-            updatedAt: new Date().toISOString()
-        });
-    });
-    afterEach(() => {
-        vi.unstubAllGlobals();
-        vi.clearAllMocks();
-    });
-    it('refreshes only document and asset snapshots when task attachments change', async () => {
-        const fetchCounts = {
-            documents: 0,
-            assets: 0,
-            aiProfiles: 0,
-            documentReviews: 0,
-            annotatedAttachments: 0
-        };
-        vi.stubGlobal('fetch', vi.fn((url, init) => {
-            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
-                return Promise.resolve({
-                    ok: true,
-                    json: () => Promise.resolve({
-                        success: true,
-                        state: {
-                            version: 2,
-                            enabled: true,
-                            phase: 'active',
-                            pullCursor: null,
-                            lastPullAt: null,
-                            lastPushAt: null,
-                            lastSyncedAt: null
-                        }
-                    })
-                });
-            }
-            if (url.includes('/api/taskforce/ui-state') && String(init?.method || '').toUpperCase() === 'POST') {
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
-            }
-            if (url.includes('/api/taskforce/sync/workspace/documents')) {
-                fetchCounts.documents += 1;
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ documents: [] }) });
-            }
-            if (url.includes('/api/taskforce/sync/workspace/assets')) {
-                fetchCounts.assets += 1;
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ assets: [] }) });
-            }
-            if (url.includes('/api/taskforce/sync/workspace/ai-profiles')) {
-                fetchCounts.aiProfiles += 1;
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ aiProfiles: [] }) });
-            }
-            if (url.includes('/api/taskforce/sync/workspace/document-reviews')) {
-                fetchCounts.documentReviews += 1;
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ sessions: [], comments: [] }) });
-            }
-            if (url.includes('/api/taskforce/sync/workspace/annotated-attachments')) {
-                fetchCounts.annotatedAttachments += 1;
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ sessions: [] }) });
-            }
-            if (url.includes('/api/taskforce/sync/events')) {
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
-            }
-            if (url.includes('/api/taskforce/tasks')) {
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ tasks: [] }) });
-            }
-            if (url.includes('/api/taskforce/archive')) {
-                return Promise.resolve({ ok: true, json: () => Promise.resolve({ archived: [] }) });
-            }
-            return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
-        }));
-        const baseTask = {
-            id: 'task-with-attachments',
-            title: 'Task with attachment refreshes',
-            description: '',
-            category: 'general',
-            type: 'task',
-            priority: 2,
-            complexity: 3,
-            status: 'task',
-            createdAt: '2026-03-15T12:00:00.000Z',
-            updatedAt: '2026-03-15T12:00:00.000Z',
-            attachments: [],
-            taskEvents: []
-        };
-        const initialInput = buildInput({
-            tasks: [baseTask]
-        });
-        const { result, rerender, unmount } = renderHook((props) => useSyncOrchestrator(props), {
-            initialProps: initialInput
-        });
-        act(() => {
-            result.current.applyWorkspaceSyncStateSnapshot({
-                enabled: true,
-                phase: 'active',
-                pullCursor: null
-            });
-        });
-        await waitFor(() => {
-            expect(fetchCounts.documents).toBeGreaterThan(0);
-            expect(fetchCounts.assets).toBeGreaterThan(0);
-            expect(fetchCounts.aiProfiles).toBeGreaterThan(0);
-            expect(fetchCounts.documentReviews).toBeGreaterThan(0);
-        });
-        const baselineCounts = { ...fetchCounts };
-        rerender({
-            ...initialInput,
-            tasks: [{
-                    ...baseTask,
-                    attachments: [{
-                            id: 'asset-1',
-                            path: 'workspaces/workspace-local-active/assets/file.txt'
-                        }]
-                }]
-        });
-        await waitFor(() => {
-            expect(fetchCounts.documents).toBeGreaterThan(baselineCounts.documents);
-            expect(fetchCounts.assets).toBeGreaterThan(baselineCounts.assets);
-        });
-        expect(fetchCounts.aiProfiles).toBe(baselineCounts.aiProfiles);
-        expect(fetchCounts.documentReviews).toBe(baselineCounts.documentReviews);
-        expect(fetchCounts.annotatedAttachments).toBe(baselineCounts.annotatedAttachments);
-        unmount();
-    });
-});

package/dist/hooks/useSyncOrchestrator.retry-closure.test.d.ts

@@ -1 +0,0 @@
-export {};