@taskforcehq/taskforce 0.3.306 → 0.3.307

package/dist/TaskforceCore.test.js

@@ -910,6 +910,48 @@ describe('TaskforceCore Integration', () => {
         });
         expect(container.querySelector('[aria-pressed]')).not.toBeInTheDocument();
     });
+    it('renders the cloud login route even while protected startup config is pending', async () => {
+        const hangingConfig = new Promise(() => { });
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        config: {
+                            runtimeMode: 'cloud',
+                            workspaceMode: 'multi-cloud',
+                            authSource: 'cloud',
+                            workspaceSwitchingEnabled: true
+                        }
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        authenticated: false,
+                        runtimeMode: 'cloud'
+                    })
+                });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return hangingConfig;
+            }
+            if (url.includes('/api/taskforce/auth/providers')) {
+                return Promise.resolve({ ok: true, json: () => Promise.resolve({ providers: [] }) });
+            }
+            return Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/login?mode=login&next=%2Ftaskforce%2F'], children: _jsx(TaskforceCore, {}) }));
+        await waitFor(() => {
+            expect(screen.getByPlaceholderText('Email')).toBeInTheDocument();
+            expect(screen.getByPlaceholderText('Password')).toBeInTheDocument();
+            expect(screen.getByRole('button', { name: 'Sign In' })).toBeInTheDocument();
+        });
+        expect(screen.queryByText('Loading Taskforce')).not.toBeInTheDocument();
+    });
     it('allows public access to /pricing in cloud mode without login redirect', async () => {
         const fetchMock = vi.fn((url) => {
             if (url.includes('/api/taskforce/auth/session')) {
@@ -6002,6 +6044,142 @@ describe('TaskforceCore Integration', () => {
         await user.click(screen.getByTitle(/Account/i));
         expect(await screen.findByText('Sign In / Register')).toBeInTheDocument();
     });
+    it('returns to the login screen after signing out from the cloud plans screen', async () => {
+        const user = userEvent.setup();
+        let signedIn = true;
+        const fetchMock = vi.fn((url) => {
+            if (url.includes('/api/taskforce/auth/runtime-config')) {
+                return jsonResponse({ config: { runtimeMode: 'cloud', workspaceMode: 'team', authSource: 'cloud' } });
+            }
+            if (url.includes('/api/taskforce/auth/session')) {
+                return jsonResponse({
+                    authenticated: signedIn,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    email: signedIn ? 'member@example.com' : '',
+                    userId: signedIn ? 'user-member' : 'anonymous',
+                    workspaceId: signedIn ? 'workspace-cloud-active' : '',
+                    betaAccess: true
+                });
+            }
+            if (url.includes('/api/taskforce/auth/logout')) {
+                signedIn = false;
+                return jsonResponse({ success: true });
+            }
+            if (url.includes('/api/taskforce/config')) {
+                return jsonResponse({
+                    ...mockConfig,
+                    runtimeMode: 'cloud',
+                    authRequiredForApi: true,
+                    workspaceId: 'workspace-cloud-active',
+                    workspaceSwitchingEnabled: true,
+                    setupState: {
+                        globalSetupState: 'present',
+                        workspaceSetupState: 'present',
+                        runtimeMode: 'cloud',
+                        workspaceId: 'workspace-cloud-active',
+                        mode: 'core',
+                        forceSetup: false,
+                        forceGlobalSetup: false,
+                        forceWorkspaceSetup: false
+                    }
+                });
+            }
+            if (url.includes('/api/taskforce/account/access-status')) {
+                return jsonResponse({
+                    gate: 'plan_selection_required',
+                    hasEntitlement: false,
+                    canAccessApp: false,
+                    canAccessPlans: true
+                });
+            }
+            if (url.includes('/api/taskforce/public/pricing')) {
+                return jsonResponse({
+                    plans: [
+                        {
+                            planId: 'free',
+                            displayName: 'Free',
+                            status: 'active',
+                            features: [],
+                            pricing: {
+                                month: { pricingType: 'free', stripePriceId: null, unitAmount: 0, currency: null, interval: 'month' },
+                                year: null
+                            },
+                            defaultVersion: {
+                                planVersionId: 'free-v1',
+                                versionNumber: 1,
+                                seatLimit: null,
+                                metadata: {}
+                            }
+                        }
+                    ]
+                });
+            }
+            if (url.includes('/api/taskforce/account/profile-summary')) {
+                return jsonResponse({
+                    planId: 'free',
+                    planName: 'Free',
+                    planVersionId: 'free-v1',
+                    entitlementState: 'pending_plan_selection',
+                    gate: 'plan_selection_required',
+                    planSelectionRequired: true
+                });
+            }
+            if (url.includes('/api/taskforce/workspaces')) {
+                return jsonResponse({ workspaces: [] });
+            }
+            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: {} });
+            }
+            if (url.includes('/api/taskforce/categories')) {
+                return jsonResponse(mockCategories);
+            }
+            if (url.includes('/api/taskforce/tasks')) {
+                return jsonResponse({ tasks: mockTasks });
+            }
+            if (url.includes('/api/taskforce/archive')) {
+                return jsonResponse({ archived: [] });
+            }
+            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/workflow-templates')) {
+                return jsonResponse({ templates: [] });
+            }
+            if (url.includes('/api/taskforce/workspace/assignee-options')) {
+                return jsonResponse({ assignees: [] });
+            }
+            if (url.includes('/api/taskforce/planning/bootstrap')) {
+                return jsonResponse({
+                    initiatives: [],
+                    workstreams: [],
+                    workstreamTaskSummaries: [],
+                });
+            }
+            return jsonResponse({});
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        render(_jsx(MemoryRouter, { initialEntries: ['/?screen=plans&gate=plan_selection_required'], children: _jsx(TaskforceCore, { config: { cloudAuthBaseUrl: 'https://cloud.example.com' } }) }));
+        expect(await screen.findByRole('heading', { name: 'Subscription Plans' })).toBeInTheDocument();
+        await user.click(screen.getByTitle(/Account/i));
+        await user.click(await screen.findByRole('menuitem', { name: 'Sign Out' }));
+        await waitFor(() => {
+            expect(fetchMock.mock.calls.some((call) => String(call[0]).includes('/api/taskforce/auth/logout'))).toBe(true);
+            expect(screen.getByText('Sign in with your account credentials.')).toBeInTheDocument();
+        });
+    });
     it('uses an explicit cloud sign-out redirect and broader cloud logout reset path', () => {
         const standaloneLayoutSource = fs.readFileSync(path.join(__dirname, 'components/views/StandaloneLayout.tsx'), 'utf8');
         const useTaskforceSource = fs.readFileSync(path.join(__dirname, 'hooks/useTaskforce.ts'), 'utf8');

package/dist/components/activity/EntityActivityTimeline.d.ts

@@ -0,0 +1,34 @@
+import React from 'react';
+import { type TaskEventValueFormatter } from '../../utils/taskActivity';
+import type { EntityActivityItem, TaskActor } from '../../types';
+export type ActivityActorPresentation = {
+    kind: 'member' | 'agent' | 'system';
+    label: string;
+    color?: string;
+    ActorIcon: React.ComponentType<{
+        size?: number;
+        strokeWidth?: number;
+    }>;
+};
+export declare function EntityActivityTimeline({ activity, comments, formatFieldValue, resolveActorPresentation, onOpenTaskById, emptyMessage, listClassName, emptyClassName, endRef, }: {
+    activity?: EntityActivityItem[];
+    comments?: Array<{
+        id: string;
+        author: string;
+        text: string;
+        timestamp: string;
+        actor?: TaskActor | null;
+    }>;
+    formatFieldValue?: TaskEventValueFormatter;
+    resolveActorPresentation: (input: {
+        actorId?: string | null;
+        actorType?: 'human' | 'ai' | 'system' | null;
+        actorProfile?: TaskActor | null;
+        fallbackKind?: 'member' | 'agent' | 'system';
+    }) => ActivityActorPresentation;
+    onOpenTaskById?: (taskId: string) => void;
+    emptyMessage?: string;
+    listClassName?: string;
+    emptyClassName?: string;
+    endRef?: React.Ref<HTMLDivElement>;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/activity/EntityActivityTimeline.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Markdown } from '../ui/Markdown';
+import { formatDate } from '../../utils/formatting';
+import { getEntityActivityItems, getEntityEventPrimaryChangeField, summarizeEntityEvent, summarizeTaskChange, } from '../../utils/taskActivity';
+import timelineStyles from './EntityActivityTimeline.module.css';
+function hexToRgba(hex, opacity) {
+    const normalized = hex.replace('#', '').trim();
+    if (normalized.length !== 3 && normalized.length !== 6)
+        return '';
+    const expanded = normalized.length === 3
+        ? normalized.split('').map((part) => part + part).join('')
+        : normalized;
+    const int = Number.parseInt(expanded, 16);
+    if (Number.isNaN(int))
+        return '';
+    const red = (int >> 16) & 255;
+    const green = (int >> 8) & 255;
+    const blue = int & 255;
+    return `rgba(${red}, ${green}, ${blue}, ${opacity})`;
+}
+export function EntityActivityTimeline({ activity, comments, formatFieldValue, resolveActorPresentation, onOpenTaskById, emptyMessage = 'No activity yet.', listClassName, emptyClassName, endRef, }) {
+    const items = React.useMemo(() => getEntityActivityItems({ activity, comments }), [activity, comments]);
+    return (_jsxs("div", { className: [timelineStyles.thread, listClassName].filter(Boolean).join(' '), children: [items.length === 0 ? (_jsx("div", { className: [timelineStyles.empty, emptyClassName].filter(Boolean).join(' '), children: emptyMessage })) : null, items.map((item) => {
+                if (item.type === 'comment') {
+                    const actorPresentation = resolveActorPresentation({
+                        actorId: item.comment.author,
+                        actorType: item.comment.actor?.kind === 'ai'
+                            ? 'ai'
+                            : item.comment.actor?.kind === 'human'
+                                ? 'human'
+                                : null,
+                        actorProfile: item.comment.actor || null,
+                    });
+                    const commentKind = actorPresentation.kind === 'agent' ? 'agent' : 'member';
+                    const { ActorIcon } = actorPresentation;
+                    const authorColor = actorPresentation.color;
+                    const commentAccentStyle = authorColor && hexToRgba(authorColor, 0.35)
+                        ? {
+                            background: `linear-gradient(135deg, ${hexToRgba(authorColor, 0.18)} 0%, ${hexToRgba(authorColor, 0.1)} 100%)`,
+                            borderColor: hexToRgba(authorColor, 0.35),
+                        }
+                        : undefined;
+                    return (_jsxs("div", { className: [
+                            timelineStyles.item,
+                            timelineStyles.comment,
+                            commentKind === 'agent' ? timelineStyles.commentAgent : timelineStyles.commentMember,
+                        ].join(' '), children: [_jsxs("div", { className: timelineStyles.header, children: [_jsxs("span", { className: timelineStyles.author, style: authorColor ? { color: authorColor } : undefined, children: [_jsx(ActorIcon, { size: 12, strokeWidth: 1.5 }), actorPresentation.label] }), _jsx("span", { className: timelineStyles.time, children: formatDate(item.comment.timestamp, {
+                                            month: 'short',
+                                            day: 'numeric',
+                                            hour: '2-digit',
+                                            minute: '2-digit',
+                                        }) })] }), _jsx("div", { className: timelineStyles.commentText, style: commentAccentStyle, children: _jsx(Markdown, { onTaskIdClick: onOpenTaskById, children: item.comment.text }) })] }, item.id));
+                }
+                const actorPresentation = resolveActorPresentation({
+                    actorId: item.event.actor,
+                    actorType: item.event.actorType,
+                    actorProfile: item.event.actorProfile || null,
+                    fallbackKind: 'system',
+                });
+                const { ActorIcon } = actorPresentation;
+                const authorColor = actorPresentation.color;
+                const changeEntries = Object.entries(item.event.details?.changes || {});
+                const primaryChangeField = getEntityEventPrimaryChangeField(item.event);
+                const displayedChangeEntries = changeEntries.length > 1 && primaryChangeField
+                    ? changeEntries.filter(([field]) => field !== primaryChangeField)
+                    : changeEntries.length > 1
+                        ? changeEntries
+                        : [];
+                return (_jsxs("div", { className: [
+                        timelineStyles.item,
+                        timelineStyles.event,
+                        actorPresentation.kind === 'system' ? timelineStyles.eventSystem : '',
+                    ].filter(Boolean).join(' '), children: [_jsxs("div", { className: [timelineStyles.header, timelineStyles.eventHeader].join(' '), children: [_jsxs("span", { className: timelineStyles.author, style: authorColor ? { color: authorColor } : undefined, children: [_jsx(ActorIcon, { size: 12, strokeWidth: 1.5 }), actorPresentation.label] }), _jsx("span", { className: timelineStyles.time, children: formatDate(item.event.createdAt, {
+                                        month: 'short',
+                                        day: 'numeric',
+                                        hour: '2-digit',
+                                        minute: '2-digit',
+                                    }) })] }), _jsxs("div", { className: timelineStyles.eventText, children: [_jsx("div", { children: summarizeEntityEvent(item.event, formatFieldValue) }), displayedChangeEntries.length > 0 ? (_jsx("div", { className: timelineStyles.eventChanges, children: displayedChangeEntries.map(([field, change]) => (_jsx("div", { className: timelineStyles.eventChange, children: summarizeTaskChange(field, change, formatFieldValue) }, field))) })) : null] })] }, item.id));
+            }), _jsx("div", { ref: endRef })] }));
+}

package/dist/components/context/ContextAttachmentManager.js

@@ -299,7 +299,9 @@ export function ContextAttachmentManager(props) {
                     referenceNumber: typeof data.referenceNumber === 'number' ? data.referenceNumber : null,
                     referenceLabel: typeof data.referenceLabel === 'string' ? data.referenceLabel : undefined,
                     taskId: ownerType === 'task' && typeof data.taskId === 'string' ? data.taskId : null,
-                    timestamp: new Date().toISOString()
+                    timestamp: typeof data.timestamp === 'string' && data.timestamp.trim().length > 0
+                        ? data.timestamp
+                        : new Date().toISOString()
                 });
                 dispatchTaskforceContextAssetsMutated({
                     workspaceId: trimmedWorkspaceId || 'default',
@@ -507,7 +509,12 @@ export function ContextAttachmentManager(props) {
                                                     e.target.style.display = 'none';
                                                     e.target.parentElement.classList.add(styles.brokenImage);
                                                 } })) : (_jsxs("button", { type: "button", className: styles.contextFileLink, onClick: () => {
-                                                    if (dispatchOpenMarkdownDocument(item, fsPath))
+                                                    const markdownTarget = ownerType === 'task'
+                                                        ? (typeof item === 'string'
+                                                            ? { path: item, taskId: trimmedOwnerId }
+                                                            : { ...item, taskId: trimmedOwnerId })
+                                                        : item;
+                                                    if (dispatchOpenMarkdownDocument(markdownTarget, fsPath))
                                                         return;
                                                     window.open(path, '_blank');
                                                 }, title: "Open file", children: [_jsx(FileUp, { size: 16 }), _jsx("span", { children: caption || fsPath || path.split('/').pop() || 'Context file' })] })), _jsxs("div", { className: styles.brokenImagePlaceholder, children: [_jsx(AlertTriangle, { size: 16 }), _jsx("span", { children: "Preview unavailable" })] }), _jsxs("div", { className: styles.attachmentActions, children: [canAnnotate && (_jsx("button", { type: "button", className: styles.attachmentActionBtn, onClick: (e) => {
@@ -537,7 +544,12 @@ export function ContextAttachmentManager(props) {
                             const documentReferenceLabel = typeof item === 'string' ? '' : getDocumentReferenceLabel(item);
                             const isExternalUrl = /^https?:\/\//i.test(path);
                             return (_jsxs("div", { className: styles.documentAttachmentItem, children: [_jsxs("div", { className: styles.documentAttachmentRow, children: [_jsxs("button", { type: "button", className: styles.documentAttachmentLink, onClick: () => {
-                                                    if (dispatchOpenMarkdownDocument(item, fsPath))
+                                                    const markdownTarget = ownerType === 'task'
+                                                        ? (typeof item === 'string'
+                                                            ? { path: item, taskId: trimmedOwnerId }
+                                                            : { ...item, taskId: trimmedOwnerId })
+                                                        : item;
+                                                    if (dispatchOpenMarkdownDocument(markdownTarget, fsPath))
                                                         return;
                                                     window.open(path, '_blank');
                                                 }, title: displayName, children: [_jsxs("span", { className: styles.documentAttachmentMain, children: [_jsx("span", { className: styles.documentAttachmentIcon, "aria-hidden": "true", children: _jsx(File, { size: 13 }) }), _jsxs("span", { className: styles.documentAttachmentText, children: [_jsx("span", { className: styles.documentAttachmentName, children: displayName }), documentReferenceLabel && (_jsx("span", { className: styles.taskIdBadge, children: documentReferenceLabel }))] })] }), _jsx("span", { className: styles.documentAttachmentType, children: fileType })] }), _jsxs("div", { className: styles.documentAttachmentActions, children: [fsPath && (_jsx("button", { type: "button", className: styles.documentAttachmentActionBtn, onClick: () => {

package/dist/components/features/AgentsModule.d.ts

@@ -1,3 +1,4 @@
+import React from 'react';
 type AiProfileSeatUsage = {
     used: number;
     limit: number | null;
@@ -9,6 +10,9 @@ interface AgentsModuleProps {
     authSessionResolved?: boolean;
     isAuthenticated?: boolean;
     cloudAiProfileSeatUsage?: AiProfileSeatUsage | null;
+    agentTrayOpen?: boolean;
+    onCloseAgentTray?: () => void;
+    mcpSettingsNode?: React.ReactNode;
 }
-export declare function AgentsModule({ workspaceId, cloudAuthConfigured, authSessionResolved, isAuthenticated, cloudAiProfileSeatUsage, }: AgentsModuleProps): import("react/jsx-runtime").JSX.Element;
+export declare function AgentsModule({ workspaceId, cloudAuthConfigured, authSessionResolved, isAuthenticated, cloudAiProfileSeatUsage, agentTrayOpen, onCloseAgentTray, mcpSettingsNode, }: AgentsModuleProps): import("react/jsx-runtime").JSX.Element;
 export {};