@taskforcehq/taskforce 0.3.168

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

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

package/dist/hooks/useSyncOrchestrator.retry-closure.test.js

@@ -0,0 +1,367 @@
+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',
+        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: [],
+        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(),
+        ...overrides
+    };
+}
+describe('useSyncOrchestrator retry closure', () => {
+    beforeEach(() => {
+        localStorage.clear();
+        ensureCloudWorkspaceReadyForSyncServiceMock.mockResolvedValue({ success: true });
+        runWorkspacePullSyncServiceMock.mockResolvedValue({
+            success: false,
+            kind: 'pull_http',
+            status: 503,
+            cursor: null,
+            pages: 0,
+            appliedChanges: 0,
+            pullRequestMs: 1,
+            applyMs: 0,
+            pulledDeleteTaskIds: new Set(),
+            pulledActiveUpserts: false,
+            pulledArchivedUpserts: false
+        });
+        runWorkspacePushSyncServiceMock.mockResolvedValue({
+            success: true,
+            syncedAt: new Date().toISOString(),
+            changeCount: 0,
+            deleteCount: 0,
+            requestMs: 1,
+            currentTaskIds: new Set(),
+            pushedWatermarks: new Map(),
+            deleteTaskIds: new Set()
+        });
+        syncUserGlobalSettingsServiceMock.mockResolvedValue({
+            success: true,
+            mode: 'pulled',
+            updatedAt: new Date().toISOString()
+        });
+        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: {
+                            cloudSyncEnabled: true,
+                            sourceOfTruth: 'cloud',
+                            onboardingCompleted: true,
+                            pullCursor: ''
+                        }
+                    })
+                });
+            }
+            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')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ documents: [] }) });
+            }
+            if (url.includes('/api/taskforce/sync/events')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        }));
+    });
+    afterEach(() => {
+        vi.unstubAllGlobals();
+        vi.clearAllMocks();
+    });
+    it('uses latest pull callback when delayed retry fires after auth state changes', async () => {
+        let input = buildInput();
+        const { result, rerender } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: input
+        });
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                cloudSyncEnabled: true,
+                sourceOfTruth: 'cloud',
+                onboardingCompleted: true,
+                pullCursor: ''
+            });
+        });
+        await waitFor(() => {
+            expect(result.current.workspaceCloudSyncEnabled).toBe(true);
+        });
+        await act(async () => {
+            await result.current.pullWorkspaceChangesFromCloud();
+        });
+        await waitFor(() => {
+            expect(runWorkspacePullSyncServiceMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+        });
+        await waitFor(() => {
+            expect(result.current.workspaceRetryAt).not.toBeNull();
+        });
+        input = buildInput({
+            isAuthenticated: false,
+            checkAuthSession: vi.fn(async () => false)
+        });
+        rerender(input);
+        await act(async () => {
+            await new Promise((resolve) => setTimeout(resolve, 250));
+        });
+        expect(runWorkspacePullSyncServiceMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+    });
+    it('skips pull when another tab holds the workspace lease (non-leader coordination)', async () => {
+        const leaseKey = 'taskforce.sync.pullLease.v1.workspace-local-active';
+        window.localStorage.setItem(leaseKey, JSON.stringify({
+            owner: 'other-tab',
+            acquiredAt: Date.now(),
+            expiresAt: Date.now() + 30_000
+        }));
+        vi.stubGlobal('navigator', { locks: undefined });
+        const { result } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: buildInput()
+        });
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                cloudSyncEnabled: true,
+                sourceOfTruth: 'cloud',
+                onboardingCompleted: true,
+                pullCursor: ''
+            });
+        });
+        await act(async () => {
+            const pulled = await result.current.pullWorkspaceChangesFromCloud();
+            expect(pulled).toBe(false);
+        });
+        expect(runWorkspacePullSyncServiceMock).not.toHaveBeenCalled();
+    });
+    it('persists pull cursor/timestamps against the active workspace after workspace switch', async () => {
+        runWorkspacePullSyncServiceMock.mockResolvedValue({
+            success: true,
+            cursor: 'cursor-next',
+            pages: 1,
+            appliedChanges: 0,
+            pullRequestMs: 2,
+            applyMs: 1,
+            syncedAt: '2026-02-23T00:00:00.000Z',
+            pulledDeleteTaskIds: new Set(),
+            pulledActiveUpserts: false,
+            pulledArchivedUpserts: false
+        });
+        const uiStatePosts = [];
+        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: {
+                            cloudSyncEnabled: true,
+                            sourceOfTruth: 'cloud',
+                            onboardingCompleted: true,
+                            pullCursor: ''
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state') && String(init?.method || '').toUpperCase() === 'POST') {
+                const body = JSON.parse(String(init?.body || '{}'));
+                uiStatePosts.push(body);
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            if (url.includes('/api/taskforce/sync/workspace/documents')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ documents: [] }) });
+            }
+            if (url.includes('/api/taskforce/sync/events')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        }));
+        let input = buildInput({ currentWorkspaceId: 'workspace-a' });
+        const { result, rerender } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: input
+        });
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                cloudSyncEnabled: true,
+                sourceOfTruth: 'cloud',
+                onboardingCompleted: true,
+                pullCursor: ''
+            });
+        });
+        await act(async () => {
+            await result.current.pullWorkspaceChangesFromCloud();
+        });
+        input = buildInput({ currentWorkspaceId: 'workspace-b' });
+        rerender(input);
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                cloudSyncEnabled: true,
+                sourceOfTruth: 'cloud',
+                onboardingCompleted: true,
+                pullCursor: ''
+            });
+        });
+        await act(async () => {
+            await result.current.pullWorkspaceChangesFromCloud();
+        });
+        const syncPatchPosts = uiStatePosts.filter((entry) => entry?.stateKey === 'workspace-sync');
+        const workspaceIds = syncPatchPosts.map((entry) => entry?.workspaceId).filter(Boolean);
+        expect(workspaceIds).toContain('workspace-a');
+        expect(workspaceIds).toContain('workspace-b');
+    });
+    it('surfaces document decryption warning and reports structured apply error event', async () => {
+        runWorkspacePullSyncServiceMock.mockResolvedValue({
+            success: true,
+            cursor: 'cursor-warning',
+            pages: 1,
+            appliedChanges: 1,
+            pullRequestMs: 2,
+            applyMs: 1,
+            syncedAt: '2026-02-23T00:00:00.000Z',
+            pulledDeleteTaskIds: new Set(),
+            pulledActiveUpserts: false,
+            pulledArchivedUpserts: false,
+            documentDecryptFailures: ['docs/secret.md']
+        });
+        const syncEventBodies = [];
+        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: {
+                            cloudSyncEnabled: true,
+                            sourceOfTruth: 'cloud',
+                            onboardingCompleted: true,
+                            pullCursor: ''
+                        }
+                    })
+                });
+            }
+            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')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ documents: [] }) });
+            }
+            if (url.includes('/api/taskforce/sync/events')) {
+                syncEventBodies.push(JSON.parse(String(init?.body || '{}')));
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ success: true }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        }));
+        const { result } = renderHook((props) => useSyncOrchestrator(props), {
+            initialProps: buildInput()
+        });
+        act(() => {
+            result.current.applyWorkspaceSyncStateSnapshot({
+                cloudSyncEnabled: true,
+                sourceOfTruth: 'cloud',
+                onboardingCompleted: true,
+                pullCursor: ''
+            });
+        });
+        await waitFor(() => {
+            expect(result.current.workspaceCloudSyncEnabled).toBe(true);
+        });
+        await act(async () => {
+            await result.current.pullWorkspaceChangesFromCloud();
+        });
+        await waitFor(() => {
+            expect(result.current.workspaceLastWarningMessage).toBe('Some synced documents could not be decrypted (1).');
+        });
+        expect(syncEventBodies.some((entry) => entry.eventType === 'apply' && entry.status === 'error')).toBe(true);
+    });
+    it('forces a pull retry when pending push is blocked on hydration for too long', async () => {
+        vi.useFakeTimers();
+        runWorkspacePullSyncServiceMock.mockResolvedValue({
+            success: false,
+            kind: 'pull_http',
+            status: 503,
+            retryAfterMs: 60_000,
+            cursor: null,
+            pages: 0,
+            appliedChanges: 0,
+            pullRequestMs: 1,
+            applyMs: 0,
+            pulledDeleteTaskIds: new Set(),
+            pulledActiveUpserts: false,
+            pulledArchivedUpserts: false
+        });
+        try {
+            const { result } = renderHook((props) => useSyncOrchestrator(props), {
+                initialProps: buildInput()
+            });
+            act(() => {
+                result.current.applyWorkspaceSyncStateSnapshot({
+                    cloudSyncEnabled: true,
+                    sourceOfTruth: 'cloud',
+                    onboardingCompleted: true,
+                    pullCursor: ''
+                });
+            });
+            await act(async () => {
+                await result.current.pullWorkspaceChangesFromCloud();
+            });
+            expect(runWorkspacePullSyncServiceMock.mock.calls.length).toBeGreaterThanOrEqual(1);
+            expect(result.current.isWorkspacePullRetryPending()).toBe(true);
+            await act(async () => {
+                await result.current.pushWorkspaceChangesToCloud('sig-1');
+            });
+            expect(result.current.workspaceLastWarningMessage).toBe('Local changes queued — waiting for initial cloud pull before upload.');
+            await act(async () => {
+                await vi.advanceTimersByTimeAsync(46_000);
+            });
+            await act(async () => {
+                await result.current.pushWorkspaceChangesToCloud('sig-2');
+            });
+            await act(async () => {
+                await vi.advanceTimersByTimeAsync(250);
+            });
+            expect(runWorkspacePullSyncServiceMock.mock.calls.length).toBeGreaterThanOrEqual(2);
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+});