p-dev-harness 0.3.1 → 0.4.0

package/workspace-snapshot/files/apps/gui/lib/use-theme-toggle.ts

@@ -0,0 +1,26 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { useTheme } from "next-themes";
+
+export function useThemeToggle() {
+  const { resolvedTheme, setTheme } = useTheme();
+  const [mounted, setMounted] = useState(false);
+
+  useEffect(() => {
+    setMounted(true);
+  }, []);
+
+  const isDark = resolvedTheme === "dark";
+
+  function toggleTheme() {
+    setTheme(isDark ? "light" : "dark");
+  }
+
+  return {
+    mounted,
+    isDark,
+    toggleTheme,
+    setTheme,
+  };
+}

package/workspace-snapshot/files/apps/gui/lib/vercel-bridge-polling-ui.ts

@@ -1,8 +1,17 @@
+import type { VercelBridgeOrchestrationPhase } from "@harness/setup/control-plane-types";
+import type { VercelBridgeApplyResult } from "@harness/setup/vercel-setup-apply";
+import type { VercelBridgeOrchestrationSummary } from "@harness/setup/vercel-setup-summary";
+
 export function isRedeployPollingActive(input: {
   setupPending: boolean;
   pollActionId?: string | null;
+  orchestration?: Pick<VercelBridgeOrchestrationSummary, "active">;
 }): boolean {
-  return input.setupPending || Boolean(input.pollActionId);
+  return (
+    input.setupPending ||
+    Boolean(input.pollActionId) ||
+    Boolean(input.orchestration?.active)
+  );
 }
 
 export function canInvalidatePreviewDuringPolling(
@@ -14,3 +23,81 @@ export function canInvalidatePreviewDuringPolling(
 
 export const REDEPLOY_POLLING_LOCK_MESSAGE =
   "Vercel production redeploy is in progress. Wait for verification to finish before changing settings.";
+
+export const INITIAL_APPLY_STATUS_MESSAGE = "Applying Vercel settings…";
+
+export function resolveOrchestrationStatusMessage(input: {
+  loading: "preview" | "apply" | "poll" | "refresh" | null;
+  applyResult?: VercelBridgeApplyResult | null;
+  orchestration?: VercelBridgeOrchestrationSummary;
+}): string | undefined {
+  if (input.loading === "apply") {
+    return INITIAL_APPLY_STATUS_MESSAGE;
+  }
+
+  if (input.applyResult?.orchestrationStatusMessage) {
+    return input.applyResult.orchestrationStatusMessage;
+  }
+
+  if (input.orchestration?.active) {
+    return input.orchestration.statusMessage;
+  }
+
+  return undefined;
+}
+
+export function shouldShowTerminalApplyResult(input: {
+  applyResult?: VercelBridgeApplyResult | null;
+  orchestration?: VercelBridgeOrchestrationSummary;
+  redeployPollingActive: boolean;
+}): boolean {
+  if (!input.applyResult) {
+    return false;
+  }
+  if (input.redeployPollingActive) {
+    return false;
+  }
+  if (input.orchestration?.active) {
+    return false;
+  }
+  if (input.applyResult.setupPending) {
+    return false;
+  }
+  return Boolean(
+    input.applyResult.setupBlocked ||
+      input.orchestration?.terminal ||
+      (input.applyResult.verified && input.applyResult.signedProbeVerified),
+  );
+}
+
+export function shouldHideApplyButton(input: {
+  verifiedSuccess: boolean;
+  redeployPollingActive: boolean;
+}): boolean {
+  return input.verifiedSuccess || input.redeployPollingActive;
+}
+
+export function mapOrchestrationPhaseLabel(
+  phase?: VercelBridgeOrchestrationPhase,
+): string | undefined {
+  if (!phase) {
+    return undefined;
+  }
+  switch (phase) {
+    case "triggered":
+      return "Redeploying production";
+    case "building":
+    case "waiting_for_ready":
+      return "Waiting for deployment";
+    case "verifying":
+      return "Verifying webhook";
+    case "retry_wait":
+      return "Retrying verification";
+    case "verified":
+      return "Verified";
+    case "terminal":
+      return "Action required";
+    default:
+      return undefined;
+  }
+}

package/workspace-snapshot/files/apps/gui/lib/verification-state.ts

@@ -1,5 +1,69 @@
-import type { ServiceVerificationUi } from "@/components/custom/environment-config-form";
+import {
+  INITIAL_SERVICE_VERIFICATION,
+  type ServiceKey,
+  type ServiceVerificationMap,
+  type ServiceVerificationUi,
+} from "@/components/custom/environment-config-form";
 import type { RepoVerificationUi } from "@/components/custom/target-repo-config-form";
+import type { ServiceConnectionSummaryMap } from "@/lib/setup-server";
+
+const SERVICE_KEYS: ServiceKey[] = [
+  "LINEAR_API_KEY",
+  "CURSOR_API_KEY",
+  "GITHUB_TOKEN",
+  "VERCEL_TOKEN",
+];
+
+export function serviceVerificationFromSummaries(
+  summaries: ServiceConnectionSummaryMap,
+): ServiceVerificationMap {
+  return SERVICE_KEYS.reduce(
+    (next, key) => {
+      const summary = summaries[key];
+      if (summary.status === "connected") {
+        next[key] = {
+          state: "connected",
+          message: summary.message,
+          limitation: summary.limitation,
+          label: summary.label,
+        };
+      } else if (summary.status === "failed") {
+        next[key] = {
+          state: "failed",
+          message: summary.message,
+          limitation: summary.limitation,
+          label: summary.label,
+        };
+      } else {
+        next[key] = {
+          state: "unchecked",
+          message: summary.message,
+          limitation: summary.limitation,
+          label: summary.label,
+        };
+      }
+      return next;
+    },
+    { ...INITIAL_SERVICE_VERIFICATION },
+  );
+}
+
+/** Presence-only summaries for Settings — no live remote verify on mount. */
+export function loadDurableServiceConnectionSummaries(
+  presence: Record<ServiceKey, boolean>,
+): ServiceConnectionSummaryMap {
+  return Object.fromEntries(
+    SERVICE_KEYS.map((key) => [
+      key,
+      presence[key]
+        ? {
+            status: "connected" as const,
+            message: "Saved credential configured.",
+          }
+        : { status: "missing" as const },
+    ]),
+  ) as ServiceConnectionSummaryMap;
+}
 
 /** Non-secret in-memory fingerprint for comparing typed secret values. */
 export function valueFingerprint(value: string): string {
@@ -38,6 +102,38 @@ export function isServiceFailedForValue(
   return verification.attemptedValueFingerprint === valueFingerprint(value);
 }
 
+export function resolveServiceConnectionBadgeState(
+  present: boolean,
+  verification: ServiceVerificationUi,
+  value: string,
+): ServiceVerificationUi["state"] {
+  if (verification.state === "checking") {
+    return "checking";
+  }
+
+  const trimmedValue = value.trim();
+
+  if (verification.state === "connected") {
+    if (trimmedValue) {
+      return isServiceVerifiedForValue(verification, trimmedValue)
+        ? "connected"
+        : "unchecked";
+    }
+    return present ? "connected" : "unchecked";
+  }
+
+  if (verification.state === "failed") {
+    if (trimmedValue) {
+      return isServiceFailedForValue(verification, trimmedValue)
+        ? "failed"
+        : "unchecked";
+    }
+    return present ? "failed" : "unchecked";
+  }
+
+  return "unchecked";
+}
+
 export function isRepoVerifiedForUrl(
   verification: RepoVerificationUi | undefined,
   targetRepo: string,

package/workspace-snapshot/files/apps/gui/lib/workflow/api-client.ts

@@ -0,0 +1,84 @@
+import type { WorkflowBootstrapPayload } from "@harness/workflow-page/types";
+
+function buildQuery(input?: {
+  sourceMode?: string;
+  fixtureId?: string;
+  scopeId?: string;
+}): string {
+  const params = new URLSearchParams();
+  if (input?.sourceMode === "fixture" && input.fixtureId) {
+    params.set("source", "fixture");
+    params.set("fixture", input.fixtureId);
+  }
+  if (input?.scopeId) {
+    params.set("scope", input.scopeId);
+  }
+  const query = params.toString();
+  return query ? `?${query}` : "";
+}
+
+export async function fetchWorkflowBootstrap(input?: {
+  sourceMode?: string;
+  fixtureId?: string;
+  scopeId?: string;
+  signal?: AbortSignal;
+}): Promise<WorkflowBootstrapPayload> {
+  const response = await fetch(`/api/workflow/bootstrap${buildQuery(input)}`, {
+    signal: input?.signal,
+  });
+  if (!response.ok) {
+    throw new Error("Failed to load Workflow bootstrap data.");
+  }
+  return (await response.json()) as WorkflowBootstrapPayload;
+}
+
+export async function saveWorkflowModel(input: {
+  role: "planner" | "builder";
+  modelId: string;
+  params: Array<{ id: string; value: string }>;
+  expectedConfigFingerprint: string;
+  sourceMode?: string;
+  fixtureId?: string;
+  scopeId?: string;
+  sequenceId?: number;
+}): Promise<{
+  configFingerprint: string;
+  savedAt: string;
+  sequenceId?: number;
+}> {
+  const response = await fetch(
+    `/api/workflow/models${buildQuery(input)}`,
+    {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        role: input.role,
+        modelId: input.modelId,
+        params: input.params,
+        expectedConfigFingerprint: input.expectedConfigFingerprint,
+        sourceMode: input.sourceMode,
+        fixtureId: input.fixtureId,
+        scopeId: input.scopeId,
+      }),
+    },
+  );
+  const payload = (await response.json()) as {
+    saved?: boolean;
+    configFingerprint?: string;
+    savedAt?: string;
+    error?: string;
+    code?: string;
+  };
+  if (!response.ok || !payload.saved || !payload.configFingerprint) {
+    const error = new Error(payload.error ?? "Couldn't save model settings.") as Error & {
+      code?: string;
+    };
+    error.code = payload.code;
+    throw error;
+  }
+  return {
+    configFingerprint: payload.configFingerprint,
+    savedAt: payload.savedAt ?? new Date().toISOString(),
+    sequenceId: input.sequenceId,
+  };
+}

package/workspace-snapshot/files/apps/gui/lib/workflow/use-model-autosave.ts

@@ -0,0 +1,90 @@
+"use client";
+
+import { useCallback } from "react";
+import type { RoleModelRole } from "@harness/config/role-models";
+import type {
+  WorkflowBootstrapPayload,
+  WorkflowModelCatalogEntry,
+  WorkflowModelSelection,
+} from "@harness/workflow-page/types";
+import {
+  useWorkflowModelSave,
+  type WorkflowModelPhaseKey,
+} from "@/lib/workflow/use-workflow-model-save";
+
+export type { WorkflowModelPhaseKey, ModelSaveState } from "@/lib/workflow/use-workflow-model-save";
+
+export function resolveModelDisplayName(
+  modelCatalog: WorkflowModelCatalogEntry[],
+  modelId: string | undefined,
+): string {
+  if (!modelId) {
+    return "Unknown model";
+  }
+  return (
+    modelCatalog.find((model) => model.id === modelId)?.displayName ?? modelId
+  );
+}
+
+type UseModelAutosaveOptions = {
+  bootstrap: WorkflowBootstrapPayload;
+  committedSelections: Record<RoleModelRole, WorkflowModelSelection>;
+  onCommittedSelectionsChange: (
+    role: RoleModelRole,
+    selection: WorkflowModelSelection,
+  ) => void;
+  onBootstrapFingerprintChange: (fingerprint: string) => void;
+};
+
+export function useModelAutosave({
+  bootstrap,
+  committedSelections,
+  onCommittedSelectionsChange,
+  onBootstrapFingerprintChange,
+}: UseModelAutosaveOptions) {
+  const {
+    optimisticSelections,
+    saveErrors,
+    handleModelSelect: selectModel,
+    handleModelParameter: updateParameter,
+    retrySave,
+    saveStateLabel,
+  } = useWorkflowModelSave({
+    context: {
+      sourceMode: bootstrap.sourceMode,
+      fixtureId: bootstrap.fixtureId,
+      selectedScopeId: bootstrap.selectedScopeId,
+      configFingerprint: bootstrap.configFingerprint,
+    },
+    committedSelections,
+    onCommittedSelectionChange: onCommittedSelectionsChange,
+    onFingerprintChange: onBootstrapFingerprintChange,
+  });
+
+  const handleModelSelect = useCallback(
+    (phaseKey: WorkflowModelPhaseKey, modelId: string) => {
+      selectModel(phaseKey, modelId, bootstrap.modelCatalog);
+    },
+    [bootstrap.modelCatalog, selectModel],
+  );
+
+  const handleModelParameter = useCallback(
+    (phaseKey: WorkflowModelPhaseKey, parameterId: string, value: string) => {
+      updateParameter(phaseKey, parameterId, value);
+    },
+    [updateParameter],
+  );
+
+  const saveErrorDetail = (phaseKey: WorkflowModelPhaseKey): string | undefined =>
+    saveErrors[phaseKey]?.message;
+
+  return {
+    plannerSelection: optimisticSelections.planner,
+    builderSelection: optimisticSelections.builder,
+    handleModelSelect,
+    handleModelParameter,
+    retrySave,
+    saveStateLabel,
+    saveErrorDetail,
+  };
+}

package/workspace-snapshot/files/apps/gui/lib/workflow/use-workflow-model-save.ts

@@ -0,0 +1,265 @@
+"use client";
+
+import { useCallback, useRef, useState } from "react";
+import type { RoleModelRole } from "@harness/config/role-models";
+import type { WorkflowModelSelection } from "@harness/workflow-page/types";
+import { saveWorkflowModel } from "@/lib/workflow/api-client";
+
+export type WorkflowModelPhaseKey = "planning" | "implementation";
+
+export type ModelSaveState = "idle" | "saving" | "saved" | "error";
+
+export type ModelSaveError = {
+  code?: string;
+  message: string;
+};
+
+const AUTOSAVE_DELAY_MS = 400;
+
+function phaseToRole(phaseKey: WorkflowModelPhaseKey): RoleModelRole {
+  return phaseKey === "planning" ? "planner" : "builder";
+}
+
+export type WorkflowModelSaveContext = {
+  sourceMode: "live" | "fixture";
+  fixtureId?: string;
+  selectedScopeId?: string;
+  configFingerprint: string;
+};
+
+export type UseWorkflowModelSaveOptions = {
+  context: WorkflowModelSaveContext;
+  committedSelections: Record<RoleModelRole, WorkflowModelSelection>;
+  onCommittedSelectionChange: (
+    role: RoleModelRole,
+    selection: WorkflowModelSelection,
+  ) => void;
+  onFingerprintChange: (fingerprint: string) => void;
+};
+
+export function useWorkflowModelSave({
+  context,
+  committedSelections,
+  onCommittedSelectionChange,
+  onFingerprintChange,
+}: UseWorkflowModelSaveOptions) {
+  const [optimisticSelections, setOptimisticSelections] = useState(
+    committedSelections,
+  );
+  const [saveState, setSaveState] = useState<
+    Record<WorkflowModelPhaseKey, ModelSaveState>
+  >({
+    planning: "idle",
+    implementation: "idle",
+  });
+  const [saveErrors, setSaveErrors] = useState<
+    Partial<Record<WorkflowModelPhaseKey, ModelSaveError>>
+  >({});
+  const timersRef = useRef<
+    Partial<Record<WorkflowModelPhaseKey, ReturnType<typeof setTimeout>>>
+  >({});
+  const fingerprintRef = useRef(context.configFingerprint);
+  const generationRef = useRef<Record<WorkflowModelPhaseKey, number>>({
+    planning: 0,
+    implementation: 0,
+  });
+
+  fingerprintRef.current = context.configFingerprint;
+
+  const revertToCommitted = useCallback(
+    (phaseKey: WorkflowModelPhaseKey) => {
+      const role = phaseToRole(phaseKey);
+      const committed = committedSelections[role];
+      setOptimisticSelections((current) => ({
+        ...current,
+        [role]: committed,
+      }));
+    },
+    [committedSelections],
+  );
+
+  const runSave = useCallback(
+  async (
+    phaseKey: WorkflowModelPhaseKey,
+    selection: WorkflowModelSelection,
+    generation: number,
+  ) => {
+    const role = phaseToRole(phaseKey);
+    try {
+      const result = await saveWorkflowModel({
+        role,
+        modelId: selection.modelId,
+        params: selection.parameters,
+        expectedConfigFingerprint: fingerprintRef.current,
+        sourceMode: context.sourceMode,
+        fixtureId: context.fixtureId,
+        scopeId: context.selectedScopeId,
+        sequenceId: generation,
+      });
+      if (generation !== generationRef.current[phaseKey]) {
+        return;
+      }
+      fingerprintRef.current = result.configFingerprint;
+      onFingerprintChange(result.configFingerprint);
+      onCommittedSelectionChange(role, selection);
+      setSaveState((current) => ({ ...current, [phaseKey]: "saved" }));
+      setSaveErrors((current) => {
+        const next = { ...current };
+        delete next[phaseKey];
+        return next;
+      });
+    } catch (error) {
+      if (generation !== generationRef.current[phaseKey]) {
+        return;
+      }
+      revertToCommitted(phaseKey);
+      setSaveState((current) => ({ ...current, [phaseKey]: "error" }));
+      const response =
+        error instanceof Error && "code" in error
+          ? (error as Error & { code?: string })
+          : error;
+      setSaveErrors((current) => ({
+        ...current,
+        [phaseKey]: {
+          code:
+            typeof response === "object" &&
+            response &&
+            "code" in response &&
+            typeof response.code === "string"
+              ? response.code
+              : undefined,
+          message:
+            error instanceof Error
+              ? error.message
+              : "Couldn't save model settings.",
+        },
+      }));
+    }
+  },
+  [
+    context.fixtureId,
+    context.selectedScopeId,
+    context.sourceMode,
+    onCommittedSelectionChange,
+    onFingerprintChange,
+    revertToCommitted,
+  ],
+  );
+
+  const scheduleSave = useCallback(
+    (phaseKey: WorkflowModelPhaseKey, selection: WorkflowModelSelection) => {
+      const existingTimer = timersRef.current[phaseKey];
+      if (existingTimer) {
+        clearTimeout(existingTimer);
+      }
+
+      setSaveState((current) => ({ ...current, [phaseKey]: "saving" }));
+      setSaveErrors((current) => {
+        const next = { ...current };
+        delete next[phaseKey];
+        return next;
+      });
+
+      timersRef.current[phaseKey] = setTimeout(() => {
+        const generation = generationRef.current[phaseKey] + 1;
+        generationRef.current[phaseKey] = generation;
+        void runSave(phaseKey, selection, generation);
+      }, AUTOSAVE_DELAY_MS);
+    },
+    [runSave],
+  );
+
+  const retrySave = useCallback(
+    (phaseKey: WorkflowModelPhaseKey) => {
+      const role = phaseToRole(phaseKey);
+      const selection = optimisticSelections[role];
+      scheduleSave(phaseKey, selection);
+    },
+    [optimisticSelections, scheduleSave],
+  );
+
+  const handleModelSelect = useCallback(
+    (
+      phaseKey: WorkflowModelPhaseKey,
+      modelId: string,
+      modelCatalog: Array<{
+        id: string;
+        supportedParameters: Array<{
+          id: string;
+          type: string;
+          defaultValue?: string;
+        }>;
+      }>,
+    ) => {
+      const role = phaseToRole(phaseKey);
+      const model = modelCatalog.find((entry) => entry.id === modelId);
+      const defaultParams =
+        model?.supportedParameters
+          .filter((parameter) => parameter.type === "boolean")
+          .map((parameter) => ({
+            id: parameter.id,
+            value: parameter.defaultValue ?? "false",
+          })) ?? [];
+      const nextSelection: WorkflowModelSelection = {
+        modelId,
+        displayName: model?.id ?? modelId,
+        parameters: defaultParams,
+        source: "roleModels",
+      };
+      setOptimisticSelections((current) => ({ ...current, [role]: nextSelection }));
+      scheduleSave(phaseKey, nextSelection);
+    },
+    [scheduleSave],
+  );
+
+  const handleModelParameter = useCallback(
+    (phaseKey: WorkflowModelPhaseKey, parameterId: string, value: string) => {
+      const role = phaseToRole(phaseKey);
+      const current = optimisticSelections[role];
+      const nextSelection: WorkflowModelSelection = {
+        ...current,
+        parameters: [
+          ...current.parameters.filter((entry) => entry.id !== parameterId),
+          { id: parameterId, value },
+        ],
+      };
+      setOptimisticSelections((currentState) => ({
+        ...currentState,
+        [role]: nextSelection,
+      }));
+      scheduleSave(phaseKey, nextSelection);
+    },
+    [optimisticSelections, scheduleSave],
+  );
+
+  const syncCommittedSelections = useCallback(
+    (nextCommitted: Record<RoleModelRole, WorkflowModelSelection>) => {
+      setOptimisticSelections(nextCommitted);
+    },
+    [],
+  );
+
+  const saveStateLabel = (phaseKey: WorkflowModelPhaseKey): string | null => {
+    switch (saveState[phaseKey]) {
+      case "saving":
+        return "Saving…";
+      case "saved":
+        return "Saved";
+      case "error":
+        return "Couldn't save. Your previous model is still active.";
+      default:
+        return null;
+    }
+  };
+
+  return {
+    optimisticSelections,
+    saveState,
+    saveErrors,
+    handleModelSelect,
+    handleModelParameter,
+    retrySave,
+    saveStateLabel,
+    syncCommittedSelections,
+  };
+}