p-dev-harness 0.3.1 → 0.4.0

package/workspace-snapshot/files/apps/gui/components/custom/guided-step-transition.tsx

@@ -1,60 +1,114 @@
 "use client";
 
+import { useEffect, useRef } from "react";
 import { AnimatePresence, motion, useReducedMotion } from "framer-motion";
 
+import type { GuidedTransitionDirection } from "@/lib/guided-setup";
 import { cn } from "@/lib/utils";
 
 interface GuidedStepTransitionProps {
   stepKey: string;
+  direction: GuidedTransitionDirection;
   children: React.ReactNode;
   className?: string;
+  panelRef?: React.RefObject<HTMLElement | null>;
+}
+
+function focusIncomingPanel(panel: HTMLElement | null | undefined) {
+  if (!panel) {
+    return;
+  }
+
+  const focusTarget =
+    panel.querySelector<HTMLElement>("[data-guided-step-focus]") ??
+    panel.querySelector<HTMLElement>("h2, h3, button, a, input, select, textarea");
+
+  focusTarget?.focus({ preventScroll: true });
 }
 
 export function GuidedStepTransition({
   stepKey,
+  direction,
   children,
   className,
+  panelRef,
 }: GuidedStepTransitionProps) {
   const prefersReducedMotion = useReducedMotion();
+  const pendingFocusTransferRef = useRef(false);
+  const previousStepKeyRef = useRef(stepKey);
+
+  useEffect(() => {
+    if (previousStepKeyRef.current !== stepKey) {
+      pendingFocusTransferRef.current = Boolean(
+        panelRef?.current?.contains(document.activeElement),
+      );
+      previousStepKeyRef.current = stepKey;
+    }
+  }, [panelRef, stepKey]);
+
+  const spatialDirection =
+    direction === "none" ? "forward" : direction;
 
   const variants = prefersReducedMotion
     ? {
         initial: { opacity: 0 },
         animate: {
           opacity: 1,
-          transition: { duration: 0.15, ease: [0.2, 0, 0, 1] as const },
+          transition: { duration: 0.08, ease: [0.2, 0, 0, 1] as const },
         },
         exit: {
           opacity: 0,
-          transition: { duration: 0.12, ease: [0.3, 0, 1, 1] as const },
+          transition: { duration: 0.08, ease: [0.3, 0, 1, 1] as const },
         },
       }
-    : {
-        initial: { opacity: 0, y: 12 },
-        animate: {
-          opacity: 1,
-          y: 0,
-          transition: { duration: 0.28, ease: [0.2, 0, 0, 1] as const },
-        },
-        exit: {
-          opacity: 0,
-          y: -8,
-          transition: { duration: 0.22, ease: [0.3, 0, 1, 1] as const },
-        },
-      };
+    : spatialDirection === "forward"
+      ? {
+          initial: { opacity: 0, x: "100vw" },
+          animate: {
+            opacity: 1,
+            x: 0,
+            transition: { duration: 0.32, ease: [0.2, 0, 0, 1] as const },
+          },
+          exit: {
+            opacity: 0,
+            x: "-100vw",
+            transition: { duration: 0.28, ease: [0.32, 0, 0.67, 0] as const },
+          },
+        }
+      : {
+          initial: { opacity: 0, x: "-100vw" },
+          animate: {
+            opacity: 1,
+            x: 0,
+            transition: { duration: 0.32, ease: [0.2, 0, 0, 1] as const },
+          },
+          exit: {
+            opacity: 0,
+            x: "100vw",
+            transition: { duration: 0.28, ease: [0.32, 0, 0.67, 0] as const },
+          },
+        };
 
   return (
-    <AnimatePresence mode="wait" initial={false}>
-      <motion.div
-        key={stepKey}
-        className={cn(className)}
-        variants={variants}
-        initial="initial"
-        animate="animate"
-        exit="exit"
-      >
-        {children}
-      </motion.div>
-    </AnimatePresence>
+    <div className="w-full overflow-x-hidden">
+      <AnimatePresence mode="wait" initial={false}>
+        <motion.div
+          key={stepKey}
+          className={cn(className)}
+          variants={variants}
+          initial={direction === "none" ? false : "initial"}
+          animate="animate"
+          exit="exit"
+          onAnimationComplete={(definition) => {
+            if (definition === "animate" && pendingFocusTransferRef.current) {
+              focusIncomingPanel(panelRef?.current ?? null);
+              pendingFocusTransferRef.current = false;
+            }
+          }}
+        >
+          {children}
+        </motion.div>
+      </AnimatePresence>
+    </div>
   );
 }

