@taskforcehq/taskforce 0.3.302 → 0.3.304

package/dist/hooks/useTaskMutations.js

@@ -1,21 +1,46 @@
-import { useState, useCallback, useRef } from 'react';
+import { useState, useCallback, useEffect, useRef } from 'react';
 import { normalizeTaskFromApi } from '../utils/taskNormalization.js';
 export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks, setArchivedTasks, setDeletedTasks, setError, resetForm, setActiveTab, fetchTasks, fetchArchive, fetchDeletedTasks, mergeTaskFromServer, pushNotice, cloudAuthConfigured, runtimeMode, isAuthenticated, workspaceCloudSyncEnabled, buildWorkspaceSyncSignature, pushWorkspaceChangesToCloud, workspacePendingSignatureRef, workspaceDeletedTaskIdsRef, }) {
     // Copy ID state + timer ref
     const [copiedId, setCopiedId] = useState(null);
     const copiedIdTimerRef = useRef(null);
+    const workspaceSyncTimerRef = useRef(null);
+    const workspaceSyncTargetAtRef = useRef(null);
+    useEffect(() => () => {
+        if (typeof window === 'undefined')
+            return;
+        if (workspaceSyncTimerRef.current !== null) {
+            window.clearTimeout(workspaceSyncTimerRef.current);
+            workspaceSyncTimerRef.current = null;
+        }
+        workspaceSyncTargetAtRef.current = null;
+    }, []);
     const queueWorkspaceSyncFromAuthoritativeTaskState = useCallback((delayMs = 0) => {
         if (!(cloudAuthConfigured && runtimeMode === 'local' && isAuthenticated && workspaceCloudSyncEnabled))
             return;
         if (typeof window === 'undefined')
             return;
-        window.setTimeout(() => {
+        const normalizedDelayMs = Math.max(0, delayMs);
+        const requestedTargetAt = Date.now() + normalizedDelayMs;
+        const existingTargetAt = workspaceSyncTargetAtRef.current;
+        if (workspaceSyncTimerRef.current !== null) {
+            if (normalizedDelayMs <= 0)
+                return;
+            if (existingTargetAt !== null && existingTargetAt >= requestedTargetAt)
+                return;
+            window.clearTimeout(workspaceSyncTimerRef.current);
+            workspaceSyncTimerRef.current = null;
+        }
+        workspaceSyncTargetAtRef.current = requestedTargetAt;
+        workspaceSyncTimerRef.current = window.setTimeout(() => {
+            workspaceSyncTimerRef.current = null;
+            workspaceSyncTargetAtRef.current = null;
             const signature = buildWorkspaceSyncSignature();
             if (!signature)
                 return;
             workspacePendingSignatureRef.current = signature;
             void pushWorkspaceChangesToCloud(signature);
-        }, Math.max(0, delayMs));
+        }, normalizedDelayMs);
     }, [
         cloudAuthConfigured,
         runtimeMode,
@@ -227,8 +252,20 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
     }, [tasks, archivedTasks, pushNotice, mergeTaskFromServer, queueWorkspaceSyncFromAuthoritativeTaskState]);
     const handleToggleComplete = async (task) => {
         const newStatus = task.status === 'done' ? 'task' : 'done';
+        const completedAt = newStatus === 'done' ? new Date().toISOString() : undefined;
+        const optimisticUpdates = {
+            status: newStatus,
+            completedAt,
+            completed: newStatus === 'done',
+            inProgress: false,
+            readyForReview: false,
+            cancelled: false
+        };
+        const previousTasks = tasks;
+        const previousArchivedTasks = archivedTasks;
+        setTasks(prev => prev.map(t => t.id === task.id ? { ...t, ...optimisticUpdates } : t));
+        setArchivedTasks(prev => prev.map(t => t.id === task.id ? { ...t, ...optimisticUpdates } : t));
         try {
-            const completedAt = newStatus === 'done' ? new Date().toISOString() : undefined;
             const res = await fetch(`/api/taskforce/task/${task.id}`, {
                 method: 'PATCH',
                 headers: { 'Content-Type': 'application/json' },
@@ -239,7 +276,8 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
                 const message = data.error || 'Failed to update task status.';
                 setError(message);
                 pushNotice(message, 'error');
-                await fetchTasks(true);
+                setTasks(previousTasks);
+                setArchivedTasks(previousArchivedTasks);
                 return;
             }
             const updatedTask = await res.json().catch(() => null);
@@ -257,7 +295,8 @@ export function useTaskMutations({ tasks, archivedTasks, editingTaskId, setTasks
             console.error("Failed to toggle complete", err);
             setError('Failed to update task status.');
             pushNotice('Failed to update task status.', 'error');
-            fetchTasks();
+            setTasks(previousTasks);
+            setArchivedTasks(previousArchivedTasks);
         }
     };
     const handleToggleCancel = async (task) => {

package/dist/hooks/useTaskMutations.test.js

@@ -6,9 +6,84 @@ describe('useTaskMutations', () => {
         vi.stubGlobal('fetch', vi.fn());
     });
     afterEach(() => {
+        vi.useRealTimers();
         vi.unstubAllGlobals();
         vi.clearAllMocks();
     });
+    const baseTask = {
+        id: 'task-1',
+        title: 'Test task',
+        description: '',
+        category: 'general',
+        type: 'task',
+        priority: 2,
+        complexity: 3,
+        status: 'task',
+        createdAt: '2026-04-03T10:00:00.000Z',
+        updatedAt: '2026-04-03T10:05:00.000Z'
+    };
+    const buildHook = (overrides = {}) => {
+        const setTasks = vi.fn();
+        const setArchivedTasks = vi.fn();
+        const setDeletedTasks = vi.fn();
+        const setError = vi.fn();
+        const resetForm = vi.fn();
+        const setActiveTab = vi.fn();
+        const fetchTasks = vi.fn();
+        const fetchArchive = vi.fn();
+        const fetchDeletedTasks = vi.fn();
+        const mergeTaskFromServer = vi.fn();
+        const pushNotice = vi.fn();
+        const buildWorkspaceSyncSignature = vi.fn(() => 'sig-1');
+        const pushWorkspaceChangesToCloud = vi.fn();
+        const workspacePendingSignatureRef = { current: null };
+        const workspaceDeletedTaskIdsRef = { current: new Set() };
+        const hook = renderHook(() => useTaskMutations({
+            tasks: [baseTask],
+            archivedTasks: [],
+            editingTaskId: null,
+            setTasks,
+            setArchivedTasks,
+            setDeletedTasks,
+            setError,
+            resetForm,
+            setActiveTab,
+            fetchTasks,
+            fetchArchive,
+            fetchDeletedTasks,
+            mergeTaskFromServer,
+            pushNotice,
+            cloudAuthConfigured: true,
+            runtimeMode: 'local',
+            isAuthenticated: true,
+            workspaceCloudSyncEnabled: true,
+            buildWorkspaceSyncSignature,
+            pushWorkspaceChangesToCloud,
+            workspacePendingSignatureRef,
+            workspaceDeletedTaskIdsRef,
+            ...overrides
+        }));
+        return {
+            ...hook,
+            deps: {
+                setTasks,
+                setArchivedTasks,
+                setDeletedTasks,
+                setError,
+                resetForm,
+                setActiveTab,
+                fetchTasks,
+                fetchArchive,
+                fetchDeletedTasks,
+                mergeTaskFromServer,
+                pushNotice,
+                buildWorkspaceSyncSignature,
+                pushWorkspaceChangesToCloud,
+                workspacePendingSignatureRef,
+                workspaceDeletedTaskIdsRef
+            }
+        };
+    };
     it('clears pending delete ids when a deleted task is restored', async () => {
         const fetchMock = vi.mocked(fetch);
         fetchMock.mockResolvedValue({
@@ -77,4 +152,76 @@ describe('useTaskMutations', () => {
         expect(pushWorkspaceChangesToCloud).toHaveBeenCalledWith('sig-1');
         expect(setDeletedTasks).toHaveBeenCalled();
     });
+    it('optimistically marks a task done before the server responds', async () => {
+        let resolveResponse;
+        const fetchMock = vi.mocked(fetch);
+        fetchMock.mockImplementation(() => new Promise((resolve) => {
+            resolveResponse = resolve;
+        }));
+        const { result, deps } = buildHook();
+        let togglePromise = null;
+        await act(async () => {
+            togglePromise = result.current.handleToggleComplete(baseTask);
+        });
+        expect(deps.setTasks).toHaveBeenCalledTimes(1);
+        const optimisticUpdater = deps.setTasks.mock.calls[0]?.[0];
+        const optimisticTasks = optimisticUpdater([baseTask]);
+        expect(optimisticTasks[0]?.status).toBe('done');
+        expect(optimisticTasks[0]?.completed).toBe(true);
+        resolveResponse({
+            ok: true,
+            status: 200,
+            json: async () => ({ ...baseTask, status: 'done', completedAt: '2026-04-14T12:00:00.000Z' })
+        });
+        await act(async () => {
+            await togglePromise;
+        });
+        expect(deps.mergeTaskFromServer).toHaveBeenCalledWith(expect.objectContaining({ id: 'task-1', status: 'done' }));
+    });
+    it('rolls back the optimistic done state when the server update fails', async () => {
+        const fetchMock = vi.mocked(fetch);
+        fetchMock.mockResolvedValue({
+            ok: false,
+            status: 500,
+            json: async () => ({ error: 'Server exploded' })
+        });
+        const { result, deps } = buildHook();
+        await act(async () => {
+            await result.current.handleToggleComplete(baseTask);
+        });
+        expect(deps.setTasks).toHaveBeenCalledTimes(2);
+        expect(deps.setTasks.mock.calls[1]?.[0]).toEqual([baseTask]);
+        expect(deps.setArchivedTasks.mock.calls[1]?.[0]).toEqual([]);
+        expect(deps.pushNotice).toHaveBeenCalledWith('Server exploded', 'error');
+        expect(deps.mergeTaskFromServer).not.toHaveBeenCalled();
+    });
+    it('coalesces pending workspace sync pushes and preserves attachment delay', async () => {
+        vi.useFakeTimers();
+        const fetchMock = vi.mocked(fetch);
+        fetchMock.mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: async () => ({ ...baseTask, updatedAt: '2026-04-14T12:00:00.000Z' })
+        });
+        const { result, deps } = buildHook();
+        await act(async () => {
+            await result.current.handleUpdateTask(baseTask.id, { description: 'First update' });
+        });
+        await act(async () => {
+            await result.current.handleUpdateTask(baseTask.id, {
+                attachments: [{ id: 'asset-1', path: 'workspaces/workspace-local-active/assets/file.txt' }]
+            });
+        });
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(149);
+        });
+        expect(deps.pushWorkspaceChangesToCloud).not.toHaveBeenCalled();
+        await act(async () => {
+            await vi.advanceTimersByTimeAsync(1);
+        });
+        expect(deps.buildWorkspaceSyncSignature).toHaveBeenCalledTimes(1);
+        expect(deps.workspacePendingSignatureRef.current).toBe('sig-1');
+        expect(deps.pushWorkspaceChangesToCloud).toHaveBeenCalledTimes(1);
+        expect(deps.pushWorkspaceChangesToCloud).toHaveBeenCalledWith('sig-1');
+    });
 });

package/dist/hooks/useTaskforce.d.ts

@@ -122,7 +122,7 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
     authUserDisplayName: string;
     authUserAvatarUrl: string;
     authWorkspaceId: string;
-    userGlobalSyncStatus: "error" | "idle" | "syncing" | "disconnected";
+    userGlobalSyncStatus: "error" | "idle" | "disconnected" | "syncing";
     workspaceLastPullAt: string | null;
     workspaceLastPushAt: string | null;
     workspaceLastErrorAt: string | null;
@@ -193,6 +193,12 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
     runtimeCapabilities: RuntimeCapabilities | null;
     refreshSetupContext: () => Promise<void>;
     retryBootstrapChecks: () => Promise<void>;
+    continueAfterCommercialOnboarding: () => Promise<{
+        success: boolean;
+        destination: "app" | "setup" | "login";
+        error?: string;
+        code?: string;
+    }>;
     saveWorkspaceProfile: (input: {
         name: string;
         description?: string;
@@ -206,7 +212,7 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
     fetchWorkspaces: () => Promise<{
         success: boolean;
         error?: string;
-        workspaces?: WorkspaceSummary[];
+        workspaces?: import("./workspace/useTaskforceWorkspaceBootstrap").WorkspaceSummary[];
     }>;
     createWorkspace: (name: string, description?: string) => Promise<{
         success: boolean;
@@ -249,6 +255,9 @@ export declare function useTaskforce({ config, initialTaskId, onTaskCountChange,
         emailSent?: boolean;
         emailError?: string;
         workspaceSetupRequired?: boolean;
+        planSelectionRequired?: boolean;
+        checkoutPending?: boolean;
+        commercialState?: string | null;
     }>;
     updateCurrentUserProfile: (input: {
         displayName: string;