Files
kandev/apps/web/components/task/task-page-content.tsx
T
2026-02-18 18:24:41 +00:00

370 lines
17 KiB
TypeScript

'use client';
import { useEffect, useMemo, useState } from 'react';
import { TaskTopBar } from '@/components/task/task-top-bar';
import { TaskLayout } from '@/components/task/task-layout';
import { DebugOverlay } from '@/components/debug-overlay';
import type { Repository, RepositoryScript, Task } from '@/lib/types/http';
import type { Terminal } from '@/hooks/domains/session/use-terminals';
import type { KanbanState } from '@/lib/state/slices';
import { DEBUG_UI } from '@/lib/config';
import { TooltipProvider } from '@kandev/ui/tooltip';
import { useRepositories } from '@/hooks/domains/workspace/use-repositories';
import { useSessionAgent } from '@/hooks/domains/session/use-session-agent';
import { useSessionResumption } from '@/hooks/domains/session/use-session-resumption';
import { useSessionAgentctl } from '@/hooks/domains/session/use-session-agentctl';
import { useAppStore } from '@/components/state-provider';
import { fetchTask } from '@/lib/api';
import { useTasks } from '@/hooks/use-tasks';
import { useResponsiveBreakpoint } from '@/hooks/use-responsive-breakpoint';
import type { Layout } from 'react-resizable-panels';
import { TaskArchivedProvider } from './task-archived-context';
import { SessionCommands } from '@/components/session-commands';
import { VcsDialogsProvider } from '@/components/vcs/vcs-dialogs';
type TaskPageContentProps = {
task: Task | null;
sessionId?: string | null;
initialRepositories?: Repository[];
initialScripts?: RepositoryScript[];
initialTerminals?: Terminal[];
defaultLayouts?: Record<string, Layout>;
};
function buildDebugEntries(params: {
connectionStatus: string;
task: Task | null;
effectiveSessionId: string | null | undefined;
taskSessionState: string | null;
isAgentWorking: boolean;
resumptionState: string;
resumptionError: string | null;
agentctlStatus: { status: string; isReady: boolean; errorMessage?: string | null; agentExecutionId?: string | null };
previewOpen: boolean;
previewStage: string;
previewUrl: string;
devProcessId: string | undefined;
devProcessStatus: string | null;
}): Record<string, unknown> {
const { connectionStatus, task, effectiveSessionId, taskSessionState,
isAgentWorking, resumptionState, resumptionError, agentctlStatus,
previewOpen, previewStage, previewUrl, devProcessId, devProcessStatus } = params;
return {
ws_status: connectionStatus,
task_id: task?.id ?? null,
session_id: effectiveSessionId ?? null,
task_state: task?.state ?? null,
task_session_state: taskSessionState ?? null,
is_agent_working: isAgentWorking,
resumption_state: resumptionState,
resumption_error: resumptionError,
agentctl_status: agentctlStatus.status,
agentctl_ready: agentctlStatus.isReady,
agentctl_error: agentctlStatus.errorMessage ?? null,
agentctl_execution_id: agentctlStatus.agentExecutionId ?? null,
preview_open: previewOpen,
preview_stage: previewStage,
preview_url: previewUrl || null,
dev_process_id: devProcessId ?? null,
dev_process_status: devProcessStatus ?? null,
};
}
function resolveEffectiveTask(
taskDetails: Task | null,
initialTask: Task | null,
kanbanTask: KanbanState['tasks'][number] | null,
effectiveTaskId: string | null,
): Task | null {
const matchingTaskDetails = taskDetails?.id === effectiveTaskId ? taskDetails : null;
const matchingInitialTask = initialTask?.id === effectiveTaskId ? initialTask : null;
const baseTask = matchingTaskDetails ?? matchingInitialTask;
if (!baseTask && !kanbanTask) return null;
if (baseTask) return mergeBaseWithKanban(baseTask, kanbanTask);
if (kanbanTask) return buildTaskFromKanban(kanbanTask, taskDetails, initialTask);
return null;
}
function mergeBaseWithKanban(baseTask: Task, kanbanTask: KanbanState['tasks'][number] | null): Task {
if (!kanbanTask) return baseTask;
return {
...baseTask,
title: kanbanTask.title ?? baseTask.title,
description: kanbanTask.description ?? baseTask.description,
workflow_step_id: (kanbanTask.workflowStepId as string | undefined) ?? baseTask.workflow_step_id,
position: kanbanTask.position ?? baseTask.position,
state: (kanbanTask.state as Task['state'] | undefined) ?? baseTask.state,
repositories: baseTask.repositories,
};
}
function buildTaskFromKanban(kanbanTask: KanbanState['tasks'][number], taskDetails: Task | null, initialTask: Task | null): Task {
const prevWorkspaceId = taskDetails?.workspace_id ?? initialTask?.workspace_id;
const prevBoardId = taskDetails?.workflow_id ?? initialTask?.workflow_id;
return {
id: kanbanTask.id,
title: kanbanTask.title,
description: kanbanTask.description ?? '',
workflow_step_id: kanbanTask.workflowStepId,
position: kanbanTask.position,
state: kanbanTask.state ?? 'CREATED',
workspace_id: prevWorkspaceId ?? '',
workflow_id: prevBoardId ?? '',
priority: 0,
repositories: [],
created_at: '',
updated_at: kanbanTask.updatedAt ?? '',
} as Task;
}
function useWorkflowStepsMapped() {
const kanbanSteps = useAppStore((state) => state.kanban.steps);
return useMemo(
() => kanbanSteps.map((s) => ({
id: s.id, name: s.title, color: s.color, position: s.position,
events: s.events, allow_manual_move: s.allow_manual_move,
prompt: s.prompt, is_start_step: s.is_start_step,
})),
[kanbanSteps]
);
}
function useSessionPanelState(effectiveSessionId: string | null | undefined) {
const storeSessionState = useAppStore((state) =>
effectiveSessionId ? state.taskSessions.items[effectiveSessionId]?.state ?? null : null
);
const isSessionPassthrough = useAppStore((state) =>
effectiveSessionId ? state.taskSessions.items[effectiveSessionId]?.is_passthrough === true : false
);
const previewOpen = useAppStore((state) =>
effectiveSessionId ? state.previewPanel.openBySessionId[effectiveSessionId] ?? false : false
);
const previewStage = useAppStore((state) =>
effectiveSessionId ? state.previewPanel.stageBySessionId[effectiveSessionId] ?? 'closed' : 'closed'
);
const previewUrl = useAppStore((state) =>
effectiveSessionId ? state.previewPanel.urlBySessionId[effectiveSessionId] ?? '' : ''
);
const devProcessId = useAppStore((state) =>
effectiveSessionId ? state.processes.devProcessBySessionId[effectiveSessionId] : undefined
);
const devProcessStatus = useAppStore((state) =>
devProcessId ? state.processes.processesById[devProcessId]?.status ?? null : null
);
return { storeSessionState, isSessionPassthrough, previewOpen, previewStage, previewUrl, devProcessId, devProcessStatus };
}
function deriveIsAgentWorking(taskSessionState: string | null, isAgentRunning: boolean, taskState: string | null): boolean {
if (taskSessionState !== null) return taskSessionState === 'STARTING' || taskSessionState === 'RUNNING';
return isAgentRunning && (taskState === 'IN_PROGRESS' || taskState === 'SCHEDULING');
}
function useMergedAgentState(
agent: ReturnType<typeof useSessionAgent>,
resumption: ReturnType<typeof useSessionResumption>,
sessionPanel: ReturnType<typeof useSessionPanelState>,
effectiveSessionId: string | null | undefined,
task: Task | null,
) {
const isResuming = resumption.resumptionState === 'checking' || resumption.resumptionState === 'resuming';
const isResumed = resumption.resumptionState === 'resumed' || resumption.resumptionState === 'running';
const taskSessionState = sessionPanel.storeSessionState ?? agent.taskSessionState;
const worktreePath = effectiveSessionId ? (resumption.worktreePath ?? agent.worktreePath) : agent.worktreePath;
const worktreeBranch = effectiveSessionId ? (resumption.worktreeBranch ?? agent.worktreeBranch) : agent.worktreeBranch;
const isAgentWorking = deriveIsAgentWorking(taskSessionState, agent.isAgentRunning, task?.state ?? null);
return { isResuming, isResumed, taskSessionState, worktreePath, worktreeBranch, isAgentWorking };
}
function buildArchivedValue(task: Task | null, repository: Repository | null) {
const isArchived = !!task?.archived_at;
return {
isArchived,
archivedTaskId: isArchived ? task?.id : undefined,
archivedTaskTitle: isArchived ? task?.title : undefined,
archivedTaskRepositoryPath: isArchived ? (repository?.local_path ?? undefined) : undefined,
archivedTaskUpdatedAt: isArchived ? task?.updated_at : undefined,
};
}
type TaskPageInnerProps = {
task: Task | null;
effectiveSessionId: string | null;
repository: Repository | null;
agent: ReturnType<typeof useSessionAgent>;
merged: ReturnType<typeof useMergedAgentState>;
resumption: ReturnType<typeof useSessionResumption>;
sessionPanel: ReturnType<typeof useSessionPanelState>;
agentctlStatus: ReturnType<typeof useSessionAgentctl>;
connectionStatus: string;
workflowSteps: ReturnType<typeof useWorkflowStepsMapped>;
archivedValue: ReturnType<typeof buildArchivedValue>;
isMobile: boolean;
showDebugOverlay: boolean;
onToggleDebugOverlay: () => void;
initialScripts: RepositoryScript[];
initialTerminals?: Terminal[];
defaultLayouts: Record<string, Layout>;
};
function resolveTaskIds(task: Task | null) {
return {
taskId: task?.id ?? null,
workflowId: task?.workflow_id ?? null,
workspaceId: task?.workspace_id ?? null,
workflowStepId: task?.workflow_step_id ?? null,
baseBranch: task?.repositories?.[0]?.base_branch,
isArchived: !!task?.archived_at,
};
}
function resolveTaskProps(task: Task | null, repository: Repository | null) {
const ids = resolveTaskIds(task);
return {
...ids,
taskTitle: task?.title,
taskDescription: task?.description,
repositoryPath: repository?.local_path ?? null,
repositoryName: repository?.name ?? null,
};
}
function TaskPageInner({
task, effectiveSessionId, repository, agent, merged, resumption, sessionPanel,
agentctlStatus, connectionStatus, workflowSteps, archivedValue, isMobile,
showDebugOverlay, onToggleDebugOverlay, initialScripts, initialTerminals, defaultLayouts,
}: TaskPageInnerProps) {
const tp = resolveTaskProps(task, repository);
return (
<TooltipProvider>
<VcsDialogsProvider sessionId={effectiveSessionId} baseBranch={tp.baseBranch} taskTitle={tp.taskTitle} displayBranch={merged.worktreeBranch}>
<div className="h-screen w-full flex flex-col bg-background">
<SessionCommands sessionId={effectiveSessionId} baseBranch={tp.baseBranch} isAgentRunning={merged.isAgentWorking} hasWorktree={Boolean(merged.worktreeBranch)} isPassthrough={sessionPanel.isSessionPassthrough} />
{DEBUG_UI && showDebugOverlay && (
<DebugOverlay title="Task Debug" entries={buildDebugEntries({
connectionStatus, task, effectiveSessionId, taskSessionState: merged.taskSessionState,
isAgentWorking: merged.isAgentWorking, resumptionState: resumption.resumptionState,
resumptionError: resumption.error, agentctlStatus, previewOpen: sessionPanel.previewOpen,
previewStage: sessionPanel.previewStage, previewUrl: sessionPanel.previewUrl,
devProcessId: sessionPanel.devProcessId, devProcessStatus: sessionPanel.devProcessStatus,
})} />
)}
{!isMobile && (
<TaskTopBar
taskId={tp.taskId} activeSessionId={effectiveSessionId} taskTitle={tp.taskTitle}
taskDescription={tp.taskDescription} baseBranch={tp.baseBranch ?? undefined}
onStartAgent={agent.handleStartAgent} onStopAgent={agent.handleStopAgent}
isAgentRunning={agent.isAgentRunning || merged.isResumed} isAgentLoading={agent.isAgentLoading || merged.isResuming}
worktreePath={merged.worktreePath} worktreeBranch={merged.worktreeBranch}
repositoryPath={tp.repositoryPath} repositoryName={tp.repositoryName}
showDebugOverlay={showDebugOverlay} onToggleDebugOverlay={onToggleDebugOverlay}
workflowSteps={workflowSteps} currentStepId={tp.workflowStepId} workflowId={tp.workflowId} isArchived={tp.isArchived}
/>
)}
<TaskArchivedProvider value={archivedValue}>
<TaskLayout
workspaceId={tp.workspaceId} workflowId={tp.workflowId} sessionId={effectiveSessionId}
repository={repository ?? null} initialScripts={initialScripts} initialTerminals={initialTerminals}
defaultLayouts={defaultLayouts} taskTitle={tp.taskTitle} baseBranch={tp.baseBranch} worktreeBranch={merged.worktreeBranch}
/>
</TaskArchivedProvider>
</div>
</VcsDialogsProvider>
</TooltipProvider>
);
}
function syncActiveTaskSession(params: {
initialTaskId: string | undefined;
initialSessionId: string | null;
setActiveSession: (taskId: string, sessionId: string) => void;
setActiveTask: (taskId: string) => void;
}) {
if (!params.initialTaskId) return;
if (params.initialSessionId) params.setActiveSession(params.initialTaskId, params.initialSessionId);
else params.setActiveTask(params.initialTaskId);
}
function useTaskDetails(activeTaskId: string | null, initialTask: Task | null) {
const [taskDetails, setTaskDetails] = useState<Task | null>(initialTask);
const kanbanTask = useAppStore((state) =>
activeTaskId ? state.kanban.tasks.find((item: KanbanState['tasks'][number]) => item.id === activeTaskId) ?? null : null
);
const effectiveTaskId = activeTaskId ?? initialTask?.id ?? null;
const task = useMemo(() => resolveEffectiveTask(taskDetails, initialTask, kanbanTask, effectiveTaskId), [taskDetails, initialTask, kanbanTask, effectiveTaskId]);
useTasks(task?.workflow_id ?? null);
useEffect(() => {
if (!activeTaskId || taskDetails?.id === activeTaskId) return;
fetchTask(activeTaskId, { cache: 'no-store' })
.then((response) => setTaskDetails(response))
.catch((error) => console.error('[TaskPageContent] Failed to load task details:', error));
}, [activeTaskId, taskDetails?.id, taskDetails?.workspace_id, taskDetails?.workflow_id, kanbanTask, setTaskDetails]);
return { task, kanbanTask };
}
function useTaskPageData(initialTask: Task | null, sessionId: string | null, initialRepositories: Repository[]) {
const activeTaskId = useAppStore((state) => state.tasks.activeTaskId);
const activeSessionId = useAppStore((state) => state.tasks.activeSessionId);
const setActiveSession = useAppStore((state) => state.setActiveSession);
const setActiveTask = useAppStore((state) => state.setActiveTask);
const { task } = useTaskDetails(activeTaskId, initialTask);
const agent = useSessionAgent(task);
const initialSessionId = sessionId ?? agent.taskSessionId ?? null;
const effectiveSessionId = activeSessionId ?? initialSessionId;
useEffect(() => {
syncActiveTaskSession({ initialTaskId: initialTask?.id, initialSessionId, setActiveSession, setActiveTask });
}, [initialTask?.id, initialSessionId, setActiveSession, setActiveTask]);
const { repositories } = useRepositories(task?.workspace_id ?? null, Boolean(task?.workspace_id));
const effectiveRepositories = repositories.length ? repositories : initialRepositories;
const repository = useMemo(
() => effectiveRepositories.find((item: Repository) => item.id === task?.repositories?.[0]?.repository_id) ?? null,
[effectiveRepositories, task?.repositories]
);
return { task, agent, effectiveSessionId, repository };
}
export function TaskPageContent({
task: initialTask,
sessionId = null,
initialRepositories = [],
initialScripts = [],
initialTerminals,
defaultLayouts = {},
}: TaskPageContentProps) {
const [isMounted, setIsMounted] = useState(false);
const [showDebugOverlay, setShowDebugOverlay] = useState(false);
const { isMobile } = useResponsiveBreakpoint();
const connectionStatus = useAppStore((state) => state.connection.status);
const { task, agent, effectiveSessionId, repository } = useTaskPageData(initialTask, sessionId, initialRepositories);
const workflowSteps = useWorkflowStepsMapped();
const sessionPanel = useSessionPanelState(effectiveSessionId);
const agentctlStatus = useSessionAgentctl(effectiveSessionId);
const resumption = useSessionResumption(task?.id ?? null, effectiveSessionId);
const merged = useMergedAgentState(agent, resumption, sessionPanel, effectiveSessionId, task);
const archivedValue = useMemo(() => buildArchivedValue(task, repository), [task, repository]);
useEffect(() => { queueMicrotask(() => setIsMounted(true)); }, []);
if (!isMounted) return <div className="h-screen w-full bg-background" />;
return (
<TaskPageInner
task={task} effectiveSessionId={effectiveSessionId ?? null} repository={repository}
agent={agent} merged={merged} resumption={resumption} sessionPanel={sessionPanel}
agentctlStatus={agentctlStatus} connectionStatus={connectionStatus}
workflowSteps={workflowSteps} archivedValue={archivedValue} isMobile={isMobile}
showDebugOverlay={showDebugOverlay} onToggleDebugOverlay={() => setShowDebugOverlay((prev) => !prev)}
initialScripts={initialScripts} initialTerminals={initialTerminals} defaultLayouts={defaultLayouts}
/>
);
}