@taskforcehq/taskforce 0.3.305 → 0.3.306

package/dist/hooks/useTaskforce.runtime-routing.test.d.ts

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

package/dist/hooks/useTaskforce.runtime-routing.test.js

@@ -0,0 +1,152 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { MemoryRouter } from 'react-router-dom';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+vi.mock('../config/clientDeployment', () => ({
+    resolveClientDeploymentConfig: () => ({
+        runtimeMode: 'local',
+        cloudEnvironment: 'performance',
+        cloudBaseUrl: 'https://performance-app.taskforcehq.ai',
+        cloudMcpBaseUrl: 'https://performance-mcp.taskforcehq.ai',
+        baseUrl: 'https://performance-app.taskforcehq.ai',
+        apiBaseUrl: 'https://performance-app.taskforcehq.ai',
+        cloudAuthBaseUrl: 'https://performance-app.taskforcehq.ai',
+        wsBaseUrl: 'https://performance-app.taskforcehq.ai',
+        cloudAuthViaLocalProxy: false,
+        warnings: []
+    })
+}));
+import { useTaskforce } from './useTaskforce';
+function jsonResponse(body, status = 200) {
+    return Promise.resolve({
+        ok: status >= 200 && status < 300,
+        status,
+        json: () => Promise.resolve(body)
+    });
+}
+function requestUrl(input) {
+    if (typeof input === 'string')
+        return input;
+    if (input instanceof URL)
+        return input.toString();
+    if (typeof Request !== 'undefined' && input instanceof Request)
+        return input.url;
+    return String(input);
+}
+const wrapper = ({ children }) => (_jsx(MemoryRouter, { children: children }));
+describe('useTaskforce runtime API routing', () => {
+    afterEach(() => {
+        vi.unstubAllGlobals();
+        vi.clearAllMocks();
+    });
+    it('lets runtime-config same-origin API hints override compiled remote API bases', async () => {
+        const requestedUrls = [];
+        vi.stubGlobal('fetch', vi.fn((input) => {
+            const url = requestUrl(input);
+            requestedUrls.push(url);
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({
+                    config: {
+                        runtimeMode: 'cloud',
+                        workspaceMode: 'multi-cloud',
+                        authSource: 'cloud',
+                        workspaceSwitchingEnabled: true,
+                        baseUrl: 'http://127.0.0.1:54465',
+                        apiBaseUrl: 'http://127.0.0.1:54465',
+                        cloudAuthBaseUrl: 'https://performance-app.taskforcehq.ai',
+                        wsBaseUrl: 'http://127.0.0.1:54465'
+                    }
+                });
+            }
+            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/workspaces')) {
+                return jsonResponse({
+                    success: true,
+                    currentWorkspaceId: 'workspace-cloud-1',
+                    workspaces: [{ id: 'workspace-cloud-1', name: 'Cloud Workspace', role: 'owner' }]
+                });
+            }
+            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: '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/taxonomy-state')) {
+                return jsonResponse({
+                    categories: [{ value: 'general', label: 'General' }],
+                    types: [{ value: 'feature', label: 'Feature' }],
+                    priorities: [{ value: 2, label: 'Medium' }],
+                    taxonomies: []
+                });
+            }
+            if (url.includes('/api/taskforce/workflow-templates'))
+                return jsonResponse({ workflows: [] });
+            if (url.includes('/api/taskforce/initiative-templates'))
+                return jsonResponse({ templates: [] });
+            if (url.includes('/api/taskforce/environments'))
+                return jsonResponse({ environments: [] });
+            if (url.includes('/api/taskforce/workspace/assignee-options'))
+                return jsonResponse({ assignees: [] });
+            if (url.includes('/api/taskforce/auth/workspace-members'))
+                return jsonResponse({ users: [] });
+            if (url.includes('/api/taskforce/planning/bootstrap')) {
+                return jsonResponse({ initiatives: [], workstreams: [], workstreamTaskSummaries: [] });
+            }
+            if (url.includes('/api/taskforce/tasks'))
+                return jsonResponse({ tasks: [] });
+            if (url.includes('/api/taskforce/archive'))
+                return jsonResponse({ archived: [] });
+            if (url.includes('/api/taskforce/data-version'))
+                return jsonResponse({ dataVersion: 1 });
+            if (url.includes('/api/taskforce/build-info'))
+                return jsonResponse({});
+            if (url.includes('/api/taskforce/global-settings'))
+                return jsonResponse({});
+            return jsonResponse({});
+        }));
+        const { result } = renderHook(() => useTaskforce({
+            config: {
+                cloudAuthBaseUrl: 'https://performance-app.taskforcehq.ai'
+            }
+        }), { wrapper });
+        await waitFor(() => {
+            expect(result.current.runtimeMode).toBe('cloud');
+            expect(result.current.bootstrapState.ready).toBe(true);
+        }, { timeout: 2500 });
+        expect(requestedUrls.some((url) => url.startsWith('https://performance-app.taskforcehq.ai'))).toBe(false);
+        requestedUrls.length = 0;
+        await act(async () => {
+            await result.current.fetchTasks(true);
+            await result.current.fetchPlanningEntities();
+        });
+        const taskforceReads = requestedUrls.filter((url) => url.includes('/api/taskforce/tasks') || url.includes('/api/taskforce/planning/bootstrap'));
+        expect(taskforceReads).toEqual(expect.arrayContaining([
+            'http://127.0.0.1:54465/api/taskforce/tasks',
+            'http://127.0.0.1:54465/api/taskforce/planning/bootstrap'
+        ]));
+        expect(taskforceReads.some((url) => url.startsWith('https://performance-app.taskforcehq.ai'))).toBe(false);
+    });
+});