@graph8/sdk 0.370.0 → 0.374.0

package/blocks/workbench/components/workbench-table-settings.tsx

@@ -0,0 +1,53 @@
+"use client";
+
+/**
+ * WorkbenchTableSettings: rename a workbench or change its description, in a side sheet. Sends only the fields that changed. The
+ * handler ignores a null field but applies an empty string, so a cleared description is sent as "" (a null would silently keep the old one).
+ *
+ * SDK operations:
+ *   1. updateWorkbenchTable   PUT /workbench/tables/{table_id} { name?, description? }   (write, undoable by editing again)
+ */
+
+import { useEffect, useState } from "react";
+import { Button, Input, Label, Textarea } from "@graph8/sdk/ui";
+import { ApiError } from "@/g8/components/api-error";
+import { FormSheet } from "@/g8/components/screen/form-sheet";
+import { useG8Mutation } from "@/g8/hooks/use-g8-mutation";
+import { g8Put } from "@/g8/lib/g8-client";
+import type { WorkbenchTable } from "../lib/workbench-types";
+
+export interface WorkbenchTableSettingsProps {
+  tableId: string;
+  /** The loaded table; the form is seeded from it only once it is loaded. */
+  table: Pick<WorkbenchTable, "name" | "description"> | null | undefined;
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  /** Called after a save so the caller can re-read the table. */
+  onSaved?: () => void;
+}
+
+export function WorkbenchTableSettings({ tableId, table, open, onOpenChange, onSaved }: WorkbenchTableSettingsProps) {
+  const [name, setName] = useState("");
+  const [description, setDescription] = useState("");
+  useEffect(() => { if (open && table) { setName(table.name ?? ""); setDescription(table.description ?? ""); } }, [open, table?.name, table?.description]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  const originalName = table?.name ?? "";
+  const originalDescription = table?.description ?? "";
+  const nameChanged = name.trim() !== originalName && name.trim().length > 0;
+  const descChanged = description.trim() !== originalDescription;
+  const save = useG8Mutation(async () => (await g8Put(`/workbench/tables/${tableId}`, { ...(nameChanged ? { name: name.trim() } : {}), ...(descChanged ? { description: description.trim() } : {}) })).data, {
+    onSuccess: () => { onOpenChange(false); onSaved?.(); },
+  });
+
+  return (
+    <FormSheet open={open} onOpenChange={onOpenChange} title="Workbench details" description="Rename it or change what it is for."
+      footer={(<><Button variant="ghost" onClick={() => onOpenChange(false)}>Cancel</Button><Button loading={save.loading} disabled={!table || name.trim().length === 0 || (!nameChanged && !descChanged)} onClick={() => void save.mutate(undefined)}>Save details</Button></>)}>
+      <div className="flex flex-col gap-3">
+        <div className="flex flex-col gap-1"><Label htmlFor="wb-set-name">Name</Label><Input id="wb-set-name" value={name} onChange={(e) => setName(e.target.value)} /></div>
+        <div className="flex flex-col gap-1"><Label htmlFor="wb-set-desc">Description</Label><Textarea id="wb-set-desc" rows={3} value={description} onChange={(e) => setDescription(e.target.value)} />
+</div>
+        {save.error ? <ApiError error={save.error} title="Could not save the details" /> : null}
+      </div>
+    </FormSheet>
+  );
+}

package/blocks/workbench/components/workbench-triggers.tsx

@@ -0,0 +1,178 @@
+"use client";
+
+/**
+ * WorkbenchTriggers: the automations that fire when something happens to a row of one workbench. A trigger is "when a row
+ * arrives (or an AI column finishes, or a status changes), optionally only if a column matches, do this": run the AI
+ * columns, recompute formulas, send the row to a list, or call a webhook. Lists the triggers with a switch each, creates
+ * one in a side sheet, and deletes with a confirm.
+ *
+ * SDK operations, in order:
+ *   1. listWorkbenchTriggers   GET    /workbench/tables/{table_id}/triggers                 (read)
+ *   2. createWorkbenchTrigger  POST   /workbench/tables/{table_id}/triggers                 (billable tier: ARMS spend when the action runs AI)
+ *   3. updateWorkbenchTrigger  PUT    /workbench/tables/{table_id}/triggers/{trigger_id}    (billable tier: enabling an AI trigger arms spend)
+ *   4. deleteWorkbenchTrigger  DELETE /workbench/tables/{table_id}/triggers/{trigger_id}    (destructive, ConfirmSpendDialog; a 404 means already gone)
+ *
+ * Nothing charges on the call itself. An enabled "Run the AI columns" trigger enriches, and charges for, every matching row as
+ * it arrives. graph8 publishes no total up front for that, so the confirm says so and shows no number. Disabling and every
+ * other action need no confirm. The destination list of an "export" trigger comes from ListPicker (lists block).
+ */
+
+import { useState } from "react";
+import { Webhook, Zap } from "lucide-react";
+import { Button, Input, Label, Skeleton, Switch } from "@graph8/sdk/ui";
+import { ApiError } from "@/g8/components/api-error";
+import { ConfirmSpendDialog } from "@/g8/components/confirm-spend-dialog";
+import { EmptyState } from "@/g8/components/empty-state";
+import { FormSheet } from "@/g8/components/screen/form-sheet";
+import { SectionCard } from "@/g8/components/screen/section-card";
+import { StatusPill } from "@/g8/components/screen/status-pill";
+import { useG8Mutation } from "@/g8/hooks/use-g8-mutation";
+import { useG8Query } from "@/g8/hooks/use-g8-query";
+import { g8Delete, g8Get, g8Post, g8Put } from "@/g8/lib/g8-client";
+import { ListPicker } from "@/g8/lists/components/list-picker";
+import { isNotFound } from "../lib/api-status";
+import {
+  CONDITION_OPERATORS, TRIGGER_ACTIONS, TRIGGER_EVENTS, describeRule, labelOf, rowsOf, triggerConfigProblem, triggerRules, triggerSpends,
+} from "../lib/automation-types";
+import type { WorkbenchTrigger } from "../lib/automation-types";
+import type { WorkbenchColumn } from "../lib/workbench-types";
+
+export interface WorkbenchTriggersProps {
+  tableId: string;
+  /** The table's columns, offered for the optional "only when" condition. */
+  columns?: WorkbenchColumn[];
+  /** Rows are people or companies; picks the lists an "export" trigger can send to. Default people. */
+  entityType?: "contact" | "company";
+  className?: string;
+}
+
+const selectClass = "h-9 w-full rounded-md border border-border bg-background px-2 text-sm";
+const SPEND_NOTE = "Every matching row is enriched and charged at the AI column rate. No total is published up front, so none is shown: check the AI columns first.";
+
+interface Draft {
+  name: string;
+  event_type: string;
+  action_type: string;
+  webhook_url: string;
+  list_id: number | null;
+  field: string;
+  operator: string;
+  value: string;
+  enabled: boolean;
+}
+const BLANK: Draft = { name: "", event_type: "ingest", action_type: "run_formula", webhook_url: "", list_id: null, field: "", operator: "eq", value: "", enabled: true };
+
+function toBody(d: Draft) {
+  const cond = CONDITION_OPERATORS.find((o) => o.value === d.operator);
+  const rule = d.field ? (cond?.needsValue ? { field: d.field, operator: d.operator, value: d.value } : { field: d.field, operator: d.operator }) : null;
+  return {
+    name: d.name.trim(), event_type: d.event_type, action_type: d.action_type,
+    action_config: d.action_type === "webhook_notify" ? { webhook_url: d.webhook_url.trim() } : d.action_type === "export" ? { list_id: d.list_id } : {},
+    enabled: d.enabled, ...(rule ? { conditions: { rules: [rule] } } : {}),
+  };
+}
+
+export function WorkbenchTriggers({ tableId, columns = [], entityType = "contact", className }: WorkbenchTriggersProps) {
+  const path = `/workbench/tables/${tableId}/triggers`;
+  const list = useG8Query(async (signal) => rowsOf<WorkbenchTrigger>((await g8Get(path, undefined, { signal })).data), [tableId]);
+  const [open, setOpen] = useState(false);
+  const [draft, setDraft] = useState<Draft>(BLANK);
+  const [arming, setArming] = useState<{ kind: "create" } | { kind: "enable"; trigger: WorkbenchTrigger } | null>(null);
+  const [deleting, setDeleting] = useState<WorkbenchTrigger | null>(null);
+  const [busyId, setBusyId] = useState<number | null>(null);
+
+  const create = useG8Mutation(async (d: Draft) => (await g8Post(path, toBody(d))).data, {
+    onSuccess: () => { setOpen(false); setArming(null); setDraft(BLANK); void list.refetch(); },
+    onError: () => setArming(null),
+  });
+  const toggle = useG8Mutation(async (v: { trigger: WorkbenchTrigger; enabled: boolean }) => { setBusyId(v.trigger.id); return (await g8Put(`${path}/${v.trigger.id}`, { enabled: v.enabled })).data; }, {
+    onSuccess: () => { setBusyId(null); setArming(null); void list.refetch(); },
+    onError: () => { setBusyId(null); setArming(null); },
+  });
+  const remove = useG8Mutation(async (t: WorkbenchTrigger) => {
+    try { await g8Delete(`${path}/${t.id}`); } catch (e) { if (!isNotFound(e)) throw e; }
+  }, { onSuccess: () => { setDeleting(null); void list.refetch(); } });
+
+  const problem = triggerConfigProblem(draft.action_type, { webhook_url: draft.webhook_url, list_id: draft.list_id, new_list_name: "" });
+  const needsValue = CONDITION_OPERATORS.find((o) => o.value === draft.operator)?.needsValue !== false;
+  const valid = draft.name.trim().length > 0 && !problem && (!draft.field || !needsValue || draft.value.trim() !== "");
+  const submit = () => { if (valid && !create.loading) { if (triggerSpends(draft.action_type) && draft.enabled) setArming({ kind: "create" }); else void create.mutate(draft); } };
+  const items = list.data ?? [];
+
+  return (
+    <SectionCard
+      className={className}
+      title="Triggers"
+      icon={<Zap aria-hidden />}
+      description="Do something automatically when a row arrives, an AI column finishes, or a status changes."
+      actions={<Button size="sm" onClick={() => { setDraft(BLANK); create.reset(); setOpen(true); }}>New trigger</Button>}
+    >
+      {list.error ? <ApiError error={list.error} title="Could not load triggers" onRetry={() => void list.refetch()} /> : null}
+      {toggle.error ? <ApiError error={toggle.error} title="Could not change the trigger" /> : null}
+      {remove.error ? <ApiError error={remove.error} title="Could not delete the trigger" /> : null}
+      {list.loading && !list.data ? <Skeleton className="h-16 w-full" aria-label="Loading triggers" /> : null}
+      {!list.loading && !list.error && items.length === 0 ? (
+        <EmptyState compact icon={<Zap strokeWidth={1.5} />} title="No triggers yet" description="Send new rows to a list, call a webhook, or run your AI columns the moment a row arrives." />
+      ) : null}
+      <ul className="flex flex-col divide-y divide-border">
+        {items.map((t) => {
+          const rules = triggerRules(t);
+          return (
+            <li key={t.id} className="flex flex-wrap items-center gap-3 py-3">
+              <div className="min-w-0 flex-1">
+                <p className="flex items-center gap-2 text-sm font-medium">
+                  {t.action_type === "webhook_notify" ? <Webhook className="size-4 text-text-color-muted" aria-hidden /> : <Zap className="size-4 text-text-color-muted" aria-hidden />}
+                  <span className="truncate">{t.name}</span>
+                  {triggerSpends(t.action_type) ? <StatusPill tone="warning">Uses credits</StatusPill> : null}
+                </p>
+                <p className="text-xs text-text-color-muted">{labelOf(TRIGGER_EVENTS, t.event_type)}, then {labelOf(TRIGGER_ACTIONS, t.action_type).toLowerCase()}</p>
+                {rules.length ? <p className="text-xs text-text-color-muted">Only when {rules.map((r, i) => <span key={i}>{i ? " and " : ""}{describeRule(r)}</span>)}</p> : null}
+              </div>
+              <Switch aria-label={`Enable trigger ${t.name}`} checked={t.enabled === true} disabled={busyId === t.id}
+                onCheckedChange={(on) => { if (on && triggerSpends(t.action_type)) setArming({ kind: "enable", trigger: t }); else void toggle.mutate({ trigger: t, enabled: on }); }} />
+              <Button size="sm" variant="ghost" aria-label={`Delete trigger ${t.name}`} onClick={() => setDeleting(t)}>Delete</Button>
+            </li>
+          );
+        })}
+      </ul>
+
+      <FormSheet open={open} onOpenChange={setOpen} title="New trigger" description="A trigger watches one workbench. It starts working as soon as it is saved and switched on."
+        footer={(<><Button variant="ghost" onClick={() => setOpen(false)}>Cancel</Button><Button loading={create.loading} disabled={!valid} onClick={submit}>Create trigger</Button></>)}>
+        <div className="flex flex-col gap-3">
+          <div className="flex flex-col gap-1"><Label htmlFor="wbt-name">Trigger name</Label><Input id="wbt-name" placeholder="Send new leads to the hot list" value={draft.name} onChange={(e) => setDraft({ ...draft, name: e.target.value })} /></div>
+          <div className="flex flex-col gap-1"><Label htmlFor="wbt-when">When</Label>
+            <select id="wbt-when" className={selectClass} value={draft.event_type} onChange={(e) => setDraft({ ...draft, event_type: e.target.value })}>{TRIGGER_EVENTS.map((x) => <option key={x.value} value={x.value}>{x.label}</option>)}</select></div>
+          <div className="flex flex-col gap-1"><Label htmlFor="wbt-then">Then</Label>
+            <select id="wbt-then" className={selectClass} value={draft.action_type} onChange={(e) => setDraft({ ...draft, action_type: e.target.value })}>{TRIGGER_ACTIONS.map((x) => <option key={x.value} value={x.value}>{x.label}</option>)}</select></div>
+          {draft.action_type === "webhook_notify" ? (
+            <div className="flex flex-col gap-1"><Label htmlFor="wbt-url">Webhook URL</Label><Input id="wbt-url" inputMode="url" placeholder="https://hooks.example.com/notify" value={draft.webhook_url} onChange={(e) => setDraft({ ...draft, webhook_url: e.target.value })} /></div>
+          ) : null}
+          {draft.action_type === "export" ? (
+            <div className="flex flex-col gap-1"><Label>Destination list</Label><ListPicker value={draft.list_id} onChange={(l) => setDraft({ ...draft, list_id: l.id })} type={entityType === "company" ? "companies" : "contacts"} allowCreate /></div>
+          ) : null}
+          {draft.name.trim() && problem ? <p role="status" className="text-xs text-text-color-muted">{problem}</p> : null}
+          <fieldset className="flex flex-col gap-2 rounded-md border border-border p-3">
+            <legend className="px-1 text-xs text-text-color-muted">Optional condition</legend>
+            <div className="flex flex-col gap-1"><Label htmlFor="wbt-field">Only when column</Label>
+              <select id="wbt-field" className={selectClass} value={draft.field} onChange={(e) => setDraft({ ...draft, field: e.target.value })}>
+                <option value="">Always</option>{columns.map((c) => <option key={c.id} value={c.name}>{c.display_name || c.name}</option>)}</select></div>
+            {draft.field ? (<>
+              <div className="flex flex-col gap-1"><Label htmlFor="wbt-op">Condition</Label>
+                <select id="wbt-op" className={selectClass} value={draft.operator} onChange={(e) => setDraft({ ...draft, operator: e.target.value })}>{CONDITION_OPERATORS.map((o) => <option key={o.value} value={o.value}>{o.label}</option>)}</select></div>
+              {needsValue ? <div className="flex flex-col gap-1"><Label htmlFor="wbt-val">Condition value</Label><Input id="wbt-val" value={draft.value} onChange={(e) => setDraft({ ...draft, value: e.target.value })} /></div> : null}
+            </>) : null}
+          </fieldset>
+          <div className="flex items-center justify-between gap-3"><Label htmlFor="wbt-on">Switch it on when saved</Label><Switch id="wbt-on" checked={draft.enabled} onCheckedChange={(on) => setDraft({ ...draft, enabled: on })} /></div>
+          {create.error ? <ApiError error={create.error} title="Could not create the trigger" /> : null}
+        </div>
+      </FormSheet>
+
+      <ConfirmSpendDialog open={arming != null} tier="billable" title={arming?.kind === "enable" ? `Arm "${arming.trigger.name}"` : `Arm "${draft.name.trim()}"`}
+        description={SPEND_NOTE} confirmLabel="Arm trigger" confirming={create.loading || toggle.loading}
+        onConfirm={() => { if (arming?.kind === "enable") void toggle.mutate({ trigger: arming.trigger, enabled: true }); else if (arming) void create.mutate(draft); }}
+        onCancel={() => setArming(null)} />
+      <ConfirmSpendDialog open={deleting != null} tier="destructive" title={`Delete "${deleting?.name ?? ""}"`} description="The trigger stops firing. Rows it already handled are not changed."
+        confirmLabel="Delete trigger" confirming={remove.loading} onConfirm={() => deleting && void remove.mutate(deleting)} onCancel={() => setDeleting(null)} />
+    </SectionCard>
+  );
+}

package/blocks/workbench/hooks/use-connected-crms.ts

@@ -0,0 +1,29 @@
+"use client";
+
+import { useG8Query } from "@/g8/hooks/use-g8-query";
+import { g8Get } from "@/g8/lib/g8-client";
+import { rowsOf } from "../lib/automation-types";
+
+export interface ConnectedCrm {
+  provider: string;
+  connection_id: string;
+}
+
+interface CrmRow { provider?: string; status?: string; connection_id?: string | null }
+
+const LABELS: Record<string, string> = { hubspot: "HubSpot", salesforce: "Salesforce", pipedrive: "Pipedrive", zoho: "Zoho CRM", sugarcrm: "SugarCRM" };
+
+/** A CRM's display name: "HubSpot" for hubspot, the key with spaces for one this block does not know. */
+export function crmLabel(provider: string): string {
+  return LABELS[provider] ?? provider.replace(/[-_]/g, " ");
+}
+
+/**
+ * The CRMs this workspace has connected (`GET /crm-syncs`): only rows that carry a connection id are offered, because both the
+ * one-off import and the scheduled import need it. `data` is undefined until the read lands.
+ */
+export function useConnectedCrms(options: { enabled?: boolean } = {}) {
+  const read = useG8Query(async (signal) => rowsOf<CrmRow>((await g8Get("/crm-syncs", undefined, { signal })).data), [], { enabled: options.enabled !== false });
+  const connected = read.data?.filter((s): s is ConnectedCrm => Boolean(s.provider && s.connection_id));
+  return { connected, loading: read.loading, error: read.error, refetch: read.refetch };
+}

package/blocks/workbench/lib/api-status.ts

@@ -0,0 +1,8 @@
+"use client";
+
+import { G8Error } from "@graph8/sdk/errors";
+
+/** The API answered 404: the thing is not there. For a read that means "none yet"; for a delete it means "already gone". */
+export function isNotFound(error: unknown): boolean {
+  return error instanceof G8Error && error.status === 404;
+}

package/blocks/workbench/lib/automation-types.ts

@@ -0,0 +1,257 @@
+"use client";
+
+/**
+ * Shapes and small helpers for the Workbench automation components (triggers, pipelines, schedule, auto-enrich,
+ * connections, imports, send to sequence).
+ *
+ * The dev API answers these with OPEN payloads, so everything here is optional and read defensively. The rules the
+ * helpers encode are copied from the handlers (enrichment/interfaces/fastapi/staging_*_dtos.py, domain/services/
+ * staging_trigger_contract.py), never guessed:
+ *  - trigger event_type: ingest | ai_complete | status_change; action_type: run_ai | run_formula | export | webhook_notify
+ *  - a webhook trigger needs an http(s) URL; an export trigger needs an existing list or a new list name
+ *  - trigger conditions are `{ rules: [{ field, operator, value }] }`, operators eq | neq | gt | lt | exists | not_exists | contains
+ *    (exists and not_exists take no value)
+ *  - schedule action_type: run_ai | run_formula | crm_import; needs a cron expression or a frequency (hourly | daily | weekly)
+ *  - pipeline start type: email_pdf | webhook | scraper_bot | ingest; step type: ai_group | waterfall | formula | branch | export_to_list
+ */
+export type StatusTone = "neutral" | "info" | "positive" | "warning" | "negative";
+
+export interface WorkbenchTrigger {
+  id: number;
+  name: string;
+  event_type?: string | null;
+  action_type?: string | null;
+  action_config?: Record<string, unknown> | null;
+  conditions?: { rules?: TriggerRule[] } | TriggerRule[] | null;
+  enabled?: boolean | null;
+  created_at?: string | null;
+  updated_at?: string | null;
+}
+
+export interface TriggerRule {
+  field?: string;
+  operator?: string;
+  value?: unknown;
+  logic?: string;
+}
+
+export const TRIGGER_EVENTS = [
+  { value: "ingest", label: "A row arrives" },
+  { value: "ai_complete", label: "An AI column finishes" },
+  { value: "status_change", label: "A row's status changes" },
+] as const;
+
+export const TRIGGER_ACTIONS = [
+  { value: "run_ai", label: "Run the AI columns", spends: true },
+  { value: "run_formula", label: "Recompute formulas", spends: false },
+  { value: "export", label: "Send the row to a list", spends: false },
+  { value: "webhook_notify", label: "Call a webhook", spends: false },
+] as const;
+
+export const CONDITION_OPERATORS = [
+  { value: "eq", label: "equals", needsValue: true },
+  { value: "neq", label: "does not equal", needsValue: true },
+  { value: "gt", label: "is greater than", needsValue: true },
+  { value: "lt", label: "is less than", needsValue: true },
+  { value: "contains", label: "contains", needsValue: true },
+  { value: "exists", label: "has a value", needsValue: false },
+  { value: "not_exists", label: "is empty", needsValue: false },
+] as const;
+
+export function labelOf(list: readonly { value: string; label: string }[], value: string | null | undefined): string {
+  return list.find((x) => x.value === value)?.label ?? (value ? value.replace(/_/g, " ") : "Unknown");
+}
+
+/** Does this trigger action charge credits when it fires? Only an AI pass does. */
+export function triggerSpends(actionType: string | null | undefined): boolean {
+  return TRIGGER_ACTIONS.find((a) => a.value === actionType)?.spends === true;
+}
+
+export function triggerRules(t: Pick<WorkbenchTrigger, "conditions">): TriggerRule[] {
+  const c = t.conditions;
+  if (!c) return [];
+  return Array.isArray(c) ? c : Array.isArray(c.rules) ? c.rules : [];
+}
+
+/** "Status equals failed" for a rule; the row field name is the API's own, so it is shown as written. */
+export function describeRule(rule: TriggerRule): string {
+  const op = CONDITION_OPERATORS.find((o) => o.value === rule.operator);
+  if (!rule.field || !op) return "Custom condition";
+  return op.needsValue ? `${rule.field} ${op.label} ${String(rule.value ?? "")}` : `${rule.field} ${op.label}`;
+}
+
+/** The validation the handler runs on action_config, so the form blocks what the API would refuse. Returns a message or null. */
+export function triggerConfigProblem(actionType: string, config: { webhook_url?: string; list_id?: number | null; new_list_name?: string }): string | null {
+  if (actionType === "webhook_notify") {
+    try {
+      const u = new URL(config.webhook_url ?? "");
+      if (u.protocol !== "http:" && u.protocol !== "https:") return "Enter a full http or https webhook URL.";
+    } catch {
+      return "Enter a full http or https webhook URL.";
+    }
+  }
+  if (actionType === "export" && !(config.list_id && config.list_id > 0) && !config.new_list_name?.trim()) return "Choose a list, or name a new one.";
+  return null;
+}
+
+export interface WorkbenchPipelineStep {
+  id: string;
+  type: string;
+  name: string;
+  enabled?: boolean;
+  group_id?: string | null;
+  column_id?: number | null;
+}
+
+export interface WorkbenchPipeline {
+  id: string;
+  name: string;
+  enabled?: boolean | null;
+  start_type?: string | null;
+  start?: { type?: string | null; source_types?: string[]; expected_fields?: unknown[] } | null;
+  steps?: WorkbenchPipelineStep[] | null;
+  created_at?: string | null;
+  updated_at?: string | null;
+}
+
+export const PIPELINE_STARTS = [
+  { value: "ingest", label: "Rows added to the table" },
+  { value: "webhook", label: "A webhook call" },
+  { value: "email_pdf", label: "An email with a PDF" },
+  { value: "scraper_bot", label: "A scraper run" },
+] as const;
+
+export const STEP_TYPES = [
+  { value: "ai_group", label: "AI columns" },
+  { value: "waterfall", label: "Provider waterfall" },
+  { value: "formula", label: "Formula" },
+  { value: "branch", label: "If / else" },
+  { value: "export_to_list", label: "Send to a list" },
+] as const;
+
+/** Steps that call a model or a data provider, so an enabled pipeline charges for them on every new row. */
+export function stepSpends(step: Pick<WorkbenchPipelineStep, "type" | "enabled">): boolean {
+  return step.enabled !== false && (step.type === "ai_group" || step.type === "waterfall");
+}
+
+export function pipelineSpends(p: Pick<WorkbenchPipeline, "steps">): boolean {
+  return (p.steps ?? []).some(stepSpends);
+}
+
+export interface WorkbenchSchedule {
+  action_type?: string | null;
+  cron_expression?: string | null;
+  frequency?: string | null;
+  action_config?: Record<string, unknown> | null;
+  enabled?: boolean | null;
+  scheduler_state?: string | null;
+  scheduler_error?: string | null;
+  next_run_at?: string | null;
+  last_run_at?: string | null;
+  last_outcome?: string | null;
+  owner_label?: string | null;
+  updated_by_label?: string | null;
+  timezone?: string | null;
+}
+
+export const SCHEDULE_ACTIONS = [
+  { value: "run_ai", label: "Run the AI columns", spends: true },
+  { value: "run_formula", label: "Recompute formulas", spends: false },
+  { value: "crm_import", label: "Pull records from the CRM", spends: false },
+] as const;
+
+export const SCHEDULE_FREQUENCIES = [
+  { value: "hourly", label: "Every hour" },
+  { value: "daily", label: "Every day" },
+  { value: "weekly", label: "Every week" },
+] as const;
+
+export function scheduleSpends(actionType: string | null | undefined): boolean {
+  return SCHEDULE_ACTIONS.find((a) => a.value === actionType)?.spends === true;
+}
+
+const CRON_FIELD = /^[A-Za-z0-9*/?,#LW-]+$/;
+
+/**
+ * Mirrors the server's `_validate_cron` (set_staging_schedule/handler.py): five fields of cron characters, and the MINUTE must be a
+ * plain number from 0 to 59, so a schedule runs at most once an hour (that is the recurring-spend bound). `*\/5 * * * *` and
+ * `0,30 * * * *` are refused there, so they are refused here.
+ */
+export function validCron(expr: string): boolean {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5 || !parts.every((p) => CRON_FIELD.test(p))) return false;
+  return /^\d{1,2}$/.test(parts[0]) && Number(parts[0]) <= 59;
+}
+
+export const CRON_HINT = "Five fields: minute, hour, day of month, month, day of week. The minute must be a single number from 0 to 59 (schedules run at most once an hour).";
+
+/** The most records a scheduled CRM import may pull per run (the one-off import allows 10,000). */
+export const MAX_CRM_SCHEDULE_LIMIT = 1000;
+
+export function describeSchedule(s: WorkbenchSchedule): string {
+  const when = s.frequency ? labelOf(SCHEDULE_FREQUENCIES, s.frequency) : s.cron_expression ? `On cron ${s.cron_expression}` : "No cadence set";
+  return `${labelOf(SCHEDULE_ACTIONS, s.action_type)}. ${when}${s.timezone ? ` (${s.timezone})` : ""}.`;
+}
+
+export function schedulerTone(state: string | null | undefined): StatusTone {
+  if (state === "active") return "positive";
+  if (state === "paused") return "neutral";
+  return "warning"; // missing, unavailable and anything unknown need a look; unknown is never shown as healthy
+}
+
+export interface EnrichmentConfig {
+  id?: string | number;
+  type?: string | null;
+  name?: string | null;
+  display_name?: string | null;
+  column_name?: string | null;
+  group_id?: string | null;
+  is_active?: boolean | null;
+}
+
+export function configName(c: EnrichmentConfig): string {
+  return c.display_name || c.name || c.column_name || (c.type ? `${c.type.replace(/_/g, " ")} configuration` : "Configuration");
+}
+
+export interface WorkbenchConnection {
+  id: number;
+  source_table_id?: string;
+  destination_table_id?: string;
+  sync_mode?: string | null;
+  field_mapping?: Record<string, string> | null;
+  filter_conditions?: Record<string, unknown> | null;
+  enabled?: boolean | null;
+  last_synced_row_id?: number | null;
+  created_at?: string | null;
+}
+
+export interface MappingSuggestion {
+  status?: string | null;
+  job_id?: string | null;
+  mappings?: { source?: string; target?: string | null; confidence?: number }[] | null;
+  message?: string | null;
+}
+
+/** Statuses of a mapping job that will not change any more. Anything else (pending, an unknown word) keeps polling. */
+export function mappingDone(status: string | null | undefined): boolean {
+  return status === "completed" || status === "failed";
+}
+
+/** The first non-empty list found under any of the keys the endpoints use, or an empty list. */
+export function rowsOf<T>(data: unknown): T[] {
+  if (Array.isArray(data)) return data as T[];
+  const d = (data ?? {}) as Record<string, unknown>;
+  for (const key of ["items", "rows", "configs", "connections", "triggers", "pipelines"]) if (Array.isArray(d[key])) return d[key] as T[];
+  return [];
+}
+
+/** Whole-number sequence ids only: the send-to-sequence body takes an integer, the list read answers a string. */
+export function sequenceNumber(id: string | number | null | undefined): number | null {
+  const n = typeof id === "number" ? id : /^\d+$/.test(String(id ?? "")) ? Number(id) : NaN;
+  return Number.isInteger(n) && n > 0 ? n : null;
+}
+
+/** Sequences that can take new people: running ones. Paused, ended and draft sequences are not offered. */
+export function sequenceAcceptsPeople(status: string | null | undefined): boolean {
+  return ["live", "waiting", "running", "active"].includes((status ?? "").toLowerCase());
+}

package/blocks/workflows/components/workflow-editor.tsx

@@ -107,7 +107,7 @@ export function WorkflowEditor({ actionId, onSaved, className }: WorkflowEditorP
   return (
     <div className={className}>
       <div className="mb-4 flex flex-wrap items-center gap-2">
-        <h2 className="text-lg font-semibold">{str(wf.workflow.name, "Workflow")}</h2>
+        <h2 className="text-lg font-medium">{str(wf.workflow.name, "Workflow")}</h2>
         <span className="text-muted-foreground text-sm">{wf.workflow.enabled === false ? "Disabled" : "Enabled"}</span>
         <div className="ml-auto flex items-center gap-2">
           {draft ? <span className="text-sm">Unsaved changes</span> : null}