package/workspace-snapshot/files/apps/gui/components/custom/guided-target-workflow-card.tsx

@@ -5,7 +5,12 @@ import type { RemoteTargetWorkflowApplyResult } from "@harness/setup/remote-acti
 import type { RemoteSetupSummary } from "@harness/setup/remote-setup-summary";
 import type { RemoteWorkflowStatus } from "@harness/setup/remote-actions";
 import type { TargetWorkflowFinalizationResult } from "@harness/setup/target-workflow-finalization-types";
-import { WORKFLOW_INSTALL_SHORT_POLL_INTERVAL_MS } from "@harness/setup/target-workflow-finalization-types";
+import {
+  WORKFLOW_INSTALL_BASE_RETRY_MS,
+  WORKFLOW_INSTALL_MAX_RETRY_MS,
+  WORKFLOW_INSTALL_MAX_TRANSIENT_RETRIES,
+  WORKFLOW_INSTALL_SHORT_POLL_INTERVAL_MS,
+} from "@harness/setup/target-workflow-finalization-types";
 
 import { SPACING } from "@/lib/constants";
 import { GUIDED_SETUP_STEP_COUNT } from "@/lib/guided-setup";
@@ -21,6 +26,8 @@ interface GuidedTargetWorkflowCardProps {
   onSummaryUpdated?: (summary: RemoteSetupSummary) => void;
   onWorkflowSetupComplete?: () => void;
   onWorkflowAwaitingMergeChange?: (awaiting: boolean) => void;
+  onStepCompleted?: () => void;
+  onContinue?: () => void;
   pendingInstallByRepo?: Record<string, RemoteTargetWorkflowApplyResult>;
   finalizationByRepo?: Record<string, TargetWorkflowFinalizationResult>;
   onPendingInstallChange?: (
@@ -52,6 +59,8 @@ function allTargetWorkflowsReady(summary: RemoteSetupSummary): boolean {
   );
 }
 
+export { allTargetWorkflowsReady };
+
 function isPendingInstallResult(
   result: RemoteTargetWorkflowApplyResult,
 ): boolean {
@@ -62,35 +71,106 @@ function isPendingInstallResult(
   );
 }
 
-function shouldContinuePolling(
+function isTerminalFinalization(
   finalization: TargetWorkflowFinalizationResult | undefined,
 ): boolean {
   if (!finalization) {
     return false;
   }
   if (finalization.lifecycle === "complete") {
+    return true;
+  }
+  return finalization.lifecycle === "blocked" && !finalization.retryable;
+}
+
+function shouldContinuePolling(
+  finalization: TargetWorkflowFinalizationResult | undefined,
+): boolean {
+  if (!finalization) {
     return false;
   }
-  if (finalization.lifecycle === "blocked" && !finalization.canRetry) {
+  if (isTerminalFinalization(finalization)) {
     return false;
   }
   return true;
 }
 
-function isTerminalFinalization(
-  finalization: TargetWorkflowFinalizationResult | undefined,
+function isRecoveringInstallBranch(
+  finalization: TargetWorkflowFinalizationResult,
 ): boolean {
   return (
-    finalization?.lifecycle === "complete" ||
-    (finalization?.lifecycle === "blocked" && !finalization.canRetry)
+    finalization.lifecycle === "updating-branch" &&
+    finalization.message.includes("Refreshing")
   );
 }
 
+function isNewerFinalization(
+  existing: TargetWorkflowFinalizationResult | undefined,
+  incoming: TargetWorkflowFinalizationResult,
+): boolean {
+  if (!existing) {
+    return true;
+  }
+  if (isTerminalFinalization(existing) && !isTerminalFinalization(incoming)) {
+    return false;
+  }
+  if (
+    existing.validatedHeadSha &&
+    incoming.validatedHeadSha &&
+    existing.validatedHeadSha !== incoming.validatedHeadSha
+  ) {
+    return incoming.advancedThisRequest;
+  }
+  if (isRecoveringInstallBranch(incoming)) {
+    return true;
+  }
+  return incoming.advancedThisRequest || !existing.lockContended;
+}
+
+function backoffDelayMs(failureCount: number, retryAfterMs?: number): number {
+  const base = retryAfterMs ?? WORKFLOW_INSTALL_BASE_RETRY_MS;
+  const exponential = Math.min(
+    WORKFLOW_INSTALL_MAX_RETRY_MS,
+    base * 2 ** Math.max(0, failureCount - 1),
+  );
+  const jitter = Math.floor(Math.random() * WORKFLOW_INSTALL_BASE_RETRY_MS);
+  return Math.min(WORKFLOW_INSTALL_MAX_RETRY_MS, exponential + jitter);
+}
+
+function createPreparingFinalization(
+  repo: RemoteSetupSummary["targetRepos"][number],
+  pending: RemoteTargetWorkflowApplyResult,
+): TargetWorkflowFinalizationResult {
+  return {
+    repoConfigId: repo.repoConfigId,
+    targetRepo: repo.targetRepo,
+    targetRepoSlug: repo.targetRepo,
+    productionBranch: repo.productionBranch,
+    branchName: pending.branchName,
+    lifecycle: "preparing",
+    phase: "preparing-workflow-installation",
+    operationId: crypto.randomUUID(),
+    message: "Starting automatic workflow install finalization.",
+    workflowStatus: repo.workflowStatus,
+    canRetry: true,
+    retryable: true,
+    retryAfterMs: WORKFLOW_INSTALL_SHORT_POLL_INTERVAL_MS,
+    lastSafeCheckpoint: "preparing",
+    errorCode: "none",
+    requiresGitHubIntervention: false,
+    advancedThisRequest: false,
+    lockContended: false,
+    updatedAt: new Date().toISOString(),
+  };
+}
+
 export function GuidedTargetWorkflowCard({
   initialSummary,
   onSummaryUpdated,
   onWorkflowSetupComplete,
   onWorkflowAwaitingMergeChange,
+  onStepCompleted,
+  onContinue,
   pendingInstallByRepo = {},
   finalizationByRepo = {},
   onPendingInstallChange,
@@ -101,7 +181,23 @@ export function GuidedTargetWorkflowCard({
   const [localFinalizationByRepo, setLocalFinalizationByRepo] = useState(
     finalizationByRepo,
   );
+  const [transientByRepo, setTransientByRepo] = useState<
+    Record<string, string | null>
+  >({});
+  const [hideApplyByRepo, setHideApplyByRepo] = useState<Record<string, boolean>>(
+    {},
+  );
   const pollGenerationRef = useRef(0);
+  const failureCountRef = useRef<Record<string, number>>({});
+  const mountedRef = useRef(true);
+
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+      pollGenerationRef.current += 1;
+    };
+  }, []);
 
   useEffect(() => {
     setSummary(initialSummary);
@@ -132,6 +228,7 @@ export function GuidedTargetWorkflowCard({
         return;
       }
 
+      const existing = localFinalizationByRepo[repoConfigId];
       const response = await fetch("/api/setup/finalize-target-workflow", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
@@ -139,25 +236,34 @@ export function GuidedTargetWorkflowCard({
           repoConfigId: repo.repoConfigId,
           targetRepo: repo.targetRepo,
           productionBranch: repo.productionBranch,
-          prUrl: apply?.prUrl,
-          branchName: apply?.branchName,
+          prUrl: apply?.prUrl ?? existing?.prUrl,
+          branchName: apply?.branchName ?? existing?.branchName,
+          operationId: existing?.operationId,
         }),
       });
       const data = await response.json();
       if (!response.ok) {
-        throw new Error(data.error ?? "Workflow finalization failed");
+        const error = new Error(data.error ?? "Workflow finalization failed") as Error & {
+          retryable?: boolean;
+          retryAfterMs?: number;
+          errorCode?: string;
+        };
+        error.retryable = data.retryable === true;
+        error.retryAfterMs = typeof data.retryAfterMs === "number" ? data.retryAfterMs : undefined;
+        error.errorCode = typeof data.errorCode === "string" ? data.errorCode : undefined;
+        throw error;
       }
 
       const finalization = data.finalization as TargetWorkflowFinalizationResult;
       const nextSummary = data.summary as RemoteSetupSummary;
 
+      if (!mountedRef.current) {
+        return finalization;
+      }
+
       setLocalFinalizationByRepo((previous) => {
-        const existing = previous[repoConfigId];
-        if (
-          existing &&
-          isTerminalFinalization(existing) &&
-          !isTerminalFinalization(finalization)
-        ) {
+        const current = previous[repoConfigId];
+        if (!isNewerFinalization(current, finalization)) {
           return previous;
         }
         const next = { ...previous, [repoConfigId]: finalization };
@@ -172,22 +278,17 @@ export function GuidedTargetWorkflowCard({
         const nextPending = { ...pendingInstallByRepo };
         delete nextPending[repoConfigId];
         onPendingInstallChange?.(nextPending);
-      }
-
-      if (allTargetWorkflowsReady(nextSummary)) {
-        onPendingInstallChange?.({});
-        onWorkflowAwaitingMergeChange?.(false);
-        onWorkflowSetupComplete?.();
+        onStepCompleted?.();
       }
 
       return finalization;
     },
     [
+      localFinalizationByRepo,
       onFinalizationChange,
       onPendingInstallChange,
+      onStepCompleted,
       onSummaryUpdated,
-      onWorkflowAwaitingMergeChange,
-      onWorkflowSetupComplete,
       pendingInstallByRepo,
       summary.targetRepos,
     ],
@@ -197,34 +298,87 @@ export function GuidedTargetWorkflowCard({
     (repoConfigId: string, apply?: RemoteTargetWorkflowApplyResult) => {
       const generation = pollGenerationRef.current + 1;
       pollGenerationRef.current = generation;
+      failureCountRef.current[repoConfigId] = 0;
 
       const poll = async () => {
         while (pollGenerationRef.current === generation) {
           try {
             const finalization = await finalizeRepo(repoConfigId, apply);
+            if (!mountedRef.current || pollGenerationRef.current !== generation) {
+              break;
+            }
+            if (finalization?.lockContended) {
+              setTransientByRepo((prev) => ({ ...prev, [repoConfigId]: null }));
+              await new Promise((resolve) =>
+                setTimeout(
+                  resolve,
+                  finalization.retryAfterMs ?? WORKFLOW_INSTALL_SHORT_POLL_INTERVAL_MS,
+                ),
+              );
+              continue;
+            }
+            failureCountRef.current[repoConfigId] = 0;
+            setTransientByRepo((prev) => ({ ...prev, [repoConfigId]: null }));
             if (!shouldContinuePolling(finalization)) {
               break;
             }
-          } catch {
-            break;
+            await new Promise((resolve) =>
+              setTimeout(
+                resolve,
+                finalization?.retryAfterMs ?? WORKFLOW_INSTALL_SHORT_POLL_INTERVAL_MS,
+              ),
+            );
+          } catch (error) {
+            if (!mountedRef.current || pollGenerationRef.current !== generation) {
+              break;
+            }
+            const typed = error as Error & {
+              retryable?: boolean;
+              retryAfterMs?: number;
+            };
+            const failures = (failureCountRef.current[repoConfigId] ?? 0) + 1;
+            failureCountRef.current[repoConfigId] = failures;
+            const retryable = typed.retryable !== false;
+            if (!retryable || failures > WORKFLOW_INSTALL_MAX_TRANSIENT_RETRIES) {
+              setLocalFinalizationByRepo((previous) => {
+                const existing = previous[repoConfigId];
+                if (!existing) {
+                  return previous;
+                }
+                const terminal: TargetWorkflowFinalizationResult = {
+                  ...existing,
+                  lifecycle: "blocked",
+                  retryable: false,
+                  canRetry: true,
+                  errorCode: "retry_budget_exhausted",
+                  message:
+                    existing.message ||
+                    "Workflow install polling stopped after repeated refresh failures.",
+                  updatedAt: new Date().toISOString(),
+                };
+                const next = { ...previous, [repoConfigId]: terminal };
+                onFinalizationChange?.(next);
+                return next;
+              });
+              setTransientByRepo((prev) => ({ ...prev, [repoConfigId]: null }));
+              break;
+            }
+            setTransientByRepo((prev) => ({
+              ...prev,
+              [repoConfigId]: "Temporarily unable to refresh GitHub status.",
+            }));
+            await new Promise((resolve) =>
+              setTimeout(resolve, backoffDelayMs(failures, typed.retryAfterMs)),
+            );
           }
-          await new Promise((resolve) =>
-            setTimeout(resolve, WORKFLOW_INSTALL_SHORT_POLL_INTERVAL_MS),
-          );
         }
       };
 
       void poll();
     },
-    [finalizeRepo],
+    [finalizeRepo, onFinalizationChange],
   );
 
-  useEffect(() => {
-    if (allTargetWorkflowsReady(summary)) {
-      onWorkflowSetupComplete?.();
-    }
-  }, [onWorkflowSetupComplete, summary]);
-
   useEffect(() => {
     const awaiting = Object.entries(localFinalizationByRepo).some(([, state]) =>
       shouldContinuePolling(state),
@@ -253,12 +407,14 @@ export function GuidedTargetWorkflowCard({
       result: RemoteTargetWorkflowApplyResult,
       initialFinalization?: TargetWorkflowFinalizationResult,
     ) => {
+      setHideApplyByRepo((prev) => ({ ...prev, [repoConfigId]: true }));
       let nextPending = { ...pendingInstallByRepo };
 
       if (result.outcome === "already-installed") {
         delete nextPending[repoConfigId];
         onPendingInstallChange?.(nextPending);
         await refreshSummary();
+        onStepCompleted?.();
         return;
       }
 
@@ -285,6 +441,7 @@ export function GuidedTargetWorkflowCard({
       localFinalizationByRepo,
       onFinalizationChange,
       onPendingInstallChange,
+      onStepCompleted,
       pendingInstallByRepo,
       refreshSummary,
       startPolling,
@@ -294,13 +451,48 @@ export function GuidedTargetWorkflowCard({
   const awaitingFinalization = Object.values(localFinalizationByRepo).some(
     (state) => shouldContinuePolling(state),
   );
+  const allComplete =
+    allTargetWorkflowsReady(summary) ||
+    (summary.targetRepos.length > 0 &&
+      summary.targetRepos.every((repo) => {
+        const finalization = localFinalizationByRepo[repo.repoConfigId];
+        return (
+          repo.workflowStatus === "present" ||
+          finalization?.lifecycle === "complete"
+        );
+      }));
+
+  const handleContinueWhenAllComplete = useCallback(async () => {
+    if (!allComplete) {
+      return;
+    }
+
+    let authoritativeSummary: RemoteSetupSummary;
+    try {
+      authoritativeSummary = await refreshSummary();
+    } catch {
+      return;
+    }
+
+    if (!allTargetWorkflowsReady(authoritativeSummary)) {
+      return;
+    }
+
+    onWorkflowSetupComplete?.();
+    onContinue?.();
+  }, [
+    allComplete,
+    onContinue,
+    onWorkflowSetupComplete,
+    refreshSummary,
+  ]);
 
   return (
     <SectionCard
       title={`Step 7 of ${GUIDED_SETUP_STEP_COUNT} · Install target repo workflow`}
       description={
         awaitingFinalization
-          ? "Installing the harness workflow automatically. Setup will continue when production verification succeeds."
+          ? "Installing the harness workflow. Continue when production verification succeeds."
           : "The harness will create or reuse a workflow install PR, merge it automatically when GitHub permits, and verify the production workflow."
       }
     >
@@ -319,7 +511,13 @@ export function GuidedTargetWorkflowCard({
             {summary.targetRepos.map((repo) => {
               const pending = pendingInstallByRepo[repo.repoConfigId];
               const finalization = localFinalizationByRepo[repo.repoConfigId];
-              const workflowReady = repo.workflowStatus === "present";
+              const workflowReady =
+                repo.workflowStatus === "present" ||
+                finalization?.lifecycle === "complete";
+              const hideApply =
+                hideApplyByRepo[repo.repoConfigId] ||
+                Boolean(finalization) ||
+                Boolean(pending && isPendingInstallResult(pending));
 
               return (
                 <div
@@ -337,48 +535,57 @@ export function GuidedTargetWorkflowCard({
                   </div>
 
                   {workflowReady ? (
-                    <WorkflowInstallReadyPanel repoConfigId={repo.repoConfigId} />
+                    <WorkflowInstallReadyPanel
+                      repoConfigId={repo.repoConfigId}
+                      onContinue={
+                        allComplete
+                          ? () => {
+                              void handleContinueWhenAllComplete();
+                            }
+                          : undefined
+                      }
+                    />
                   ) : finalization ? (
                     <WorkflowInstallProgressPanel
+                      variant="guided"
                       finalization={finalization}
+                      transientMessage={transientByRepo[repo.repoConfigId]}
+                      onContinue={
+                        allComplete && finalization.lifecycle === "complete"
+                          ? () => {
+                              void handleContinueWhenAllComplete();
+                            }
+                          : undefined
+                      }
                       onRetry={
-                        finalization.canRetry
-                          ? () => void finalizeRepo(repo.repoConfigId, pending)
+                        finalization.canRetry || finalization.retryable
+                          ? () => {
+                              failureCountRef.current[repo.repoConfigId] = 0;
+                              startPolling(repo.repoConfigId, pending);
+                            }
                           : undefined
                       }
                     />
                   ) : pending && isPendingInstallResult(pending) ? (
                     <WorkflowInstallProgressPanel
-                      finalization={{
-                        repoConfigId: repo.repoConfigId,
-                        targetRepo: repo.targetRepo,
-                        targetRepoSlug: repo.targetRepo,
-                        productionBranch: repo.productionBranch,
-                        branchName: pending.branchName,
-                        lifecycle: "preparing",
-                        message: "Starting automatic workflow install finalization.",
-                        workflowStatus: repo.workflowStatus,
-                        canRetry: false,
-                        requiresGitHubIntervention: false,
-                        advancedThisRequest: false,
-                        lockContended: false,
-                      }}
+                      variant="guided"
+                      finalization={createPreparingFinalization(repo, pending)}
                     />
-                  ) : (
+                  ) : hideApply ? null : (
                     <>
                       <p className="text-sm text-muted-foreground">
-                        Preview and confirm to create or update the workflow install
-                        PR. Finalization runs automatically after apply.
+                        Confirm to create or update the workflow install PR.
+                        Preview is optional. Finalization runs automatically after apply.
                       </p>
                       <TargetWorkflowPrCard
                         repo={repo}
                         variant="guided"
                         onApplied={() => undefined}
-                        onGuidedApplySuccess={(result, finalization) =>
+                        onGuidedApplySuccess={(result, nextFinalization) =>
                           void handleGuidedApplySuccess(
                             repo.repoConfigId,
                             result,
-                            finalization,
+                            nextFinalization,
                           )
                         }
                         blockedByUpstream={blockedByUpstream}