"use client"; import { useEffect, useState } from "react"; import { IconAlertTriangle, IconCheck, IconGitBranch, IconLoader2, IconRefresh, } from "@tabler/icons-react"; import { Button } from "@kandev/ui/button"; import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "@kandev/ui/collapsible"; import { getWebSocketClient } from "@/lib/ws/connection"; import type { TaskRepository } from "@/lib/types/http"; import type { TaskLaunchRecoveryAction } from "@/lib/types/task-launch-error"; import type { TaskStatusSummaryActiveError } from "@/lib/types/task-status-summary"; import { TaskLaunchBranchPicker } from "@/components/task/task-launch-branch-picker"; import { useTranslation } from "react-i18next"; type TaskLaunchErrorEntryProps = { taskId: string; workspaceId: string; error: TaskStatusSummaryActiveError; repositories?: TaskRepository[]; }; const pendingRecoveryRequests = new Map>(); function useTaskLaunchRecovery({ taskId, error, }: Pick) { const [pendingAction, setPendingAction] = useState(null); const [recoveryError, setRecoveryError] = useState(false); useEffect(() => { setRecoveryError(false); }, [error.stamp]); const sendRecovery = async (action: TaskLaunchRecoveryAction, baseBranch?: string) => { const client = getWebSocketClient(); if (!client || pendingAction) return; setRecoveryError(false); const requestKey = JSON.stringify({ taskId, stamp: error.stamp, action, baseBranch }); const existingRequest = pendingRecoveryRequests.get(requestKey); if (existingRequest) { setPendingAction(action); try { await existingRequest; } catch { // The request owner reports the recovery error to avoid duplicate toasts. } finally { setPendingAction(null); } return; } setPendingAction(action); const request = Promise.resolve().then(() => client.request("task.launch.recover", { task_id: taskId, ...(error.session_id ? { session_id: error.session_id } : {}), ...(error.task_repository_id ? { task_repository_id: error.task_repository_id } : {}), action, ...(baseBranch ? { base_branch: baseBranch } : {}), error_stamp: error.stamp, }), ); pendingRecoveryRequests.set(requestKey, request); try { await request; } catch { setRecoveryError(true); } finally { pendingRecoveryRequests.delete(requestKey); setPendingAction(null); } }; return { pendingAction, recoveryError, sendRecovery }; } const TASK_LAUNCH_ERROR_CATEGORIES = new Set([ "base_branch_missing", "default_branch_unresolved", "pr_already_closed", "workspace_checkout_failed", "generic_launch_failure", ]); export function isLaunchErrorCategory(category: string | undefined): boolean { return Boolean(category && TASK_LAUNCH_ERROR_CATEGORIES.has(category)); } export function isTypedTaskLaunchError( error: TaskStatusSummaryActiveError | null | undefined, ): error is TaskStatusSummaryActiveError & { category: string } { return Boolean(error?.stamp && isLaunchErrorCategory(error.category)); } function categoryTitle(category: string | undefined, t: (key: string) => string): string { switch (category) { case "base_branch_missing": return t("task:launchErrorBaseBranchMissing"); case "default_branch_unresolved": return t("task:launchErrorDefaultBranchUnresolved"); case "pr_already_closed": return t("task:launchErrorPrAlreadyClosed"); case "workspace_checkout_failed": return t("task:launchErrorWorkspaceCheckoutFailed"); default: return t("task:launchErrorGeneric"); } } function actionLabel(action: TaskLaunchRecoveryAction, t: (key: string) => string): string { switch (action) { case "retry_default": return t("task:retryWithDefaultBranch"); case "pick_base_branch": return t("task:pickBaseBranch"); case "mark_review_done": return t("task:markReviewDone"); case "retry_launch": return t("task:retryLaunch"); } } function RecoveryActionIcon({ action, pending, }: { action: TaskLaunchRecoveryAction; pending: boolean; }) { if (pending) return ; if (action === "retry_default") return ; if (action === "retry_launch") return ; if (action === "pick_base_branch") return ; return ; } function TaskLaunchRecoveryActions({ actions, workspaceId, repositories, taskRepositoryId, currentBase, pendingAction, onRecover, }: { actions: TaskLaunchRecoveryAction[]; workspaceId: string; repositories?: TaskRepository[]; taskRepositoryId?: string; currentBase: string; pendingAction: TaskLaunchRecoveryAction | null; onRecover: (action: TaskLaunchRecoveryAction, baseBranch?: string) => Promise; }) { const { t } = useTranslation(); return (
{actions.map((action) => { const opensBranchPicker = action === "pick_base_branch"; const button = ( ); if (action !== "pick_base_branch") return {button}; return ( onRecover(action, branch)} trigger={button} /> ); })}
); } export function TaskLaunchErrorEntry({ taskId, workspaceId, error, repositories, }: TaskLaunchErrorEntryProps) { const { t } = useTranslation(); const { pendingAction, recoveryError, sendRecovery } = useTaskLaunchRecovery({ taskId, error }); const [showDetails, setShowDetails] = useState(false); const taskRepository = repositories?.find( (repository) => repository.id === error.task_repository_id, ); const currentBase = taskRepository?.base_branch ?? t("task:baseBranchNotSet"); return (
{categoryTitle(error.category, t)} {t("task:launchNeedsAttention")}

{error.preview}

{t("task:launchErrorNoChanges")}

{error.details && ( {t("task:showDetails")}
                {error.details}
              
)} {recoveryError && (

{t("task:launchRecoveryFailed")} {t("task:tryRecoveryAgain")}

)}
); }