@taskforcehq/taskforce 0.3.168

package/dist/TaskforceCore.js

@@ -0,0 +1,729 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { MemoryRouter, useInRouterContext, useLocation, useNavigate } from 'react-router-dom';
+import { useTaskforce } from './hooks/useTaskforce';
+import { WidgetView } from './components/views/WidgetView';
+import { StandaloneLayout } from './components/views/StandaloneLayout';
+import styles from './Taskforce.module.css';
+import { t } from './localization';
+import { resolveWorkspaceLifecycleState } from './utils/workspaceLifecycle';
+import logo from './assets/branding/logos/logo_white_01.png';
+import taskforceBg from './assets/images/taskforce.png';
+function TaskforceCoreWithRouter({ config = {}, initialTaskId, onTaskCountChange, onHeaderMouseDown, isDragging, onClose, mode = 'standalone' }) {
+    const location = useLocation();
+    const navigate = useNavigate();
+    const [loginEmail, setLoginEmail] = useState('');
+    const [loginPassword, setLoginPassword] = useState('');
+    const [authMode, setAuthMode] = useState('login');
+    const [verificationToken, setVerificationToken] = useState('');
+    const [resetToken, setResetToken] = useState('');
+    const [inviteToken, setInviteToken] = useState('');
+    const [inviteEmail, setInviteEmail] = useState(null);
+    const [inviteWorkspaceId, setInviteWorkspaceId] = useState(null);
+    const [loginNotice, setLoginNotice] = useState(null);
+    const [loginError, setLoginError] = useState(null);
+    const [loginErrorCode, setLoginErrorCode] = useState(null);
+    const [loginBusy, setLoginBusy] = useState(false);
+    const [verifyCooldownUntil, setVerifyCooldownUntil] = useState(0);
+    const [resetCooldownUntil, setResetCooldownUntil] = useState(0);
+    const [cooldownNow, setCooldownNow] = useState(() => Date.now());
+    const [setupModeChoice, setSetupModeChoice] = useState('core');
+    const [setupBusy, setSetupBusy] = useState(false);
+    const [setupError, setSetupError] = useState(null);
+    const [setupNotice, setSetupNotice] = useState(null);
+    const [workspaceNameInput, setWorkspaceNameInput] = useState('');
+    const [workspaceDescriptionInput, setWorkspaceDescriptionInput] = useState('');
+    const [workspaceSetupSource, setWorkspaceSetupSource] = useState('local');
+    const [cloudWorkspaceOptions, setCloudWorkspaceOptions] = useState([]);
+    const [cloudWorkspaceSelection, setCloudWorkspaceSelection] = useState('');
+    const [cloudWorkspaceLoading, setCloudWorkspaceLoading] = useState(false);
+    const [cloudWorkspaceError, setCloudWorkspaceError] = useState(null);
+    const [syncNewLocalWorkspaceToCloud, setSyncNewLocalWorkspaceToCloud] = useState(false);
+    const [bootstrapRetryBusy, setBootstrapRetryBusy] = useState(false);
+    // Initialize the hook
+    const taskforceState = useTaskforce({
+        config,
+        initialTaskId,
+        onTaskCountChange,
+        onClose
+    });
+    const { runtimeMode, workspaceSwitchingEnabled, currentWorkspaceId, configLoaded, cloudAuthConfigured, authRequiredForApi, authBlocked, isAuthenticated, hasBetaAccess, authSessionResolved, workspaceBootstrapPending, bootstrapPhase, bootstrapError, setupState, runtimeCapabilities, refreshSetupContext, retryBootstrapChecks, saveWorkspaceProfile, fetchWorkspaces, applyWorkspaceSyncStateSnapshot, loginWithCredentials, registerWithCredentials, requestEmailVerification, confirmEmailVerification, requestPasswordReset, confirmPasswordReset, inspectInviteAcceptance, acceptInviteWithToken, currentTheme, logout } = taskforceState;
+    const normalizedCloudAuthBase = useMemo(() => {
+        const raw = String(config.cloudAuthBaseUrl || config.apiBaseUrl || '').trim();
+        if (!raw)
+            return '';
+        return raw.replace(/\/+$/, '');
+    }, [config.apiBaseUrl, config.cloudAuthBaseUrl]);
+    const isCloudRuntime = runtimeMode === 'cloud' || runtimeCapabilities?.runtimeMode === 'cloud';
+    const canUseCloudWorkspaceSetup = !isCloudRuntime && cloudAuthConfigured && Boolean(normalizedCloudAuthBase);
+    const isLikelyCloudAppHost = typeof window !== 'undefined' && /^app\./i.test(window.location.hostname);
+    const isCloudAuthRequired = runtimeMode === 'cloud' && authRequiredForApi;
+    const shouldForceForAuthBlocked = runtimeMode === 'cloud' && authBlocked;
+    const shouldForceLogin = isLikelyCloudAppHost
+        ? (!isAuthenticated || authBlocked)
+        : ((isCloudAuthRequired && !isAuthenticated) || shouldForceForAuthBlocked);
+    const shouldForceComingSoon = runtimeMode === 'cloud' && isAuthenticated && !hasBetaAccess;
+    const isLoginRoute = location.pathname === '/login';
+    const isSetupRoute = location.pathname === '/setup';
+    const isComingSoonRoute = location.pathname === '/coming-soon';
+    const setupStep = useMemo(() => String(new URLSearchParams(location.search).get('step') || '').trim().toLowerCase(), [location.search]);
+    const shouldHoldForAuthBootstrap = mode !== 'widget'
+        && !authSessionResolved
+        && !isLoginRoute
+        && !isSetupRoute
+        && (runtimeMode === 'cloud' || isLikelyCloudAppHost);
+    const workspaceLifecycle = useMemo(() => resolveWorkspaceLifecycleState({
+        setupState: setupState
+            ? {
+                globalSetupState: setupState.globalSetupState,
+                workspaceSetupState: setupState.workspaceSetupState,
+                runtimeMode: setupState.runtimeMode,
+                workspaceId: setupState.workspaceId,
+                mode: setupState.mode,
+                forceSetup: setupState.forceSetup,
+                forceGlobalSetup: setupState.forceGlobalSetup,
+                forceWorkspaceSetup: setupState.forceWorkspaceSetup
+            }
+            : null,
+        runtimeMode,
+        isAuthenticated
+    }), [setupState, runtimeMode, isAuthenticated]);
+    const setupGateActive = workspaceLifecycle.setupGateActive;
+    const needsGlobalSetup = workspaceLifecycle.needsGlobalSetup;
+    const needsWorkspaceSetup = workspaceLifecycle.needsWorkspaceSetup;
+    const hasSetupReadError = workspaceLifecycle.hasSetupReadError;
+    const shouldHoldForSetupBootstrap = mode !== 'widget'
+        && authSessionResolved
+        && !shouldForceLogin
+        && !shouldForceComingSoon
+        && (!configLoaded || workspaceBootstrapPending || bootstrapPhase === 'stalled')
+        && (isSetupRoute || runtimeMode === 'cloud' || isLikelyCloudAppHost);
+    const bootstrapSubtitle = useMemo(() => {
+        if (bootstrapPhase === 'auth')
+            return 'Verifying session...';
+        if (bootstrapPhase === 'workspace')
+            return 'Resolving workspace access...';
+        if (bootstrapPhase === 'config')
+            return 'Loading configuration...';
+        return 'Checking account, workspace access, and setup status...';
+    }, [bootstrapPhase]);
+    const isPlaceholderWorkspaceName = useCallback((name, workspaceId, _description) => {
+        const normalizedName = String(name || '').trim().toLowerCase();
+        const normalizedWorkspaceId = String(workspaceId || '').trim().toLowerCase();
+        if (!normalizedName)
+            return true;
+        if (normalizedName === 'system default workspace')
+            return true;
+        if (normalizedWorkspaceId && normalizedName === normalizedWorkspaceId)
+            return true;
+        return false;
+    }, []);
+    useEffect(() => {
+        const modeValue = setupState?.mode === 'operations' ? 'operations' : 'core';
+        setSetupModeChoice(modeValue);
+    }, [setupState?.mode]);
+    useEffect(() => {
+        if (!setupState)
+            return;
+        const currentName = String(setupState.workspace?.name || '').trim();
+        const suggested = String(setupState.suggestedWorkspaceName || '').trim();
+        const preferredName = isPlaceholderWorkspaceName(currentName, setupState.workspaceId, setupState.workspace?.description)
+            ? suggested
+            : currentName;
+        setWorkspaceNameInput(preferredName || suggested || currentName);
+        setWorkspaceDescriptionInput(String(setupState.workspace?.description || ''));
+    }, [
+        setupState?.workspace?.name,
+        setupState?.workspace?.description,
+        setupState?.suggestedWorkspaceName,
+        setupState?.workspaceId,
+        isPlaceholderWorkspaceName
+    ]);
+    useEffect(() => {
+        if (!isSetupRoute || setupStep !== 'workspace')
+            return;
+        const source = String(new URLSearchParams(location.search).get('source') || '').trim().toLowerCase();
+        if (source === 'cloud' && canUseCloudWorkspaceSetup) {
+            setWorkspaceSetupSource('cloud');
+            setSyncNewLocalWorkspaceToCloud(false);
+            return;
+        }
+        setWorkspaceSetupSource('local');
+    }, [canUseCloudWorkspaceSetup, isSetupRoute, location.search, setupStep]);
+    const fetchCloudWorkspaceOptions = useCallback(async () => {
+        if (!canUseCloudWorkspaceSetup || !isAuthenticated) {
+            setCloudWorkspaceOptions([]);
+            setCloudWorkspaceSelection('');
+            return;
+        }
+        setCloudWorkspaceLoading(true);
+        setCloudWorkspaceError(null);
+        try {
+            const res = await fetch(`${normalizedCloudAuthBase}/api/taskforce/workspaces`, {
+                method: 'GET',
+                credentials: 'include'
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok || data?.success === false) {
+                setCloudWorkspaceOptions([]);
+                setCloudWorkspaceSelection('');
+                setCloudWorkspaceError(data?.error || `Failed to load cloud projects (${res.status})`);
+                return;
+            }
+            const cloudWorkspaces = Array.isArray(data?.workspaces)
+                ? data.workspaces
+                    .map((workspace) => ({
+                    id: String(workspace?.id || '').trim(),
+                    name: String(workspace?.name || workspace?.id || '').trim(),
+                    description: typeof workspace?.description === 'string' ? workspace.description : null
+                }))
+                    .filter((workspace) => workspace.id.length > 0)
+                : [];
+            setCloudWorkspaceOptions(cloudWorkspaces);
+            setCloudWorkspaceSelection((prev) => {
+                if (prev && cloudWorkspaces.some((workspace) => workspace.id === prev))
+                    return prev;
+                return cloudWorkspaces[0]?.id || '';
+            });
+        }
+        catch {
+            setCloudWorkspaceOptions([]);
+            setCloudWorkspaceSelection('');
+            setCloudWorkspaceError('Failed to load cloud projects.');
+        }
+        finally {
+            setCloudWorkspaceLoading(false);
+        }
+    }, [canUseCloudWorkspaceSetup, isAuthenticated, normalizedCloudAuthBase]);
+    useEffect(() => {
+        if (workspaceSetupSource !== 'cloud')
+            return;
+        void fetchCloudWorkspaceOptions();
+    }, [fetchCloudWorkspaceOptions, workspaceSetupSource]);
+    const nextPath = useMemo(() => {
+        const raw = new URLSearchParams(location.search).get('next') || '/';
+        if (!raw.startsWith('/'))
+            return '/';
+        if (raw === '/login')
+            return '/';
+        return raw;
+    }, [location.search]);
+    const loginRouteMode = useMemo(() => {
+        const modeRaw = String(new URLSearchParams(location.search).get('mode') || '').trim().toLowerCase();
+        if (modeRaw === 'register' || modeRaw === 'verify' || modeRaw === 'forgot' || modeRaw === 'reset' || modeRaw === 'invite') {
+            return modeRaw;
+        }
+        return 'login';
+    }, [location.search]);
+    const loginRouteToken = useMemo(() => String(new URLSearchParams(location.search).get('token') || '').trim(), [location.search]);
+    const setLoginMode = useCallback((mode) => {
+        const params = new URLSearchParams(location.search);
+        if (mode === 'login') {
+            params.delete('mode');
+        }
+        else {
+            params.set('mode', mode);
+        }
+        const query = params.toString();
+        navigate(`/login${query ? `?${query}` : ''}`, { replace: true });
+    }, [location.search, navigate]);
+    const routeToWorkspaceSetupIfNeeded = useCallback(async (hintWorkspaceSetupRequired) => {
+        if (!workspaceSwitchingEnabled)
+            return false;
+        const workspacesResult = await fetchWorkspaces();
+        if (workspacesResult.success) {
+            const workspaceCount = Array.isArray(workspacesResult.workspaces)
+                ? workspacesResult.workspaces.length
+                : 0;
+            if (workspaceCount === 0) {
+                navigate('/setup?step=workspace', { replace: true });
+                return true;
+            }
+            return false;
+        }
+        if (hintWorkspaceSetupRequired) {
+            navigate('/setup?step=workspace', { replace: true });
+            return true;
+        }
+        return false;
+    }, [fetchWorkspaces, navigate, workspaceSwitchingEnabled]);
+    useEffect(() => {
+        if (!isLoginRoute)
+            return;
+        setAuthMode(loginRouteMode);
+        if (loginRouteMode === 'verify' && loginRouteToken)
+            setVerificationToken(loginRouteToken);
+        if (loginRouteMode === 'reset' && loginRouteToken)
+            setResetToken(loginRouteToken);
+        if (loginRouteMode === 'invite' && loginRouteToken)
+            setInviteToken(loginRouteToken);
+    }, [isLoginRoute, loginRouteMode, loginRouteToken]);
+    useEffect(() => {
+        if (!isLoginRoute || authMode !== 'invite' || !inviteToken.trim())
+            return;
+        let active = true;
+        (async () => {
+            const inspected = await inspectInviteAcceptance(inviteToken);
+            if (!active)
+                return;
+            if (inspected.success) {
+                setInviteEmail(inspected.email || null);
+                setInviteWorkspaceId(inspected.workspaceId || null);
+                setLoginNotice('Invite ready. Set your password to join.');
+                setLoginError(null);
+                setLoginErrorCode(null);
+            }
+            else {
+                setInviteEmail(null);
+                setInviteWorkspaceId(null);
+                setLoginError(formatAuthError(inspected));
+                setLoginErrorCode(inspected.code || inspected.state || null);
+            }
+        })();
+        return () => { active = false; };
+    }, [isLoginRoute, authMode, inviteToken, inspectInviteAcceptance]);
+    useEffect(() => {
+        const hasCooldown = verifyCooldownUntil > Date.now() || resetCooldownUntil > Date.now();
+        if (!hasCooldown)
+            return;
+        const id = window.setInterval(() => setCooldownNow(Date.now()), 1000);
+        return () => window.clearInterval(id);
+    }, [verifyCooldownUntil, resetCooldownUntil]);
+    const verifyCooldownSeconds = Math.max(0, Math.ceil((verifyCooldownUntil - cooldownNow) / 1000));
+    const resetCooldownSeconds = Math.max(0, Math.ceil((resetCooldownUntil - cooldownNow) / 1000));
+    const verifyCooldownActive = verifyCooldownSeconds > 0;
+    const resetCooldownActive = resetCooldownSeconds > 0;
+    const formatAuthError = (result) => {
+        const message = result.error || 'Request failed.';
+        const code = result.code || result.state;
+        return code ? `[${code}] ${message}` : message;
+    };
+    useEffect(() => {
+        if (mode === 'widget')
+            return;
+        if (workspaceBootstrapPending)
+            return;
+        if (shouldForceComingSoon) {
+            if (!isComingSoonRoute)
+                navigate('/coming-soon', { replace: true });
+            return;
+        }
+        if (isComingSoonRoute && !shouldForceComingSoon) {
+            navigate('/', { replace: true });
+            return;
+        }
+        if (!shouldForceLogin) {
+            if (isLoginRoute && isAuthenticated)
+                navigate(nextPath, { replace: true });
+        }
+        else {
+            if (!isLoginRoute) {
+                const target = `${location.pathname}${location.search}${location.hash}`;
+                navigate(`/login?next=${encodeURIComponent(target || '/')}`, { replace: true });
+                return;
+            }
+            return;
+        }
+        if (setupGateActive) {
+            if (hasSetupReadError) {
+                if (!isSetupRoute || setupStep !== 'error') {
+                    navigate('/setup?step=error', { replace: true });
+                }
+                return;
+            }
+            if (needsGlobalSetup) {
+                if (!isSetupRoute || setupStep !== 'global') {
+                    navigate('/setup?step=global', { replace: true });
+                }
+                return;
+            }
+            if (needsWorkspaceSetup) {
+                if (!isSetupRoute || setupStep !== 'workspace') {
+                    navigate('/setup?step=workspace', { replace: true });
+                }
+                return;
+            }
+            if (isSetupRoute) {
+                navigate('/', { replace: true });
+            }
+            return;
+        }
+        if (isSetupRoute && setupState) {
+            navigate('/', { replace: true });
+        }
+    }, [
+        mode,
+        shouldForceLogin,
+        shouldForceComingSoon,
+        isLoginRoute,
+        isSetupRoute,
+        isComingSoonRoute,
+        setupGateActive,
+        setupState,
+        hasSetupReadError,
+        needsGlobalSetup,
+        needsWorkspaceSetup,
+        setupStep,
+        workspaceBootstrapPending,
+        location.pathname,
+        location.search,
+        location.hash,
+        navigate,
+        nextPath
+    ]);
+    useEffect(() => {
+        if (mode === 'widget')
+            return;
+        if (runtimeMode !== 'local')
+            return;
+        if (!configLoaded)
+            return;
+        if (isLoginRoute || isSetupRoute)
+            return;
+        const workspaceId = String(currentWorkspaceId || '').trim().toLowerCase();
+        if (!workspaceId || workspaceId === 'default') {
+            navigate('/setup?step=workspace', { replace: true });
+        }
+    }, [mode, runtimeMode, configLoaded, isLoginRoute, isSetupRoute, currentWorkspaceId, navigate]);
+    const handleRetryBootstrap = useCallback(async () => {
+        setBootstrapRetryBusy(true);
+        try {
+            await retryBootstrapChecks();
+        }
+        finally {
+            setBootstrapRetryBusy(false);
+        }
+    }, [retryBootstrapChecks]);
+    const handleGoToSignIn = useCallback(async () => {
+        await logout();
+        navigate('/login', { replace: true });
+    }, [logout, navigate]);
+    // Standalone-first: widget remains opt-in only.
+    if (mode === 'widget') {
+        return (_jsx(WidgetView, { ...taskforceState, onHeaderMouseDown: onHeaderMouseDown, isDragging: isDragging, onClose: onClose }));
+    }
+    if (shouldHoldForAuthBootstrap) {
+        return (_jsx("div", { className: styles.standaloneWrapper, "data-theme": currentTheme, children: _jsx("div", { className: styles.loginView, children: _jsxs("div", { className: styles.loginCard, children: [_jsxs("div", { className: styles.authBrandRow, children: [_jsx("img", { src: logo, alt: "Taskforce", className: styles.loginLogo }), _jsx("h1", { className: styles.loginTitle, children: "Loading Taskforce" })] }), _jsx("p", { className: styles.loginSubtitle, children: "Checking your session..." })] }) }) }));
+    }
+    if (shouldHoldForSetupBootstrap) {
+        return (_jsx("div", { className: styles.standaloneWrapper, "data-theme": currentTheme, children: _jsx("div", { className: styles.loginView, children: _jsxs("div", { className: styles.loginCard, children: [_jsxs("div", { className: styles.authBrandRow, children: [_jsx("img", { src: logo, alt: "Taskforce", className: styles.loginLogo }), _jsx("h1", { className: styles.loginTitle, children: "Loading Taskforce" })] }), _jsx("p", { className: styles.loginSubtitle, children: bootstrapSubtitle }), bootstrapPhase === 'stalled' && (_jsxs(_Fragment, { children: [_jsx("p", { className: styles.loginError, children: bootstrapError || 'Startup checks timed out.' }), _jsx("button", { className: styles.submitBtn, disabled: bootstrapRetryBusy, onClick: handleRetryBootstrap, children: bootstrapRetryBusy ? 'Retrying...' : 'Retry checks' }), isCloudRuntime && (_jsx("button", { className: styles.cancelBtn, disabled: bootstrapRetryBusy, onClick: handleGoToSignIn, children: "Go to sign-in" }))] }))] }) }) }));
+    }
+    if (isLoginRoute) {
+        return (_jsx("div", { className: styles.standaloneWrapper, "data-theme": currentTheme, children: _jsx("div", { className: styles.loginView, style: {
+                    backgroundImage: `linear-gradient(rgba(15, 15, 26, 0.88), rgba(15, 15, 26, 0.9)), url(${taskforceBg})`
+                }, children: _jsxs("div", { className: styles.loginCard, children: [!isCloudRuntime && !shouldForceLogin && (_jsx("button", { className: styles.loginCloseBtn, "aria-label": "Close sign in", onClick: () => navigate(nextPath, { replace: true }), children: "\u00D7" })), _jsxs("div", { className: styles.authBrandRow, children: [_jsx("img", { src: logo, alt: "Taskforce", className: styles.loginLogo }), _jsxs("h1", { className: styles.loginTitle, children: ["TASKFORCE ", _jsx("span", { className: styles.loginTitleAccent, children: "HQ" })] })] }), _jsxs("p", { className: styles.loginSubtitle, children: [authMode === 'login' && 'Sign in with your account credentials.', authMode === 'register' && 'Create your Taskforce account.', authMode === 'verify' && 'Enter your verification token.', authMode === 'forgot' && 'Request a password reset link.', authMode === 'reset' && 'Set a new password using your reset token.', authMode === 'invite' && 'Accept your invite and create a password.'] }), (authMode === 'login' || authMode === 'register' || authMode === 'forgot') && (_jsx("input", { className: styles.input, type: "email", value: loginEmail, placeholder: "Email", onChange: (event) => setLoginEmail(event.target.value) })), (authMode === 'login' || authMode === 'register' || authMode === 'reset') && (_jsx("input", { className: styles.input, type: "password", value: loginPassword, placeholder: authMode === 'reset' ? 'New password' : 'Password', onChange: (event) => setLoginPassword(event.target.value) })), authMode === 'verify' && (_jsx("input", { className: styles.input, type: "text", value: verificationToken, placeholder: "Verification token", onChange: (event) => setVerificationToken(event.target.value) })), authMode === 'reset' && (_jsx("input", { className: styles.input, type: "text", value: resetToken, placeholder: "Reset token", onChange: (event) => setResetToken(event.target.value) })), authMode === 'invite' && (_jsxs(_Fragment, { children: [_jsx("input", { className: styles.input, type: "text", value: inviteToken, placeholder: "Invite token", onChange: (event) => setInviteToken(event.target.value) }), inviteEmail && (_jsxs("p", { className: styles.loginSubtitle, children: ["Invite for: ", _jsx("strong", { children: inviteEmail }), inviteWorkspaceId ? ` · Workspace: ${inviteWorkspaceId}` : ''] }))] })), loginNotice && _jsx("p", { className: styles.loginSubtitle, children: loginNotice }), loginError && _jsx("p", { className: styles.loginError, children: loginError }), authMode === 'login' && loginErrorCode === 'EMAIL_NOT_VERIFIED' && loginEmail.trim() && (_jsx("button", { className: styles.authModeLink, disabled: loginBusy || verifyCooldownActive, onClick: async () => {
+                                setLoginBusy(true);
+                                setLoginNotice(null);
+                                const sent = await requestEmailVerification(loginEmail);
+                                if (sent.success) {
+                                    setVerifyCooldownUntil(Date.now() + 30_000);
+                                    setLoginMode('verify');
+                                    if (sent.verificationToken)
+                                        setVerificationToken(sent.verificationToken);
+                                    setLoginNotice('Verification email resent.');
+                                    setLoginError(null);
+                                    setLoginErrorCode(null);
+                                }
+                                else {
+                                    setLoginError(formatAuthError(sent));
+                                }
+                                setLoginBusy(false);
+                            }, children: verifyCooldownActive ? `Resend in ${verifyCooldownSeconds}s` : 'Resend Verification Email' })), _jsx("button", { className: styles.submitBtn, disabled: loginBusy || (authMode === 'verify' && verifyCooldownActive) || (authMode === 'forgot' && resetCooldownActive), onClick: async () => {
+                                setLoginBusy(true);
+                                setLoginNotice(null);
+                                setLoginError(null);
+                                setLoginErrorCode(null);
+                                let result = { success: false };
+                                if (authMode === 'login') {
+                                    result = await loginWithCredentials(loginEmail, loginPassword);
+                                }
+                                else if (authMode === 'register') {
+                                    result = await registerWithCredentials(loginEmail, loginPassword);
+                                }
+                                else if (authMode === 'verify') {
+                                    result = await confirmEmailVerification(verificationToken);
+                                }
+                                else if (authMode === 'forgot') {
+                                    result = await requestPasswordReset(loginEmail);
+                                }
+                                else if (authMode === 'reset') {
+                                    result = await confirmPasswordReset(resetToken, loginPassword);
+                                }
+                                else if (authMode === 'invite') {
+                                    result = await acceptInviteWithToken(inviteToken, loginPassword);
+                                }
+                                if (!result.success) {
+                                    setLoginError(formatAuthError(result));
+                                    setLoginErrorCode(result.code || null);
+                                    if (authMode === 'login' && (result.code === 'WORKSPACE_NOT_FOUND' || result.code === 'WORKSPACE_ID_REQUIRED')) {
+                                        navigate('/setup?step=workspace', { replace: true });
+                                        setLoginBusy(false);
+                                        return;
+                                    }
+                                    if (authMode === 'login' && result.code === 'EMAIL_NOT_VERIFIED' && loginEmail.trim()) {
+                                        const sent = await requestEmailVerification(loginEmail);
+                                        if (sent.success) {
+                                            setVerifyCooldownUntil(Date.now() + 30_000);
+                                            setLoginMode('verify');
+                                            if (sent.verificationToken)
+                                                setVerificationToken(sent.verificationToken);
+                                            setLoginNotice('Email not verified. A verification token was sent.');
+                                            setLoginError(null);
+                                            setLoginErrorCode(null);
+                                        }
+                                    }
+                                }
+                                else if (authMode === 'register') {
+                                    if (await routeToWorkspaceSetupIfNeeded(result.workspaceSetupRequired)) {
+                                        setLoginBusy(false);
+                                        return;
+                                    }
+                                    if (result.verificationToken)
+                                        setVerificationToken(result.verificationToken);
+                                    setVerifyCooldownUntil(Date.now() + 30_000);
+                                    setLoginMode('verify');
+                                    setLoginNotice(result.emailSent === false
+                                        ? `Account created, but verification email failed to send. ${result.emailError || 'Try Resend Verification again.'}`
+                                        : 'Account created. Check your email for verification instructions.');
+                                }
+                                else if (authMode === 'verify') {
+                                    setLoginMode('login');
+                                    setLoginNotice('Email verified. You can sign in now.');
+                                }
+                                else if (authMode === 'forgot') {
+                                    if (result.resetToken)
+                                        setResetToken(result.resetToken);
+                                    setResetCooldownUntil(Date.now() + 30_000);
+                                    setLoginMode('reset');
+                                    setLoginNotice(result.emailSent === false
+                                        ? `Password reset email failed to send. ${result.emailError || 'Try again in a minute.'}`
+                                        : 'Password reset instructions sent.');
+                                }
+                                else if (authMode === 'reset') {
+                                    setLoginMode('login');
+                                    setLoginNotice('Password updated. Sign in with your new password.');
+                                }
+                                else if (authMode === 'invite') {
+                                    if (result.workspaceSetupRequired) {
+                                        navigate('/setup?step=workspace', { replace: true });
+                                        setLoginBusy(false);
+                                        return;
+                                    }
+                                    navigate(nextPath, { replace: true });
+                                }
+                                else if (authMode === 'login') {
+                                    if (result.workspaceSetupRequired) {
+                                        navigate('/setup?step=workspace', { replace: true });
+                                        setLoginBusy(false);
+                                        return;
+                                    }
+                                    setLoginEmail('');
+                                    setLoginPassword('');
+                                    navigate(nextPath, { replace: true });
+                                }
+                                else {
+                                    setLoginEmail('');
+                                    setLoginPassword('');
+                                    navigate(nextPath, { replace: true });
+                                }
+                                setLoginBusy(false);
+                            }, children: loginBusy ? 'Working...' : (authMode === 'login' ? 'Sign In'
+                                : authMode === 'register' ? 'Create Account'
+                                    : authMode === 'verify'
+                                        ? (verifyCooldownActive ? `Resend in ${verifyCooldownSeconds}s` : 'Resend Verification')
+                                        : authMode === 'forgot'
+                                            ? (resetCooldownActive ? `Retry in ${resetCooldownSeconds}s` : 'Send Reset Link')
+                                            : authMode === 'reset'
+                                                ? 'Reset Password'
+                                                : 'Accept Invite') }), (authMode === 'login' || authMode === 'register') && (_jsxs("p", { className: styles.authModeSwitch, children: [authMode === 'login' ? 'Need an account?' : 'Already have an account?', ' ', _jsx("button", { className: styles.authModeSwitchLink, disabled: loginBusy, onClick: () => {
+                                        setLoginError(null);
+                                        setLoginErrorCode(null);
+                                        setLoginNotice(null);
+                                        setLoginMode(authMode === 'login' ? 'register' : 'login');
+                                    }, children: authMode === 'login' ? 'Register' : 'Sign In' })] })), _jsxs("div", { className: styles.authModeLinks, children: [(authMode === 'login' || authMode === 'register') && (_jsxs(_Fragment, { children: [_jsx("button", { className: styles.authModeLink, disabled: loginBusy || resetCooldownActive, onClick: () => { setLoginError(null); setLoginErrorCode(null); setLoginNotice(null); setLoginMode('forgot'); }, children: resetCooldownActive ? `Forgot Password (${resetCooldownSeconds}s)` : 'Forgot Password' }), _jsx("button", { className: styles.authModeLink, disabled: loginBusy || verifyCooldownActive, onClick: () => { setLoginError(null); setLoginErrorCode(null); setLoginNotice(null); setLoginMode('verify'); }, children: verifyCooldownActive ? `Resend Verification (${verifyCooldownSeconds}s)` : 'Resend Verification' }), _jsx("button", { className: styles.authModeLink, disabled: loginBusy, onClick: () => { setLoginError(null); setLoginErrorCode(null); setLoginNotice(null); setLoginMode('invite'); }, children: "Accept Invite" })] })), (authMode !== 'login' && authMode !== 'register') && (_jsxs(_Fragment, { children: [_jsx("button", { className: styles.authModeLink, disabled: loginBusy, onClick: () => { setLoginError(null); setLoginErrorCode(null); setLoginNotice(null); setLoginMode('login'); }, children: "Sign In" }), _jsx("button", { className: styles.authModeLink, disabled: loginBusy, onClick: () => { setLoginError(null); setLoginErrorCode(null); setLoginNotice(null); setLoginMode('register'); }, children: "Register" }), authMode === 'reset' && (_jsx("button", { className: styles.authModeLink, disabled: loginBusy || resetCooldownActive, onClick: () => { setLoginError(null); setLoginErrorCode(null); setLoginNotice(null); setLoginMode('forgot'); }, children: resetCooldownActive ? `Forgot Password (${resetCooldownSeconds}s)` : 'Forgot Password' }))] }))] })] }) }) }));
+    }
+    if (shouldForceLogin && !isLoginRoute) {
+        return (_jsx("div", { className: styles.standaloneWrapper, "data-theme": currentTheme, children: _jsx("div", { className: styles.loginView, children: _jsxs("div", { className: styles.loginCard, children: [_jsxs("div", { className: styles.authBrandRow, children: [_jsx("img", { src: logo, alt: "Taskforce", className: styles.loginLogo }), _jsx("h1", { className: styles.loginTitle, children: "Loading Taskforce" })] }), _jsx("p", { className: styles.loginSubtitle, children: "Redirecting to sign in..." })] }) }) }));
+    }
+    if (isComingSoonRoute && shouldForceComingSoon) {
+        return (_jsx("div", { className: styles.standaloneWrapper, "data-theme": currentTheme, children: _jsx("div", { className: styles.loginView, style: {
+                    backgroundImage: `linear-gradient(rgba(15, 15, 26, 0.88), rgba(15, 15, 26, 0.9)), url(${taskforceBg})`
+                }, children: _jsxs("div", { className: styles.loginCard, children: [_jsxs("div", { className: styles.authBrandRow, children: [_jsx("img", { src: logo, alt: "Taskforce", className: styles.loginLogo }), _jsx("h1", { className: styles.loginTitle, children: "Private Beta" })] }), _jsx("p", { className: styles.loginSubtitle, children: "You are signed in, but your account is not in the beta allowlist yet." }), _jsx("p", { className: styles.loginSubtitle, children: "You will see the full app as soon as beta access is enabled." }), _jsx("button", { className: styles.cancelBtn, onClick: async () => { await taskforceState.logout(); navigate('/login', { replace: true }); }, children: "Sign Out" })] }) }) }));
+    }
+    if (isSetupRoute && setupGateActive && (hasSetupReadError || needsGlobalSetup || needsWorkspaceSetup)) {
+        const isError = hasSetupReadError || setupStep === 'error';
+        const isGlobal = !isError && (needsGlobalSetup || setupStep === 'global');
+        const heading = isError
+            ? t('setup.headingCheckFailed')
+            : (isGlobal ? t('setup.headingGlobalRequired') : t('setup.headingWorkspaceRequired'));
+        const subtitle = isError
+            ? t('setup.subtitleUnreadable')
+            : isGlobal
+                ? t('setup.subtitleGlobalRequired')
+                : t('setup.subtitleWorkspaceRequired');
+        const workspaceLabel = setupModeChoice === 'operations'
+            ? t('setup.workspaceTermMission')
+            : t('setup.workspaceTermProject');
+        return (_jsx("div", { className: styles.standaloneWrapper, "data-theme": currentTheme, children: _jsx("div", { className: styles.loginView, style: {
+                    backgroundImage: `linear-gradient(rgba(15, 15, 26, 0.88), rgba(15, 15, 26, 0.9)), url(${taskforceBg})`
+                }, children: _jsxs("div", { className: styles.loginCard, children: [_jsxs("div", { className: styles.authBrandRow, children: [_jsx("img", { src: logo, alt: "Taskforce", className: styles.loginLogo }), _jsxs("h1", { className: styles.loginTitle, children: ["TASKFORCE ", _jsx("span", { className: styles.loginTitleAccent, children: "HQ" })] })] }), _jsx("p", { className: styles.loginSubtitle, children: _jsx("strong", { children: heading }) }), _jsx("p", { className: styles.loginSubtitle, children: subtitle }), runtimeCapabilities && (_jsxs("p", { className: styles.loginSubtitle, children: [t('setup.runtimeLabel'), ": ", _jsx("strong", { children: runtimeCapabilities.runtimeMode })] })), setupNotice && _jsx("p", { className: styles.loginSubtitle, children: setupNotice }), setupError && _jsx("p", { className: styles.loginError, children: setupError }), isGlobal && (_jsxs("div", { style: { display: 'grid', gap: 10, textAlign: 'left' }, children: [_jsxs("label", { className: styles.authModeLink, style: { display: 'flex', gap: 8, alignItems: 'center', cursor: 'pointer' }, children: [_jsx("input", { type: "radio", name: "setup-mode", value: "core", checked: setupModeChoice === 'core', onChange: () => setSetupModeChoice('core'), disabled: setupBusy }), _jsx("span", { children: t('setup.coreModeOption', { workspaceLabel }) })] }), _jsxs("label", { className: styles.authModeLink, style: { display: 'flex', gap: 8, alignItems: 'center', cursor: 'pointer' }, children: [_jsx("input", { type: "radio", name: "setup-mode", value: "operations", checked: setupModeChoice === 'operations', onChange: () => setSetupModeChoice('operations'), disabled: setupBusy }), _jsx("span", { children: t('setup.operationsModeOption') })] })] })), !isError && !isGlobal && (_jsxs("div", { style: { display: 'grid', gap: 10, textAlign: 'left' }, children: [!isCloudRuntime && canUseCloudWorkspaceSetup && (_jsxs("div", { style: { display: 'grid', gap: 8 }, children: [_jsxs("label", { className: styles.authModeLink, style: { display: 'flex', gap: 8, alignItems: 'center', cursor: 'pointer' }, children: [_jsx("input", { type: "radio", name: "workspace-setup-source", value: "local", checked: workspaceSetupSource === 'local', onChange: () => setWorkspaceSetupSource('local'), disabled: setupBusy }), _jsxs("span", { children: ["Create new local ", workspaceLabel.toLowerCase()] })] }), _jsxs("label", { className: styles.authModeLink, style: { display: 'flex', gap: 8, alignItems: 'center', cursor: 'pointer' }, children: [_jsx("input", { type: "radio", name: "workspace-setup-source", value: "cloud", checked: workspaceSetupSource === 'cloud', onChange: () => setWorkspaceSetupSource('cloud'), disabled: setupBusy }), _jsxs("span", { children: ["Sync existing cloud ", workspaceLabel.toLowerCase()] })] })] })), !isCloudRuntime && workspaceSetupSource === 'cloud' && canUseCloudWorkspaceSetup ? (_jsxs("div", { style: { display: 'grid', gap: 8 }, children: [!isAuthenticated && (_jsxs(_Fragment, { children: [_jsx("p", { className: styles.loginSubtitle, style: { margin: 0 }, children: "Sign in to choose one of your cloud projects." }), _jsx("button", { className: styles.cancelBtn, disabled: setupBusy, onClick: () => {
+                                                        navigate(`/login?mode=login&next=${encodeURIComponent('/setup?step=workspace&source=cloud')}`, { replace: true });
+                                                    }, children: "Sign In" })] })), isAuthenticated && (_jsxs(_Fragment, { children: [_jsxs("select", { className: styles.input, value: cloudWorkspaceSelection, onChange: (event) => setCloudWorkspaceSelection(event.target.value), disabled: setupBusy || cloudWorkspaceLoading || cloudWorkspaceOptions.length === 0, children: [cloudWorkspaceOptions.length === 0 && (_jsx("option", { value: "", children: cloudWorkspaceLoading ? 'Loading cloud projects...' : 'No cloud projects found' })), cloudWorkspaceOptions.map((workspace) => (_jsxs("option", { value: workspace.id, children: [workspace.name, " (", workspace.id, ")"] }, workspace.id)))] }), _jsx("div", { style: { display: 'flex', justifyContent: 'flex-end', gap: 8 }, children: _jsx("button", { className: styles.cancelBtn, disabled: setupBusy || cloudWorkspaceLoading, onClick: () => void fetchCloudWorkspaceOptions(), children: "Refresh Cloud Projects" }) }), cloudWorkspaceError && _jsx("p", { className: styles.loginError, children: cloudWorkspaceError })] }))] })) : (_jsxs(_Fragment, { children: [_jsx("input", { className: styles.input, type: "text", value: workspaceNameInput, placeholder: t('setup.workspaceNamePlaceholder', { workspaceLabel }), onChange: (event) => setWorkspaceNameInput(event.target.value), disabled: setupBusy }), _jsx("textarea", { className: styles.textarea, value: workspaceDescriptionInput, placeholder: t('setup.workspaceDescriptionPlaceholder', { workspaceLabel }), onChange: (event) => setWorkspaceDescriptionInput(event.target.value), disabled: setupBusy, rows: 4 }), !isCloudRuntime && canUseCloudWorkspaceSetup && isAuthenticated && (_jsxs("div", { style: { display: 'grid', gap: 4 }, children: [_jsxs("label", { className: styles.authModeLink, style: { display: 'flex', gap: 8, alignItems: 'center', cursor: 'pointer' }, children: [_jsx("input", { type: "checkbox", checked: syncNewLocalWorkspaceToCloud, onChange: (event) => setSyncNewLocalWorkspaceToCloud(event.target.checked), disabled: setupBusy }), _jsx("span", { children: "Sync to cloud after setup" })] }), _jsx("p", { style: { margin: 0, color: 'var(--text-muted)', fontSize: '12px' }, children: "When enabled, this project will connect to cloud sync as soon as setup finishes." })] }))] }))] })), _jsxs("div", { className: styles.authModeLinks, children: [isGlobal ? (_jsx("button", { className: styles.submitBtn, disabled: setupBusy, onClick: async () => {
+                                        setSetupBusy(true);
+                                        setSetupNotice(null);
+                                        setSetupError(null);
+                                        try {
+                                            const res = await fetch('/api/taskforce/global-settings', {
+                                                method: 'POST',
+                                                headers: { 'Content-Type': 'application/json' },
+                                                credentials: 'include',
+                                                body: JSON.stringify({ setup: { mode: setupModeChoice } })
+                                            });
+                                            const data = await res.json().catch(() => ({}));
+                                            if (!res.ok || data?.success === false) {
+                                                setSetupError(data?.error || t('setup.saveFailedWithStatus', { status: res.status }));
+                                            }
+                                            else {
+                                                setSetupNotice(t('setup.globalSetupSaved'));
+                                                await refreshSetupContext();
+                                            }
+                                        }
+                                        catch {
+                                            setSetupError(t('setup.saveFailed'));
+                                        }
+                                        finally {
+                                            setSetupBusy(false);
+                                        }
+                                    }, children: setupBusy ? t('setup.saving') : t('setup.saveGlobalSetup') })) : !isError ? (_jsx("button", { className: styles.submitBtn, disabled: setupBusy, onClick: async () => {
+                                        setSetupBusy(true);
+                                        setSetupNotice(null);
+                                        setSetupError(null);
+                                        if (!isCloudRuntime && workspaceSetupSource === 'cloud' && canUseCloudWorkspaceSetup) {
+                                            if (!isAuthenticated) {
+                                                setSetupError('Sign in is required before syncing a cloud project.');
+                                                setSetupBusy(false);
+                                                return;
+                                            }
+                                            const selectedWorkspace = cloudWorkspaceOptions.find((workspace) => workspace.id === cloudWorkspaceSelection);
+                                            if (!selectedWorkspace) {
+                                                setSetupError('Select a cloud project to sync.');
+                                                setSetupBusy(false);
+                                                return;
+                                            }
+                                            const result = await saveWorkspaceProfile({
+                                                workspaceId: selectedWorkspace.id,
+                                                name: selectedWorkspace.name || selectedWorkspace.id,
+                                                description: selectedWorkspace.description || undefined
+                                            });
+                                            if (!result.success) {
+                                                setSetupError(result.error || t('setup.saveWorkspaceFailed'));
+                                                setSetupBusy(false);
+                                                return;
+                                            }
+                                            const workspaceIdForSync = String(result.workspaceId || selectedWorkspace.id || '').trim();
+                                            if (!workspaceIdForSync) {
+                                                setSetupError('Failed to resolve workspace id for sync setup.');
+                                                setSetupBusy(false);
+                                                return;
+                                            }
+                                            const stateRes = await fetch('/api/taskforce/ui-state', {
+                                                method: 'POST',
+                                                headers: { 'Content-Type': 'application/json' },
+                                                credentials: 'include',
+                                                body: JSON.stringify({
+                                                    workspaceId: workspaceIdForSync,
+                                                    stateKey: 'workspace-sync',
+                                                    patch: {
+                                                        cloudSyncEnabled: true,
+                                                        sourceOfTruth: 'cloud',
+                                                        // I6: start false; the orchestrator marks it true after first successful pull.
+                                                        onboardingCompleted: false,
+                                                        pullCursor: null,
+                                                        updatedAt: new Date().toISOString()
+                                                    }
+                                                })
+                                            });
+                                            const statePayload = await stateRes.json().catch(() => ({}));
+                                            if (!stateRes.ok || statePayload?.success === false) {
+                                                setSetupError(statePayload?.error || `Failed to configure workspace sync (${stateRes.status})`);
+                                                setSetupBusy(false);
+                                                return;
+                                            }
+                                            applyWorkspaceSyncStateSnapshot({
+                                                cloudSyncEnabled: true,
+                                                sourceOfTruth: 'cloud',
+                                                // I6: start false; the orchestrator marks it true after first successful pull.
+                                                onboardingCompleted: false,
+                                                pullCursor: null
+                                            });
+                                            await refreshSetupContext();
+                                            setSetupNotice(`Cloud project synced setup ready: ${selectedWorkspace.name}`);
+                                        }
+                                        else {
+                                            const creatingNewLocalWorkspace = setupState?.workspaceSetupState === 'missing';
+                                            const result = await saveWorkspaceProfile({
+                                                workspaceId: creatingNewLocalWorkspace ? undefined : setupState?.workspaceId,
+                                                name: workspaceNameInput,
+                                                description: workspaceDescriptionInput
+                                            });
+                                            if (!result.success) {
+                                                setSetupError(result.error || t('setup.saveWorkspaceFailed'));
+                                            }
+                                            else {
+                                                const shouldEnableCloudSync = Boolean(!isCloudRuntime && syncNewLocalWorkspaceToCloud && canUseCloudWorkspaceSetup && isAuthenticated);
+                                                const workspaceIdForSync = String(result.workspaceId || setupState?.workspaceId || '').trim();
+                                                if (!workspaceIdForSync) {
+                                                    setSetupError('Failed to resolve workspace id for sync setup.');
+                                                    setSetupBusy(false);
+                                                    return;
+                                                }
+                                                const stateRes = await fetch('/api/taskforce/ui-state', {
+                                                    method: 'POST',
+                                                    headers: { 'Content-Type': 'application/json' },
+                                                    credentials: 'include',
+                                                    body: JSON.stringify({
+                                                        workspaceId: workspaceIdForSync,
+                                                        stateKey: 'workspace-sync',
+                                                        patch: {
+                                                            cloudSyncEnabled: shouldEnableCloudSync,
+                                                            sourceOfTruth: shouldEnableCloudSync ? 'local' : null,
+                                                            // I6: start false; the orchestrator marks it true after first successful pull.
+                                                            onboardingCompleted: false,
+                                                            pullCursor: null,
+                                                            updatedAt: new Date().toISOString()
+                                                        }
+                                                    })
+                                                });
+                                                const statePayload = await stateRes.json().catch(() => ({}));
+                                                if (!stateRes.ok || statePayload?.success === false) {
+                                                    setSetupError(statePayload?.error || `Failed to configure workspace sync (${stateRes.status})`);
+                                                    setSetupBusy(false);
+                                                    return;
+                                                }
+                                                applyWorkspaceSyncStateSnapshot({
+                                                    cloudSyncEnabled: shouldEnableCloudSync,
+                                                    sourceOfTruth: shouldEnableCloudSync ? 'local' : null,
+                                                    // I6: start false; the orchestrator marks it true after first successful pull.
+                                                    onboardingCompleted: false,
+                                                    pullCursor: null
+                                                });
+                                                if (shouldEnableCloudSync) {
+                                                    setSetupNotice(`${workspaceLabel} setup saved. Cloud sync enabled.`);
+                                                }
+                                                else {
+                                                    setSetupNotice(t('setup.workspaceSetupSaved', { workspaceLabel }));
+                                                }
+                                            }
+                                        }
+                                        setSetupBusy(false);
+                                    }, children: setupBusy ? t('setup.saving') : t('setup.saveWorkspaceSetup', { workspaceLabel }) })) : (_jsx("button", { className: styles.submitBtn, disabled: setupBusy, onClick: refreshSetupContext, children: t('setup.retrySetupCheck') })), runtimeMode === 'cloud' && (_jsx("button", { className: styles.cancelBtn, onClick: async () => { await taskforceState.logout(); navigate('/login', { replace: true }); }, children: t('setup.signOut') }))] })] }) }) }));
+    }
+    return (_jsx(StandaloneLayout, { ...taskforceState, onHeaderMouseDown: onHeaderMouseDown, isDragging: isDragging, onClose: onClose }));
+}
+export function TaskforceCore(props) {
+    const inRouterContext = useInRouterContext();
+    if (!inRouterContext) {
+        return (_jsx(MemoryRouter, { children: _jsx(TaskforceCoreWithRouter, { ...props }) }));
+    }
+    return _jsx(TaskforceCoreWithRouter, { ...props });
+}