@taskforcehq/taskforce 0.3.303 → 0.3.304

package/dist/hooks/useWorkspaceSyncController.d.ts

@@ -36,6 +36,7 @@ export declare function useWorkspaceSyncController(input: UseWorkspaceSyncContro
         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;
@@ -274,21 +275,31 @@ export function useWorkspaceSyncController(input) {
         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})`);
         }
@@ -406,6 +417,7 @@ export function useWorkspaceSyncController(input) {
         clearWorkspaceRetry,
         scheduleWorkspaceRetry,
         persistWorkspaceSyncPatch,
+        applyWorkspaceSyncPatchLocally,
         loadWorkspaceSyncState,
         applyWorkspaceSyncStateSnapshot,
         saveWorkspaceCloudSyncSettings,

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 {};