orcheo-studio 0.23.2 → 0.24.1

package/src/features/workflow/lib/workflow-storage-helpers.ts

@@ -20,6 +20,7 @@ import type {
   ApiWorkflow,
   ApiWorkflowVersion,
   ApiWorkflowVersionSummary,
+  WorkflowCandidateSource,
   WorkflowVersionMetadata,
   StoredWorkflow,
   WorkflowVersionRecord,
@@ -97,6 +98,45 @@ const extractAvatarEmoji = (metadata: unknown): string | undefined => {
   return undefined;
 };
 
+const extractCandidateSource = (
+  metadata: unknown,
+): WorkflowCandidateSource | undefined => {
+  if (!isRecord(metadata)) {
+    return undefined;
+  }
+
+  const source =
+    typeof metadata.source === "string" ? metadata.source : undefined;
+  const candidateId =
+    typeof metadata.candidate_id === "string"
+      ? metadata.candidate_id
+      : undefined;
+  const candidateHandle =
+    typeof metadata.candidate_handle === "string"
+      ? metadata.candidate_handle
+      : undefined;
+  const candidateVersion =
+    typeof metadata.candidate_version === "string"
+      ? metadata.candidate_version
+      : undefined;
+  const candidateSourceRef =
+    typeof metadata.candidate_source_ref === "string"
+      ? metadata.candidate_source_ref
+      : undefined;
+
+  if (!source && !candidateId && !candidateHandle && !candidateVersion) {
+    return undefined;
+  }
+
+  return {
+    source,
+    candidateId,
+    candidateHandle,
+    candidateVersion,
+    candidateSourceRef,
+  };
+};
+
 const toAuthor = (id: string | undefined): Workflow["owner"] => {
   if (!id) {
     return { ...DEFAULT_OWNER };
@@ -176,8 +216,10 @@ const parseWorkflowMetadata = (
 ): WorkflowVersionMetadata => {
   const configurableSchemas = parseConfigurableSchemas(
     isRecord(metadata) ? metadata.configurable_schema : undefined,
+    isRecord(metadata) ? metadata.configurable_schema_order : undefined,
   );
   const avatarEmoji = extractAvatarEmoji(metadata);
+  const candidateSource = extractCandidateSource(metadata);
   const resolveTemplateFallback = (): WorkflowVersionMetadata | undefined => {
     if (!metadata || typeof metadata !== "object") {
       return undefined;
@@ -204,6 +246,7 @@ const parseWorkflowMetadata = (
       templateId,
       configurableSchemas,
       avatarEmoji,
+      candidateSource,
     };
   };
 
@@ -214,6 +257,7 @@ const parseWorkflowMetadata = (
       templateId: undefined,
       configurableSchemas: undefined,
       avatarEmoji: undefined,
+      candidateSource,
     };
   }
 
@@ -226,6 +270,7 @@ const parseWorkflowMetadata = (
         summary: { ...DEFAULT_SUMMARY },
         configurableSchemas,
         avatarEmoji,
+        candidateSource,
       }
     );
   }
@@ -280,11 +325,13 @@ const parseWorkflowMetadata = (
     templateId,
     configurableSchemas,
     avatarEmoji,
+    candidateSource,
   };
 };
 
 const parseConfigurableSchemas = (
   value: unknown,
+  order: unknown,
 ): Record<string, RJSFSchema> | undefined => {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return undefined;
@@ -299,6 +346,23 @@ const parseConfigurableSchemas = (
     return undefined;
   }
 
+  // The schema object is persisted in a JSONB column that does not preserve key
+  // order, so reorder by the authored `configurable_schema_order` array when
+  // present. Keys missing from the order list keep their existing position at
+  // the end, keeping output stable for legacy versions without the array.
+  if (Array.isArray(order) && order.length > 0) {
+    const byKey = new Map(entries);
+    const orderedKeys = order.filter(
+      (key): key is string => typeof key === "string" && byKey.has(key),
+    );
+    const seen = new Set(orderedKeys);
+    const orderedEntries = [
+      ...orderedKeys.map((key) => [key, byKey.get(key)] as const),
+      ...entries.filter(([key]) => !seen.has(key)),
+    ];
+    return Object.fromEntries(orderedEntries) as Record<string, RJSFSchema>;
+  }
+
   return Object.fromEntries(entries) as Record<string, RJSFSchema>;
 };
 
@@ -337,6 +401,7 @@ const toVersionRecord = (
     graphToWorkflow: metadata.graphToWorkflow,
     templateId: metadata.templateId,
     avatarEmoji: metadata.avatarEmoji,
+    candidateSource: metadata.candidateSource,
   };
 };
 

