@taskforcehq/taskforce 0.3.303 → 0.3.305

package/dist/hooks/useTaskforce.sync-behavior.test.js

@@ -1097,6 +1097,84 @@ describe('useTaskforce sync behavior', () => {
             expect(result.current.authSessionResolved).toBe(true);
         });
     });
+    it('keeps loopback cloud runtime auth on same-origin after runtime config resolves', async () => {
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'cloud',
+                        workspaceMode: 'multi-cloud',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: true
+                    }
+                });
+            }
+            if (url.startsWith('https://app.taskforcehq.ai/api/taskforce/auth/session')) {
+                return jsonResponse({ authenticated: false, authRequiredForApi: true }, 401);
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: true,
+                    authRequiredForApi: true,
+                    betaAccess: true,
+                    userId: 'user-1',
+                    email: 'user@example.com',
+                    workspaceId: 'workspace-cloud-1'
+                });
+            }
+            if (url.includes('/api/taskforce/ui-state?key=app'))
+                return jsonResponse({ success: true, state: {} });
+            if (url.includes('/api/taskforce/ui-state?key=workspace-sync')) {
+                return jsonResponse({
+                    success: true,
+                    state: { version: 2, enabled: false, phase: 'idle', pullCursor: null }
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    projectName: 'Loopback Cloud Project',
+                    workspaceId: 'workspace-cloud-1',
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    userId: 'user-1',
+                    setupState: {
+                        globalSetupState: 'complete',
+                        workspaceSetupState: 'complete',
+                        workspaceId: 'workspace-cloud-1'
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/categories'))
+                return jsonResponse({ categories: [{ value: 'general', label: 'General' }] });
+            if (url.includes('/api/taskforce/types'))
+                return jsonResponse({ types: [] });
+            if (url.includes('/api/taskforce/priorities'))
+                return jsonResponse({ priorities: [] });
+            if (url.includes('/api/taskforce/approaches'))
+                return jsonResponse({ approaches: [] });
+            if (url.includes('/api/taskforce/specialists'))
+                return jsonResponse({ specialists: [] });
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [activeTask] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/workspace/assignee-options'))
+                return jsonResponse({ assignees: [] });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            return jsonResponse({});
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const { result } = renderHook(() => useTaskforce({ config: { cloudAuthBaseUrl: 'https://app.taskforcehq.ai' } }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.authSessionResolved).toBe(true);
+            expect(result.current.isAuthenticated).toBe(true);
+            expect(result.current.currentWorkspaceId).toBe('workspace-cloud-1');
+        });
+        expect(fetchMock.mock.calls.some(([url]) => String(url).startsWith('https://app.taskforcehq.ai/api/taskforce/auth/session'))).toBe(false);
+    });
     it('enables cloud realtime refresh for authenticated sessions and refreshes open task comments from signals', async () => {
         vi.stubGlobal('WebSocket', MockWebSocket);
         let invalidationTaskFetchCount = 0;

package/dist/hooks/useWorkspaceSyncController.d.ts

@@ -1,5 +1,5 @@
 import type { EnsureWorkspaceReadyResult } from '../sync/syncService';
-import { type WorkspaceSyncPhase, type WorkspaceSyncStateV2 } from '../sync/workspaceSyncState';
+import { type WorkspaceSyncSetupIntent, type WorkspaceSyncPhase, type WorkspaceSyncStateV2 } from '../sync/workspaceSyncState';
 type WorkspaceSyncLeaseOperation = 'pull' | 'push' | 'repair';
 interface WorkspaceSyncLeaseRecord {
     ownerId: string;
@@ -12,6 +12,7 @@ interface UseWorkspaceSyncControllerInput {
     currentWorkspaceId: string;
     setWorkspaceCloudSyncEnabled: (value: boolean) => void;
     setWorkspaceSyncPhase: (value: WorkspaceSyncPhase) => void;
+    setWorkspaceSyncSetupIntent: (value: WorkspaceSyncSetupIntent) => void;
     setWorkspaceLastPullAt: (value: string | null) => void;
     setWorkspaceLastPushAt: (value: string | null) => void;
     setWorkspaceLastErrorMessage: (value: string | null) => void;
@@ -30,12 +31,14 @@ export declare function useWorkspaceSyncController(input: UseWorkspaceSyncContro
     workspacePendingSignatureRef: import("react").RefObject<string>;
     workspaceLastPushedTaskIdsRef: import("react").RefObject<Set<string>>;
     workspaceDeletedTaskIdsRef: import("react").RefObject<Set<string>>;
+    workspaceDeletedTaskWatermarksRef: import("react").RefObject<Map<string, string>>;
     workspacePullCursorRef: import("react").RefObject<string | null>;
     clearWorkspaceRetry: () => void;
     scheduleWorkspaceRetry: (invokeSync: () => Promise<boolean>, options?: {
         minDelayMs?: number;
     }) => void;
     persistWorkspaceSyncPatch: (patch: Partial<WorkspaceSyncStateV2>) => Promise<WorkspaceSyncStateV2>;
+    applyWorkspaceSyncPatchLocally: (patch: Partial<WorkspaceSyncStateV2>) => WorkspaceSyncStateV2;
     loadWorkspaceSyncState: () => Promise<void>;
     applyWorkspaceSyncStateSnapshot: (nextState: Partial<WorkspaceSyncStateV2> & {
         enabled: boolean;

package/dist/hooks/useWorkspaceSyncController.js

@@ -2,6 +2,7 @@ import { useCallback, useEffect, useRef, useState } from 'react';
 import { calculateWorkspaceRetryDelayMs } from '../sync/syncService';
 import { normalizeWorkspaceSyncStateCompat } from '../compat/workspaceSyncCompat';
 import { createDefaultWorkspaceSyncState } from '../sync/workspaceSyncState';
+import { persistRemoteUiState } from './workspace/workspaceLocalState';
 const WORKSPACE_SYNC_LEASE_KEY_PREFIX = 'taskforce.sync.lease.v1';
 const WORKSPACE_SYNC_LEASE_CHANNEL = 'taskforce.sync.lease.v1';
 const WORKSPACE_SYNC_LEASE_HEARTBEAT_MS = 2500;
@@ -58,6 +59,7 @@ function buildWorkspaceSyncStatePatch(current, patch) {
         ...patch,
         version: 2,
         phase: patch.phase || current.phase,
+        setupIntent: patch.setupIntent === undefined ? (current.setupIntent ?? null) : (patch.setupIntent ?? null),
         pullCursor: patch.pullCursor === undefined ? current.pullCursor : normalizeCursor(patch.pullCursor),
         lastPullAt: patch.lastPullAt === undefined ? current.lastPullAt : normalizeCursor(patch.lastPullAt),
         lastPushAt: patch.lastPushAt === undefined ? current.lastPushAt : normalizeCursor(patch.lastPushAt),
@@ -66,12 +68,13 @@ function buildWorkspaceSyncStatePatch(current, patch) {
     };
     if (!next.enabled) {
         next.phase = 'idle';
+        next.setupIntent = null;
         next.pullCursor = null;
     }
     return next;
 }
 export function useWorkspaceSyncController(input) {
-    const { currentWorkspaceId, setWorkspaceCloudSyncEnabled, setWorkspaceSyncPhase, setWorkspaceLastPullAt, setWorkspaceLastPushAt, setWorkspaceLastErrorMessage } = input;
+    const { currentWorkspaceId, setWorkspaceCloudSyncEnabled, setWorkspaceSyncPhase, setWorkspaceSyncSetupIntent, setWorkspaceLastPullAt, setWorkspaceLastPushAt, setWorkspaceLastErrorMessage } = input;
     const [workspaceRetryAt, setWorkspaceRetryAt] = useState(null);
     const workspaceRetryTimerRef = useRef(null);
     const workspaceRetryAtMsRef = useRef(null);
@@ -85,6 +88,7 @@ export function useWorkspaceSyncController(input) {
     const workspacePendingSignatureRef = useRef('');
     const workspaceLastPushedTaskIdsRef = useRef(new Set());
     const workspaceDeletedTaskIdsRef = useRef(new Set());
+    const workspaceDeletedTaskWatermarksRef = useRef(new Map());
     const workspacePullCursorRef = useRef(null);
     const workspaceSyncStateRef = useRef(createDefaultWorkspaceSyncState());
     const workspaceSyncLeaseOwnerIdRef = useRef('');
@@ -254,6 +258,7 @@ export function useWorkspaceSyncController(input) {
         const next = buildWorkspaceSyncStatePatch(current, {
             enabled: Boolean(nextState.enabled),
             phase: nextState.phase || current.phase,
+            setupIntent: nextState.setupIntent,
             pullCursor: nextState.pullCursor,
             lastPullAt: nextState.lastPullAt,
             lastPushAt: nextState.lastPushAt,
@@ -264,31 +269,43 @@ export function useWorkspaceSyncController(input) {
         workspacePullCursorRef.current = next.pullCursor;
         setWorkspaceCloudSyncEnabled(next.enabled);
         setWorkspaceSyncPhase(next.phase);
+        setWorkspaceSyncSetupIntent(next.setupIntent ?? null);
         setWorkspaceLastPullAt(next.lastPullAt);
         setWorkspaceLastPushAt(next.lastPushAt);
         setWorkspaceLastErrorMessage(next.lastErrorMessage ?? null);
     }, [
         setWorkspaceCloudSyncEnabled,
         setWorkspaceSyncPhase,
+        setWorkspaceSyncSetupIntent,
         setWorkspaceLastPullAt,
         setWorkspaceLastPushAt,
         setWorkspaceLastErrorMessage
     ]);
+    const applyWorkspaceSyncPatchLocally = useCallback((patch) => {
+        const next = buildWorkspaceSyncStatePatch(workspaceSyncStateRef.current, patch);
+        applyWorkspaceSyncStateSnapshot(next);
+        return next;
+    }, [applyWorkspaceSyncStateSnapshot]);
     const persistWorkspaceSyncPatch = useCallback(async (patch) => {
         const next = buildWorkspaceSyncStatePatch(workspaceSyncStateRef.current, patch);
         workspaceSyncStateRef.current = next;
         workspacePullCursorRef.current = next.pullCursor;
-        const res = await fetch('/api/taskforce/ui-state', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            credentials: 'include',
-            body: JSON.stringify({
-                workspaceId: currentWorkspaceId,
-                stateKey: 'workspace-sync',
-                patch: next
-            })
+        const result = await persistRemoteUiState({
+            workspaceId: currentWorkspaceId,
+            stateKey: 'workspace-sync',
+            patch: next,
+            throwOnError: true,
+            respectFailureCooldown: false
         });
-        const payload = await res.json().catch(() => ({}));
+        const res = result.response;
+        const payload = result.payload;
+        if (result.skipped) {
+            applyWorkspaceSyncStateSnapshot(next);
+            return next;
+        }
+        if (!res) {
+            throw new Error('Failed to persist workspace sync state (missing response)');
+        }
         if (!res.ok || payload?.success === false) {
             throw new Error(payload?.error || `Failed to persist workspace sync state (${res.status})`);
         }
@@ -332,6 +349,7 @@ export function useWorkspaceSyncController(input) {
                 await persistWorkspaceSyncPatch({
                     enabled: false,
                     phase: 'idle',
+                    setupIntent: null,
                     pullCursor: null
                 });
                 return { success: true };
@@ -349,6 +367,7 @@ export function useWorkspaceSyncController(input) {
             await persistWorkspaceSyncPatch({
                 enabled: true,
                 phase: ensured.provisioned ? 'provision-local' : 'attach-cloud',
+                setupIntent: null,
                 pullCursor: null,
                 lastPullAt: null,
                 lastPushAt: null,
@@ -365,6 +384,7 @@ export function useWorkspaceSyncController(input) {
         workspacePendingSignatureRef.current = '';
         workspaceLastPushedTaskIdsRef.current = new Set();
         workspaceDeletedTaskIdsRef.current = new Set();
+        workspaceDeletedTaskWatermarksRef.current = new Map();
         workspacePullCursorRef.current = null;
         workspaceSyncStateRef.current = createDefaultWorkspaceSyncState();
         workspacePushInFlightRef.current = false;
@@ -402,10 +422,12 @@ export function useWorkspaceSyncController(input) {
         workspacePendingSignatureRef,
         workspaceLastPushedTaskIdsRef,
         workspaceDeletedTaskIdsRef,
+        workspaceDeletedTaskWatermarksRef,
         workspacePullCursorRef,
         clearWorkspaceRetry,
         scheduleWorkspaceRetry,
         persistWorkspaceSyncPatch,
+        applyWorkspaceSyncPatchLocally,
         loadWorkspaceSyncState,
         applyWorkspaceSyncStateSnapshot,
         saveWorkspaceCloudSyncSettings,

package/dist/hooks/useWorkspaceSyncController.test.js

@@ -5,6 +5,7 @@ const makeInput = (overrides = {}) => ({
     currentWorkspaceId: 'ws-test',
     setWorkspaceCloudSyncEnabled: vi.fn(),
     setWorkspaceSyncPhase: vi.fn(),
+    setWorkspaceSyncSetupIntent: vi.fn(),
     setWorkspaceLastPullAt: vi.fn(),
     setWorkspaceLastPushAt: vi.fn(),
     setWorkspaceLastErrorMessage: vi.fn(),

package/dist/hooks/workspace/useTaskforceApiRouting.test.js

@@ -57,4 +57,21 @@ describe('useTaskforceApiRouting', () => {
         expect(headers.get('x-taskforce-workspace-id')).toBe('workspace-2');
         expect(headers.get('x-taskforce-workspace-authoritative')).toBe('1');
     });
+    it('stops injecting the workspace header when the live ref resets to default', async () => {
+        const fetchMock = vi.fn(async (_input, init) => new Response(null, { status: 204 }));
+        vi.stubGlobal('fetch', fetchMock);
+        const currentWorkspaceIdRef = createRef();
+        currentWorkspaceIdRef.current = 'workspace-1';
+        renderHook(() => useTaskforceApiRouting({
+            currentWorkspaceIdRef,
+            runtimeMode: 'cloud',
+            resolveApiUrl: (path) => `https://cloud.example.com${path}`
+        }));
+        currentWorkspaceIdRef.current = 'default';
+        await window.fetch('/api/taskforce/tasks');
+        const [, init] = fetchMock.mock.calls.at(-1);
+        const headers = init.headers;
+        expect(headers.get('x-taskforce-workspace-id')).toBeNull();
+        expect(headers.get('x-taskforce-workspace-authoritative')).toBeNull();
+    });
 });

package/dist/hooks/workspace/useTaskforceWorkspaceBootstrap.d.ts

@@ -0,0 +1,166 @@
+import { type MutableRefObject } from 'react';
+import type { TaskAssigneeOption } from '../../utils/assignees';
+export type BootstrapPhase = 'idle' | 'auth' | 'workspace' | 'config' | 'ready' | 'stalled';
+export type WorkspaceRole = 'owner' | 'admin' | 'member' | 'read-only';
+export interface WorkspaceSummary {
+    id: string;
+    name: string;
+    role: WorkspaceRole;
+    slug?: string | null;
+    description?: string | null;
+    status?: string;
+    betaAccess?: boolean;
+}
+interface UseTaskforceWorkspaceBootstrapArgs {
+    shouldDeferProtectedApiCalls: boolean;
+    shouldBlockProtectedApiCalls: boolean;
+    getWorkspaceRequestState: () => {
+        workspaceId: string;
+        epoch: number;
+    };
+    isWorkspaceRequestStale: (requestState: {
+        workspaceId: string;
+        epoch: number;
+    }) => boolean;
+    isWorkspaceEpochStale: (requestState: {
+        workspaceId: string;
+        epoch: number;
+    }) => boolean;
+    isAbortError: (error: unknown) => boolean;
+    isBootstrapTimeoutError: (error: unknown) => boolean;
+    fetchWithTimeout: (url: string, init?: RequestInit, timeoutMs?: number, options?: {
+        signal?: AbortSignal;
+    }) => Promise<Response>;
+    handleUnauthorized: () => void;
+    applyBootstrapConfig: (data: any) => void;
+    loadPersistedUiState: (workspaceIdOverride?: string) => Promise<void>;
+    fetchBuildInfo: () => Promise<void>;
+    markBootstrapPhase: (phase: Exclude<BootstrapPhase, 'stalled'>) => void;
+    markBootstrapStalled: (message: string) => void;
+    fetchWorkflows: () => Promise<void>;
+    fetchInitiativeTemplates: () => Promise<void>;
+    loadAvailableEnvironments: () => Promise<void>;
+    setReferenceDataLoaded: (value: boolean) => void;
+    setCustomCategories: (value: any[]) => void;
+    setCustomTypes: (value: any[]) => void;
+    setPriorities: (value: any[]) => void;
+    setTaxonomies: (value: any[]) => void;
+    setTaxonomyDisplayLabels: (value: any) => void;
+    setConfigLoaded: (value: boolean) => void;
+    hasLoadedUiStateRef: MutableRefObject<boolean>;
+    currentWorkspaceIdRef: MutableRefObject<string>;
+    referenceDataRequestRef: MutableRefObject<{
+        workspaceId: string;
+        promise: Promise<void>;
+    } | null>;
+    referenceDataAbortRef: MutableRefObject<AbortController | null>;
+    bootstrapConfigAbortRef: MutableRefObject<AbortController | null>;
+    workspaceListAbortRef: MutableRefObject<AbortController | null>;
+    assigneeOptionsAbortRef: MutableRefObject<AbortController | null>;
+    workspaceListHydratedRef: MutableRefObject<boolean>;
+    setAvailableWorkspaces: (value: any[]) => void;
+    runtimeMode: 'local' | 'cloud';
+    applyResolvedWorkspaceId: (workspaceId: string, options?: {
+        preserveNonDefaultDefault?: boolean;
+    }) => void;
+    workspaceSwitchingEnabled: boolean;
+    authSessionResolved: boolean;
+    isAuthenticated: boolean;
+    authUserId: string;
+    setHydratedWorkspaceRole: (value: WorkspaceRole | null) => void;
+    setAssigneeOptions: (value: TaskAssigneeOption[]) => void;
+    setAssigneeOptionsLoaded: (value: boolean) => void;
+    commitCurrentWorkspaceId: (workspaceId: string, options?: {
+        clearExplicitSelection?: boolean;
+    }) => void;
+    currentWorkspaceId: string;
+    workspaceSelectionScope: string;
+    abortWorkspaceScopedRequests: () => void;
+    setWorkspaceBootstrapPending: (value: boolean) => void;
+    checkAuthSession: (options?: {
+        force?: boolean;
+    }) => Promise<boolean>;
+    lastConfigRefreshKeyRef: MutableRefObject<string>;
+    lastAssigneeOptionsLoadKeyRef: MutableRefObject<string>;
+    lastWorkspaceSyncStateLoadKeyRef: MutableRefObject<string>;
+    lastTaskSurfaceLoadKeyRef: MutableRefObject<string>;
+    lastSettingsSurfaceLoadKeyRef: MutableRefObject<string>;
+    isOpen: boolean;
+    activeTab: string;
+    showArchive: boolean;
+    taskScope: string;
+    settingsSection: string | null;
+    fetchTasks: (isSilent?: boolean, options?: {
+        ignoreAuthGuard?: boolean;
+    }) => Promise<void>;
+    fetchArchive: (isSilent?: boolean, options?: {
+        ignoreAuthGuard?: boolean;
+    }) => Promise<void>;
+    fetchPlanningEntities: (options?: {
+        ignoreAuthGuard?: boolean;
+    }) => Promise<void>;
+    refreshTaskCollections: (options?: {
+        isSilent?: boolean;
+        ignoreAuthGuard?: boolean;
+    }) => Promise<void>;
+    loadWorkspaceSyncState: () => Promise<void>;
+    archiveBootstrapTimerRef: MutableRefObject<number | null>;
+    hasBootstrappedDataRef: MutableRefObject<boolean>;
+}
+export declare function useTaskforceWorkspaceBootstrap(args: UseTaskforceWorkspaceBootstrapArgs): {
+    fetchReferenceData: (options?: {
+        ignoreAuthGuard?: boolean;
+        force?: boolean;
+    }) => Promise<void>;
+    fetchBootstrapConfig: (options?: {
+        ignoreAuthGuard?: boolean;
+    }) => Promise<void>;
+    fetchConfig: (options?: {
+        ignoreAuthGuard?: boolean;
+    }) => Promise<void>;
+    fetchWorkspaces: () => Promise<{
+        success: boolean;
+        error?: string;
+        workspaces?: WorkspaceSummary[];
+    }>;
+    fetchAssigneeOptions: () => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    switchWorkspace: (workspaceId: string, options?: {
+        hydrate?: boolean;
+    }) => Promise<{
+        success: boolean;
+        error?: string;
+        code?: string;
+    }>;
+    resolveWorkspaceAfterAuth: (options?: {
+        preferredWorkspaceId?: string | null;
+    }) => Promise<{
+        success: boolean;
+        workspaceSetupRequired: boolean;
+        workspaceId: string;
+        error?: undefined;
+        code?: undefined;
+    } | {
+        success: boolean;
+        workspaceSetupRequired: boolean;
+        error: string;
+        workspaceId?: undefined;
+        code?: undefined;
+    } | {
+        success: boolean;
+        workspaceSetupRequired: boolean;
+        workspaceId?: undefined;
+        error?: undefined;
+        code?: undefined;
+    } | {
+        success: boolean;
+        workspaceSetupRequired: boolean;
+        error: string;
+        code: string | undefined;
+        workspaceId?: undefined;
+    }>;
+    retryBootstrapChecks: () => Promise<void>;
+};
+export {};