package/src/features/workflow/lib/workflow-storage.ts

@@ -16,6 +16,7 @@ import {
   fetchWorkflowVersions,
   onboardCandidate,
   request,
+  updateCandidateWorkflow,
   upsertWorkflow,
 } from "./workflow-storage-api";
 import {
@@ -472,6 +473,22 @@ export const onboardCandidateAsWorkflow = async (
   return stored;
 };
 
+export const updateCandidateWorkflowVersion = async (
+  workflowId: string,
+  candidateId: string,
+): Promise<StoredWorkflow> => {
+  const apiWorkflow = await updateCandidateWorkflow(workflowId, candidateId);
+  invalidateWorkflowCache(apiWorkflow.id);
+  const stored = await ensureWorkflow(apiWorkflow.id);
+  if (!stored) {
+    throw new Error("Failed to load updated candidate workflow");
+  }
+  invalidateWorkflowListCache();
+  primeWorkflowCache(stored);
+  emitUpdate();
+  return stored;
+};
+
 export type {
   StoredWorkflow,
   WorkflowVersionRecord,

package/src/features/workflow/lib/workflow-storage.types.ts

@@ -68,6 +68,20 @@ export interface ApiWorkflowVersionSummary {
   updated_at: string;
 }
 
+export interface CandidateUpdateNote {
+  version: string;
+  summary: string;
+  migration?: string | null;
+}
+
+export interface WorkflowCandidateSource {
+  source?: string;
+  candidateId?: string;
+  candidateHandle?: string;
+  candidateVersion?: string;
+  candidateSourceRef?: string;
+}
+
 export interface ApiWorkflowPageData {
   workflow: ApiWorkflow;
   versions?: ApiWorkflowVersionSummary[];
@@ -219,6 +233,7 @@ export interface WorkflowVersionMetadata {
   templateId?: string;
   configurableSchemas?: Record<string, RJSFSchema>;
   avatarEmoji?: string;
+  candidateSource?: WorkflowCandidateSource;
 }
 
 export interface RequestOptions extends RequestInit {
@@ -241,6 +256,7 @@ export interface WorkflowVersionRecord {
   configurableSchemas?: Record<string, RJSFSchema>;
   graphToWorkflow?: Record<string, string>;
   templateId?: string;
+  candidateSource?: WorkflowCandidateSource;
 }
 
 export interface StoredWorkflow extends Workflow {

package/src/features/workflow/pages/workflow/components/workflow-config-sheet.tsx

@@ -44,12 +44,28 @@ const baseWorkflowConfigSchema: RJSFSchema = {
   },
 };
 
-const workflowConfigUiSchema: UiSchema = {
-  configurable: {
-    fields: {
-      "ui:field": "jsonObject",
+const buildWorkflowConfigUiSchema = (
+  configurableSchemas?: Record<string, RJSFSchema>,
+): UiSchema => {
+  // Opt any key declared with `"format": "cron"` into the visual cron widget.
+  const cronEntries: UiSchema = {};
+  for (const [key, schema] of Object.entries(configurableSchemas ?? {})) {
+    if (schema?.format === "cron") {
+      cronEntries[key] = { "ui:widget": "cron" };
+    }
+  }
+
+  return {
+    configurable: {
+      // Render configurable fields in the order declared by config.json,
+      // with any data-only keys appended afterwards via the "*" wildcard.
+      "ui:order": [...Object.keys(configurableSchemas ?? {}), "*"],
+      fields: {
+        "ui:field": "jsonObject",
+      },
+      ...cronEntries,
     },
-  },
+  };
 };
 
 interface WorkflowConfigSheetProps {
@@ -91,6 +107,11 @@ export function WorkflowConfigSheet({
     };
   }, [formData.configurable, configurableSchemas]);
 
+  const workflowConfigUiSchema = useMemo<UiSchema>(
+    () => buildWorkflowConfigUiSchema(configurableSchemas),
+    [configurableSchemas],
+  );
+
   useEffect(() => {
     if (open) {
       setFormData(toFormData(initialConfig));

package/src/features/workflow/pages/workflow/components/workflow-tab-content.tsx

@@ -2,12 +2,14 @@ import { useEffect, useMemo, useState } from "react";
 import { useUploadsAllowed } from "@/hooks/use-uploads-allowed";
 import {
   AlertTriangle,
+  CheckCircle2,
   Copy,
   ExternalLink,
   LoaderCircle,
   Play,
   RefreshCw,
   UserMinus,
+  XCircle,
 } from "lucide-react";
 import { useNavigate } from "react-router-dom";
 import { Controls, ReactFlow, type Node, type NodeProps } from "@xyflow/react";
@@ -56,6 +58,7 @@ import {
 } from "@features/workflow/lib/mermaid-renderer";
 import { resolveWorkflowVersionMermaidSource } from "@features/workflow/lib/workflow-storage-helpers";
 import { WorkflowConfigSheet } from "@features/workflow/pages/workflow/components/workflow-config-sheet";
+import type { WorkflowExecutionStatus } from "@features/workflow/pages/workflow/helpers/types";
 
 export interface WorkflowTabContentProps {
   workflowId: string | null;
@@ -66,6 +69,7 @@ export interface WorkflowTabContentProps {
   loadError: string | null;
   isRunPending: boolean;
   isRunning: boolean;
+  lastRunStatus?: WorkflowExecutionStatus | null;
   onRunWorkflow: () => Promise<void>;
   onSaveConfig: (nextConfig: WorkflowRunnableConfig | null) => Promise<void>;
   hasCronTriggerNode: boolean;
@@ -189,6 +193,49 @@ const getErrorMessage = (error: unknown, fallback: string): string => {
   return rawMessage;
 };
 
+interface RunResultBanner {
+  Icon: typeof CheckCircle2;
+  className: string;
+  message: string;
+}
+
+const resolveRunResultBanner = (
+  status: WorkflowExecutionStatus,
+): RunResultBanner => {
+  switch (status) {
+    case "success":
+      return {
+        Icon: CheckCircle2,
+        className:
+          "border-emerald-500/40 bg-emerald-50 text-emerald-700 dark:bg-emerald-950/40 dark:text-emerald-300",
+        message: "Workflow run succeeded. See the full trace on the Trace tab.",
+      };
+    case "failed":
+      return {
+        Icon: XCircle,
+        className: "border-destructive/40 bg-destructive/5 text-destructive",
+        message: "Workflow run failed. Check the Trace tab for details.",
+      };
+    case "partial":
+      return {
+        Icon: AlertTriangle,
+        className:
+          "border-amber-500/40 bg-amber-50 text-amber-700 dark:bg-amber-950/40 dark:text-amber-300",
+        message:
+          "Workflow run finished with partial results. Check the Trace tab for details.",
+      };
+    default:
+      // "running" reaching here means the stream ended without a final status.
+      return {
+        Icon: AlertTriangle,
+        className:
+          "border-amber-500/40 bg-amber-50 text-amber-700 dark:bg-amber-950/40 dark:text-amber-300",
+        message:
+          "Workflow run ended without a final status. Check the Trace tab for the latest status.",
+      };
+  }
+};
+
 export function WorkflowTabContent({
   workflowId,
   workflowName,
@@ -197,6 +244,7 @@ export function WorkflowTabContent({
   loadError,
   isRunPending,
   isRunning,
+  lastRunStatus = null,
   onRunWorkflow,
   onSaveConfig,
   hasCronTriggerNode,
@@ -390,6 +438,11 @@ export function WorkflowTabContent({
   }
 
   const canConfigure = Boolean(workflowId);
+  const isRunActive = isRunPending || isRunning;
+  const runResultBanner =
+    !isRunActive && lastRunStatus
+      ? resolveRunResultBanner(lastRunStatus)
+      : null;
   const canRun = Boolean(workflowId && latestVersion);
   const runButtonDisabled = !canRun || isRunPending || isRunning;
   const runButtonLabel = isRunPending || isRunning ? "Running..." : "Run";
@@ -667,7 +720,7 @@ export function WorkflowTabContent({
           </div>
         </div>
 
-        {(isRunPending || isRunning) && (
+        {isRunActive && (
           <div
             role="status"
             className="rounded-md border border-primary/30 bg-primary/5 px-3 py-2 text-sm text-primary"
@@ -677,6 +730,16 @@ export function WorkflowTabContent({
           </div>
         )}
 
+        {runResultBanner && (
+          <div
+            role="status"
+            className={`flex items-center gap-2 rounded-md border px-3 py-2 text-sm ${runResultBanner.className}`}
+          >
+            <runResultBanner.Icon className="h-4 w-4 shrink-0" />
+            <span>{runResultBanner.message}</span>
+          </div>
+        )}
+
         {isPublished && shareUrl && (
           <div className="flex items-center justify-between rounded-md border border-border/60 bg-muted/20 px-3 py-2">
             <div className="min-w-0">

package/src/features/workflow/pages/workflow/hooks/controller/build-layout-props.ts

@@ -75,6 +75,10 @@ export function buildWorkflowLayoutProps(
   resources: WorkflowResources,
   execution: WorkflowExecutionController,
 ): WorkflowLayoutProps {
+  const activeExecution = core.execution.executions.find(
+    (execution) => execution.id === core.execution.activeExecutionId,
+  );
+
   const workflowProps: WorkflowTabContentProps = {
     workflowId: core.metadata.currentWorkflowId,
     workflowRouteRef: core.routeWorkflowRef,
@@ -84,6 +88,7 @@ export function buildWorkflowLayoutProps(
     loadError: core.metadata.workflowLoadError,
     isRunPending: execution.isRunPending,
     isRunning: core.execution.isRunning,
+    lastRunStatus: activeExecution?.status ?? null,
     onRunWorkflow: execution.handleRunPersistedWorkflow,
     onSaveConfig: resources.saver.handleSaveWorkflowConfig,
     hasCronTriggerNode: hasSchedulableCronTrigger(

package/src/features/workflow/pages/workflow-gallery/candidate-updates.ts

@@ -0,0 +1,107 @@
+import type { Workflow } from "@features/workflow/data/workflow-data";
+import type { CandidateBadgeDefinition } from "@features/workflow/data/templates/candidate-badges";
+import type { CandidateUpdateNote } from "@features/workflow/lib/workflow-storage.types";
+
+interface SemVer {
+  major: number;
+  minor: number;
+  patch: number;
+}
+
+export interface CandidateUpdateAvailability {
+  candidateId: string;
+  candidateName: string;
+  currentVersion: string;
+  latestVersion: string;
+  latestSummary?: string;
+  firstMigration?: string;
+  crossedUpdates: CandidateUpdateNote[];
+  isMajor: boolean;
+}
+
+const SEMVER_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+
+export const parseSemVer = (value: string): SemVer | null => {
+  const match = SEMVER_PATTERN.exec(value);
+  if (!match) {
+    return null;
+  }
+
+  return {
+    major: Number.parseInt(match[1] ?? "0", 10),
+    minor: Number.parseInt(match[2] ?? "0", 10),
+    patch: Number.parseInt(match[3] ?? "0", 10),
+  };
+};
+
+export const compareSemVer = (left: string, right: string): number | null => {
+  const leftVersion = parseSemVer(left);
+  const rightVersion = parseSemVer(right);
+  if (!leftVersion || !rightVersion) {
+    return null;
+  }
+
+  for (const key of ["major", "minor", "patch"] as const) {
+    const delta = leftVersion[key] - rightVersion[key];
+    if (delta !== 0) {
+      return delta > 0 ? 1 : -1;
+    }
+  }
+
+  return 0;
+};
+
+export const getCandidateUpdateAvailability = (
+  workflow: Workflow,
+  candidate: CandidateBadgeDefinition | undefined,
+): CandidateUpdateAvailability | undefined => {
+  if (!candidate?.version) {
+    return undefined;
+  }
+
+  const candidateSource = workflow.versions?.at(-1)?.candidateSource;
+  if (candidateSource?.source !== "candidate-onboard") {
+    return undefined;
+  }
+
+  const currentVersion = candidateSource.candidateVersion;
+  if (!currentVersion) {
+    return undefined;
+  }
+
+  const latestVersion = candidate.version;
+  if (compareSemVer(latestVersion, currentVersion) !== 1) {
+    return undefined;
+  }
+
+  const currentParsed = parseSemVer(currentVersion);
+  const latestParsed = parseSemVer(latestVersion);
+  if (!currentParsed || !latestParsed) {
+    return undefined;
+  }
+
+  const crossedUpdates = (candidate.updates ?? []).filter((note) => {
+    const newerThanCurrent = compareSemVer(note.version, currentVersion);
+    const notNewerThanLatest = compareSemVer(note.version, latestVersion);
+    return (
+      newerThanCurrent === 1 &&
+      notNewerThanLatest !== null &&
+      notNewerThanLatest <= 0
+    );
+  });
+
+  const firstMigration = crossedUpdates.find(
+    (note) => typeof note.migration === "string" && note.migration.trim(),
+  )?.migration;
+
+  return {
+    candidateId: candidate.candidateId,
+    candidateName: candidate.name,
+    currentVersion,
+    latestVersion,
+    latestSummary: crossedUpdates[0]?.summary,
+    firstMigration,
+    crossedUpdates,
+    isMajor: latestParsed.major > currentParsed.major,
+  };
+};

package/src/features/workflow/pages/workflow-gallery/use-workflow-gallery-actions.ts

@@ -9,6 +9,7 @@ import { getCandidateBadgeDefinition } from "@features/workflow/data/templates/c
 import {
   deleteWorkflow,
   onboardCandidateAsWorkflow,
+  updateCandidateWorkflowVersion,
 } from "@features/workflow/lib/workflow-storage";
 import {
   type ApiTeam,
@@ -104,10 +105,9 @@ export const useWorkflowGalleryActions = (
   const handleOpenWorkflow = useCallback(
     (workflowId: string, teamSlug?: string) => {
       const slug = getSelectedWorkspaceSlug();
-      const path =
-        teamSlug
-          ? getWorkspaceTeamWorkflowPath(slug, teamSlug, workflowId)
-          : getWorkspaceWorkflowPath(slug, workflowId);
+      const path = teamSlug
+        ? getWorkspaceTeamWorkflowPath(slug, teamSlug, workflowId)
+        : getWorkspaceWorkflowPath(slug, workflowId);
       navigate(path);
     },
     [navigate],
@@ -302,6 +302,30 @@ export const useWorkflowGalleryActions = (
     [],
   );
 
+  const handleUpdateCandidateWorkflow = useCallback(
+    async (workflowId: string, candidateId: string) => {
+      try {
+        const workflow = await updateCandidateWorkflowVersion(
+          workflowId,
+          candidateId,
+        );
+        toast({
+          title: "Candidate updated",
+          description: `"${workflow.name}" is now on the latest candidate version.`,
+        });
+      } catch (error) {
+        toast({
+          title: "Failed to update candidate",
+          description:
+            error instanceof Error ? error.message : "Unknown error occurred",
+          variant: "destructive",
+        });
+        throw error;
+      }
+    },
+    [],
+  );
+
   const openCreateTeamDialog = useCallback(() => setIsCreateTeamOpen(true), []);
   const closeCreateTeamDialog = useCallback(
     () => setIsCreateTeamOpen(false),
@@ -314,6 +338,7 @@ export const useWorkflowGalleryActions = (
     handleImportStarterPack,
     handleExportWorkflow,
     handleDeleteWorkflow,
+    handleUpdateCandidateWorkflow,
     onboardTarget,
     confirmOnboardTeam,
     cancelOnboardTeam,

package/src/features/workflow/pages/workflow-gallery/use-workflow-gallery-state.ts

@@ -49,6 +49,8 @@ const toCandidateSpec = (candidate: ApiCandidate): CandidateBadgeSpec => ({
   avatar: candidate.avatar ?? undefined,
   notes: candidate.notes,
   mermaid: candidate.mermaid,
+  version: candidate.version,
+  updates: candidate.updates,
   rawMetadata: candidate.metadata,
 });
 
@@ -75,17 +77,22 @@ export const useWorkflowGalleryState = (): WorkflowGalleryStateSlice => {
   useEffect(() => {
     let isMounted = true;
 
-    const loadCandidates = async () => {
+    const loadCandidates = async (existingWorkflows?: StoredWorkflow[]) => {
       try {
         // Load both candidates and existing workflows to check for handle conflicts
-        const [candidates, existingWorkflows] = await Promise.all([
+        const [candidates, workflowsForConflicts] = await Promise.all([
           fetchCandidates(),
-          listWorkflows(),
+          existingWorkflows
+            ? Promise.resolve(existingWorkflows)
+            : listWorkflows(),
         ]);
         if (!isMounted) {
           return;
         }
-        setCandidateBadges(candidates.map(toCandidateSpec), existingWorkflows);
+        setCandidateBadges(
+          candidates.map(toCandidateSpec),
+          workflowsForConflicts,
+        );
         setCandidateWorkflows(getCandidateWorkflows());
       } catch (error) {
         if (isMounted) {
@@ -94,26 +101,8 @@ export const useWorkflowGalleryState = (): WorkflowGalleryStateSlice => {
       }
     };
 
-    void loadCandidates();
-
-    return () => {
-      isMounted = false;
-    };
-  }, []);
-
-  const refreshTeams = useCallback(async () => {
-    try {
-      const teamList = await fetchTeams();
-      setTeams(teamList);
-    } catch {
-      // non-fatal — teams list will stay stale
-    }
-  }, []);
-
-  useEffect(() => {
-    let isMounted = true;
-
-    const load = async (forceRefresh = false) => {
+    const load = async (forceRefresh = false, refreshCandidates = false) => {
+      let loadedWorkflows: StoredWorkflow[] | undefined;
       if (isMounted) {
         setIsLoadingWorkflows(true);
       }
@@ -122,6 +111,7 @@ export const useWorkflowGalleryState = (): WorkflowGalleryStateSlice => {
           listWorkflows({ forceRefresh }),
           fetchTeams().catch(() => [] as ApiTeam[]),
         ]);
+        loadedWorkflows = items;
         if (isMounted) {
           setWorkflows(items);
           setTeams(teamList);
@@ -143,14 +133,19 @@ export const useWorkflowGalleryState = (): WorkflowGalleryStateSlice => {
           setIsLoadingWorkflows(false);
         }
       }
+
+      if (refreshCandidates && loadedWorkflows) {
+        await loadCandidates(loadedWorkflows);
+      }
     };
 
+    void loadCandidates();
     void load();
 
     const targetWindow = typeof window !== "undefined" ? window : undefined;
     if (targetWindow) {
       const handler = () => {
-        void load(true);
+        void load(true, true);
       };
       targetWindow.addEventListener(WORKFLOW_STORAGE_EVENT, handler);
 
@@ -165,6 +160,15 @@ export const useWorkflowGalleryState = (): WorkflowGalleryStateSlice => {
     };
   }, []);
 
+  const refreshTeams = useCallback(async () => {
+    try {
+      const teamList = await fetchTeams();
+      setTeams(teamList);
+    } catch {
+      // non-fatal — teams list will stay stale
+    }
+  }, []);
+
   const templates = useMemo(
     () => [...GALLERY_TEMPLATE_WORKFLOWS, ...candidateWorkflows],
     [candidateWorkflows],