@cat-factory/app 0.160.1 → 0.162.0

package/app/stores/reports.spec.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { useAccountsStore } from '~/stores/accounts'
+import { useReportsStore } from '~/stores/reports'
+import type { ReportsView } from '~/types/execution'
+
+// The reports view is loaded three ways that can each be triggered while another is still in
+// flight — the window buttons, the board filter and the refresh button — so the store's
+// monotonicity guard is the thing that keeps the panel from showing numbers for a window the
+// user already left. These drive that race directly.
+
+/** Minimal projection — only what the store stores and these assertions read. */
+function view(over: Partial<ReportsView> = {}): ReportsView {
+  return {
+    window: '7d',
+    generatedAt: 1_000,
+    since: 0,
+    workspaceId: null,
+    currency: 'EUR',
+    totals: { inputTokens: 0, outputTokens: 0, calls: 0, meteredCost: 0, subscriptionCost: 0 },
+    spend: { byModel: [], byAgentKind: [], byWorkspace: [], byService: [], byTaskType: [] },
+    activity: { byWorkspace: [], byService: [], byTaskType: [] },
+    trend: { bucketMs: 1_000, points: [] },
+    ...over,
+  } as ReportsView
+}
+
+/** Seed an active account, since every load is scoped to one. */
+function seedAccount() {
+  const accounts = useAccountsStore()
+  accounts.accounts = [
+    {
+      id: 'acc1',
+      type: 'org',
+      name: 'Acme',
+      githubAccountLogin: null,
+      createdAt: 0,
+      roles: null,
+    },
+  ] as never
+  accounts.activeAccountId = 'acc1'
+}
+
+describe('reports store — concurrent loads', () => {
+  beforeEach(() => {
+    seedAccount()
+  })
+
+  it('a stale load never overwrites a fresher one that already resolved', async () => {
+    // The user picks 24h, then immediately 90d. The 24h request is slower and lands LAST;
+    // committing it would leave the panel labelled 90d while showing 24h numbers.
+    let resolveSlow!: (v: ReportsView) => void
+    const slow = new Promise<ReportsView>((res) => {
+      resolveSlow = res
+    })
+    const responses: Record<string, Promise<ReportsView>> = {
+      '24h': slow,
+      '90d': Promise.resolve(view({ window: '90d', totals: { ...view().totals, calls: 42 } })),
+    }
+    vi.stubGlobal('useApi', () => ({
+      getReports: (_id: string, window: string) => responses[window]!,
+    }))
+    const store = useReportsStore()
+
+    const first = store.setWindow('24h')
+    const second = store.setWindow('90d')
+    await second
+    resolveSlow(view({ window: '24h', totals: { ...view().totals, calls: 7 } }))
+    await first
+
+    expect(store.view?.window).toBe('90d')
+    expect(store.view?.totals.calls).toBe(42)
+    // The superseded load must not resurrect the spinner it started either.
+    expect(store.loading).toBe(false)
+  })
+
+  it('a superseded FAILURE never replaces the newer view with an error', async () => {
+    // The same race the other way round: an in-flight load rejects after a later
+    // one succeeded. Committing it would blank a perfectly good panel.
+    let rejectSlow!: (e: Error) => void
+    const slow = new Promise<ReportsView>((_res, rej) => {
+      rejectSlow = rej
+    })
+    const responses: Record<string, Promise<ReportsView>> = {
+      '24h': slow,
+      '90d': Promise.resolve(view({ window: '90d' })),
+    }
+    vi.stubGlobal('useApi', () => ({
+      getReports: (_id: string, window: string) => responses[window]!,
+    }))
+    const store = useReportsStore()
+
+    const first = store.setWindow('24h')
+    await store.setWindow('90d')
+    rejectSlow(new Error('gateway timeout'))
+    await first
+
+    expect(store.failed).toBe(false)
+    expect(store.error).toBeNull()
+    expect(store.view?.window).toBe('90d')
+  })
+
+  it('records a failure from the newest load, with the raw message as detail', async () => {
+    vi.stubGlobal('useApi', () => ({
+      getReports: () => Promise.reject(new Error('reports are not available')),
+    }))
+    const store = useReportsStore()
+    await store.load()
+    expect(store.failed).toBe(true)
+    // Raw backend prose only — the localized heading is the panel's job.
+    expect(store.error).toBe('reports are not available')
+    expect(store.loading).toBe(false)
+  })
+})

package/app/stores/reports.ts

@@ -0,0 +1,91 @@
+import { defineStore } from 'pinia'
+import { computed, ref } from 'vue'
+import type { ReportWindow, ReportsView } from '~/types/execution'
+import { useAccountsStore } from '~/stores/accounts'
+
+/**
+ * Reports: cross-cutting usage analytics for the active account — spend per model and
+ * agent kind, spend + run activity per workspace / service / task type, and a spend trend,
+ * over a selectable window and optionally narrowed to one board.
+ *
+ * The sibling of the `platformObservability` store: same account scope, same admin gate,
+ * same on-demand load. Nothing is pushed live (these are periodic rollups); changing the
+ * window or the board filter re-fetches, and a manual refresh re-fetches unconditionally.
+ */
+export const useReportsStore = defineStore('reports', () => {
+  const api = useApi()
+  const accounts = useAccountsStore()
+
+  const window = ref<ReportWindow>('7d')
+  /** The single board every breakdown is narrowed to, or null for the whole account. */
+  const workspaceFilter = ref<string | null>(null)
+  const view = ref<ReportsView | null>(null)
+  const loading = ref(false)
+  /** Whether the last load failed. The panel owns the localized wording. */
+  const failed = ref(false)
+  /**
+   * The backend's raw (untranslated) message for a failed load, shown beneath the localized
+   * heading as a last-resort detail — null when the failure carried no message at all.
+   */
+  const error = ref<string | null>(null)
+
+  const accountId = computed(() => accounts.activeAccount?.id ?? null)
+
+  /**
+   * Monotonicity guard. The window buttons, the board filter and the refresh button can each
+   * start a load, so two are easily in flight at once — and without this a staler response
+   * resolving later would overwrite the newer view (and its `loading`/error state) with
+   * numbers for a window the user already moved off. Only the newest load may commit.
+   */
+  let latest = 0
+
+  async function load() {
+    const id = accountId.value
+    if (!id) {
+      view.value = null
+      return
+    }
+    const seq = ++latest
+    loading.value = true
+    failed.value = false
+    error.value = null
+    try {
+      const next = await api.getReports(id, window.value, workspaceFilter.value)
+      if (seq !== latest) return
+      view.value = next
+    } catch (err) {
+      if (seq !== latest) return
+      failed.value = true
+      error.value = err instanceof Error ? err.message : null
+    } finally {
+      if (seq === latest) loading.value = false
+    }
+  }
+
+  /** Switch the window and reload (a no-op when it is already the loaded one). */
+  async function setWindow(next: ReportWindow) {
+    if (next === window.value && view.value) return
+    window.value = next
+    await load()
+  }
+
+  /** Narrow to one board (null = the whole account) and reload. */
+  async function setWorkspaceFilter(next: string | null) {
+    if (next === workspaceFilter.value && view.value) return
+    workspaceFilter.value = next
+    await load()
+  }
+
+  return {
+    window,
+    workspaceFilter,
+    view,
+    loading,
+    failed,
+    error,
+    accountId,
+    load,
+    setWindow,
+    setWorkspaceFilter,
+  }
+})

package/app/stores/ui/modals.ts

@@ -440,6 +440,10 @@ function createIntegrationPanelModals(resetHubReturn: ResetHubReturn) {
   // from `observabilityConnectionOpen` (the Datadog connection) AND `observabilityInstanceId`
   // (the per-run LLM call panel).
   const operatorDashboardOpen = ref(false)
+  // Reports: the cross-cutting usage-analytics panel over the same account scope (spend per
+  // model / agent kind, spend + activity per workspace / service / task type). Admin-gated.
+  // Distinct from `operatorDashboardOpen`, which answers the deployment-HEALTH question.
+  const reportsOpen = ref(false)
   // Private package registries: the workspace's npm/GitHub-Packages entries agent
   // containers install with. Opened from the Integrations hub.
   const packageRegistriesOpen = ref(false)
@@ -486,6 +490,13 @@ function createIntegrationPanelModals(resetHubReturn: ResetHubReturn) {
   function closeOperatorDashboard() {
     operatorDashboardOpen.value = false
   }
+  function openReports() {
+    resetHubReturn()
+    reportsOpen.value = true
+  }
+  function closeReports() {
+    reportsOpen.value = false
+  }
   function openPackageRegistries() {
     resetHubReturn()
     packageRegistriesOpen.value = true
@@ -544,6 +555,7 @@ function createIntegrationPanelModals(resetHubReturn: ResetHubReturn) {
     slackOpen,
     observabilityConnectionOpen,
     operatorDashboardOpen,
+    reportsOpen,
     packageRegistriesOpen,
     apiTokensOpen,
     modelConfigOpen,
@@ -559,6 +571,8 @@ function createIntegrationPanelModals(resetHubReturn: ResetHubReturn) {
     openObservabilityConnection,
     closeObservabilityConnection,
     openOperatorDashboard,
+    openReports,
+    closeReports,
     closeOperatorDashboard,
     openPackageRegistries,
     closePackageRegistries,

package/app/types/execution.ts

@@ -30,6 +30,14 @@ export type {
   PlatformOutcomeTotals,
   PlatformTrendPoint,
   PlatformFailureSlice,
+  ReportWindow,
+  ReportSpendDimension,
+  ReportActivityDimension,
+  ReportSpendRow,
+  ReportActivityRow,
+  ReportTrendPoint,
+  ReportTotals,
+  ReportsView,
   AgentSearchQuery,
   WebSearchAvailability,
   WebSearchProvider,

package/app/utils/apiOrigin.spec.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest'
+import { apiOriginFor, wsOriginFor } from '~/utils/apiOrigin'
+
+// The split-origin deployment (an absolute apiBase) and the same-origin one (empty apiBase, one
+// reverse proxy in front of both halves — the compose preview stack) must both produce a usable
+// socket origin. An empty apiBase used to yield a RELATIVE WebSocket URL, which is exactly the
+// case a preview stack hits: its host port is assigned at `up` time, so no absolute origin can be
+// baked into the build.
+
+describe('apiOriginFor', () => {
+  it('keeps an absolute apiBase (split origins)', () => {
+    expect(apiOriginFor('https://api.example.com', 'https://app.example.com')).toBe(
+      'https://api.example.com',
+    )
+  })
+
+  it('falls back to the page origin when apiBase is empty or blank (same origin)', () => {
+    expect(apiOriginFor('', 'http://localhost:49153')).toBe('http://localhost:49153')
+    expect(apiOriginFor('   ', 'http://localhost:49153')).toBe('http://localhost:49153')
+  })
+
+  it('is empty when neither is known (SSR — no socket is opened there)', () => {
+    expect(apiOriginFor('', '')).toBe('')
+  })
+})
+
+describe('wsOriginFor', () => {
+  it('maps http→ws and https→wss', () => {
+    expect(wsOriginFor('http://localhost:8787', '')).toBe('ws://localhost:8787')
+    expect(wsOriginFor('https://api.example.com', '')).toBe('wss://api.example.com')
+  })
+
+  it('derives the socket origin from the page for a same-origin deployment', () => {
+    expect(wsOriginFor('', 'https://preview.example.com')).toBe('wss://preview.example.com')
+    expect(wsOriginFor('', 'http://localhost:49153')).toBe('ws://localhost:49153')
+  })
+})

package/app/utils/apiOrigin.ts

@@ -0,0 +1,30 @@
+/**
+ * Where the SPA's API lives, resolved from the build-time `runtimeConfig.public.apiBase`.
+ *
+ * Two deployment topologies are supported and they differ ONLY here:
+ *
+ * - **Split origins** (the production Cloudflare/Node deployments): `apiBase` is an absolute
+ *   origin (`https://api.example.com`), the SPA is served from a different one, and the backend
+ *   allow-lists the SPA via `CORS_ALLOWED_ORIGINS`.
+ * - **Same origin**: `apiBase` is EMPTY and one reverse proxy serves both the static SPA and the
+ *   API (the compose preview stack in `deploy/preview/compose`). REST calls are then relative and
+ *   need nothing extra — but the WebSocket URL does, because the socket origin cannot be derived
+ *   from an empty string. That is what this module exists for: it substitutes the PAGE's origin,
+ *   so the stream connects to whatever host/port the stack happens to be published on. A preview
+ *   stack's host port is assigned at `up` time, so it is not knowable when the SPA is built —
+ *   same-origin is the only topology that works there.
+ */
+
+/** The API origin the SPA should talk to: `apiBase` when set, else the page's own origin. */
+export function apiOriginFor(apiBase: string, pageOrigin: string): string {
+  return apiBase.trim() || pageOrigin
+}
+
+/**
+ * The WebSocket origin (`http`→`ws`, `https`→`wss`) for the API. Falls back to `pageOrigin` for
+ * the same-origin topology; returns `''` only when neither is known (SSR, where no socket is
+ * opened anyway).
+ */
+export function wsOriginFor(apiBase: string, pageOrigin: string): string {
+  return apiOriginFor(apiBase, pageOrigin).replace(/^http/, 'ws')
+}

package/i18n/locales/de.json

@@ -173,7 +173,26 @@
         "loading": "Infrastruktureinstellungen werden geladen…",
         "kubeNoun": "der Kubernetes-Handler",
         "kubeOverrideNoun": "der Kubernetes-Override",
-        "customNoun": "dieser Handler"
+        "customNoun": "dieser Handler",
+        "cloudflareNoun": "den Cloudflare-Handler"
+      },
+      "cloudflare": {
+        "intro": "Startet pro Pull Request einen Cloudflare Worker, indem der Preview-Workflow des Ziel-Repositorys angestoßen wird. cat-factory spricht nie direkt mit Cloudflare: Es legt ein Deployment an, liest dessen Status und setzt zum Abbau einen inactive-Status.",
+        "label": "Anzeigename",
+        "subdomain": "workers.dev-Subdomain",
+        "subdomainHint": "Die Preview-URL lautet https://WORKER.SUBDOMAIN.workers.dev — gib nur das Subdomain-Label ein, ohne \".workers.dev\".",
+        "token": "VCS-API-Token",
+        "tokenPlaceholder": "Fein granuliertes Token einfügen",
+        "tokenKeep": "Leer lassen, um das gespeicherte Token zu behalten",
+        "tokenHint": "Benötigt \"Deployments: read & write\" für das Repository und sonst nichts.",
+        "repo": "Workflow-Repository (optional)",
+        "repoHint": "Leer lassen, um das jeweilige Repository des Service-Frames zu verwenden. Nur festlegen, wenn ein Repository den Preview-Workflow für mehrere Services enthält.",
+        "advanced": "Erweitert",
+        "workerTemplate": "Vorlage für den Worker-Namen",
+        "environmentTemplate": "Vorlage für den Deployment-Umgebungsnamen",
+        "templateHint": "Diese Werte sind der Vertrag mit dem Preview-Workflow: cat-factory leitet daraus die URL ab, und der Workflow benennt seine Ressourcen genauso. Leer lassen, um die Benennung des Referenz-Workflows zu verwenden. Verfügbare Platzhalter: pullNumber, branch, blockId.",
+        "apiBaseUrl": "Basis-URL der VCS-API",
+        "connectedAs": "Previews werden auf {subdomain}.workers.dev bereitgestellt."
       }
     },
     "providerConnection": {
@@ -1100,6 +1119,7 @@
         "infraless": "Keine Infrastruktur",
         "docker-compose": "Docker Compose",
         "kubernetes": "Kubernetes",
+        "cloudflare": "Cloudflare Workers-Preview",
         "custom": "Benutzerdefiniert"
       },
       "composePath": "docker-compose-Pfad",
@@ -1142,6 +1162,7 @@
       "rendererHint": "Raw wendet die Manifeste unverändert an. Kustomize baut zuerst ein Overlay (benötigt den Container-Deploy-Adapter).",
       "customManifestId": "Benutzerdefinierter Manifesttyp",
       "customManifestIdPlaceholder": "Wähle einen Manifesttyp",
+      "cloudflareHint": "Hier gibt es nichts zu konfigurieren: Das Rezept pro Pull Request liegt im Preview-Workflow dieses Repositorys. Verbinde unter Infrastruktur einen Cloudflare Workers-Handler, um Konto und Benennung festzulegen.",
       "customNoTypes": "Es sind noch keine benutzerdefinierten Manifesttypen definiert. Füge einen im Infrastruktur-Fenster hinzu.",
       "customManifestIdHint": "Der benutzerdefinierte Typ, den dieser Service erzeugt, zugeordnet zu einem Remote-Custom-Handler, den der Workspace konfiguriert.",
       "customManifestPath": "Manifest-Pfad (optional)",
@@ -2979,6 +3000,70 @@
       "title": "Jetzt aktiv"
     }
   },
+  "reports": {
+    "title": "Berichte",
+    "refresh": "Aktualisieren",
+    "loading": "Berichte werden geladen…",
+    "retry": "Erneut versuchen",
+    "error": "Berichte konnten nicht geladen werden.",
+    "period": "{from} bis {to}",
+    "unattributed": "Nicht zugeordnet",
+    "window": {
+      "oneDay": "Letzte 24 Stunden",
+      "sevenDays": "Letzte 7 Tage",
+      "thirtyDays": "Letzte 30 Tage",
+      "ninetyDays": "Letzte 90 Tage"
+    },
+    "filter": {
+      "board": "Board",
+      "allBoards": "Alle Boards"
+    },
+    "dimension": {
+      "workspace": "Board",
+      "service": "Service",
+      "taskType": "Aufgabentyp"
+    },
+    "breakdown": {
+      "title": "Aufschlüsselung nach"
+    },
+    "totals": {
+      "title": "In diesem Zeitraum",
+      "metered": "Abgerechnete Kosten",
+      "subscription": "Abo",
+      "calls": "LLM-Aufrufe",
+      "tokens": "Tokens",
+      "illustrative": "Abokosten sind nur kalkulatorisch – diese Tarife sind pauschal, werden nicht pro Token abgerechnet und zählen nie als Ausgaben."
+    },
+    "trend": {
+      "title": "Kosten im Zeitverlauf",
+      "empty": "In diesem Zeitraum wurde keine Nutzung erfasst."
+    },
+    "legend": {
+      "metered": "Abgerechnet",
+      "subscription": "Abo"
+    },
+    "spend": {
+      "byModel": "Kosten nach Modell",
+      "byAgentKind": "Kosten nach Agententyp",
+      "heading": "Kosten",
+      "empty": "In diesem Zeitraum wurde keine Nutzung erfasst.",
+      "calls": "{count} Aufruf | {count} Aufrufe",
+      "tokens": "{input} rein / {output} raus",
+      "subscriptionAside": "+{value} Abo"
+    },
+    "activity": {
+      "heading": "Läufe",
+      "empty": "In diesem Zeitraum gab es keine Läufe.",
+      "runs": "{count} Lauf | {count} Läufe",
+      "avg": "Ø {value}"
+    },
+    "status": {
+      "done": "Abgeschlossen",
+      "failed": "Fehlgeschlagen",
+      "running": "Läuft",
+      "other": "Sonstige"
+    }
+  },
   "auth": {
     "gate": {
       "loading": "Wird geladen…"
@@ -4138,6 +4223,7 @@
     "modelConfiguration": "Modellkonfiguration",
     "accountSettings": "Kontoeinstellungen",
     "operatorDashboard": "Plattform-Observability",
+    "reports": "Berichte",
     "environmentSetup": "Umgebungseinrichtung"
   },
   "errors": {
@@ -4756,6 +4842,7 @@
     "provisionType": {
       "kubernetes": "Kubernetes",
       "docker-compose": "Docker Compose",
+      "cloudflare": "Cloudflare Workers",
       "custom": "Benutzerdefiniert",
       "infraless": "Keine Infrastruktur"
     },
@@ -4763,6 +4850,7 @@
       "local-docker": "Lokales Docker",
       "local-k3s": "Lokales k3s",
       "remote-kubernetes": "Remote-Kubernetes",
+      "cloudflare": "Cloudflare-Preview",
       "remote-custom": "Remote benutzerdefiniert (HTTP)",
       "none": "Keine"
     }

package/i18n/locales/en.json

@@ -130,6 +130,7 @@
     "modelConfiguration": "Model configuration",
     "accountSettings": "Account settings",
     "operatorDashboard": "Platform observability",
+    "reports": "Reports",
     "environmentSetup": "Environment setup"
   },
   "board": {
@@ -860,6 +861,7 @@
         "infraless": "No infrastructure",
         "docker-compose": "Docker Compose",
         "kubernetes": "Kubernetes",
+        "cloudflare": "Cloudflare Workers preview",
         "custom": "Custom"
       },
       "composePath": "docker-compose path",
@@ -902,6 +904,7 @@
       "rendererHint": "Raw applies the manifests as-is. Kustomize builds an overlay first (needs the container deploy adapter).",
       "customManifestId": "Custom manifest type",
       "customManifestIdPlaceholder": "Pick a manifest type",
+      "cloudflareHint": "Nothing to configure here: the per-pull-request recipe lives in this repository’s own preview workflow. Connect a Cloudflare Workers handler under Infrastructure to choose the account and the naming.",
       "customNoTypes": "No custom manifest types are defined yet. Add one in the Infrastructure window.",
       "customManifestIdHint": "The custom type this service produces, matched to a remote-custom handler the workspace configures.",
       "customManifestPath": "Manifest path (optional)",
@@ -1522,6 +1525,70 @@
       "title": "Live now"
     }
   },
+  "reports": {
+    "title": "Reports",
+    "refresh": "Refresh",
+    "loading": "Loading reports…",
+    "retry": "Retry",
+    "error": "Reports could not be loaded.",
+    "period": "{from} to {to}",
+    "unattributed": "Unattributed",
+    "window": {
+      "oneDay": "Last 24 hours",
+      "sevenDays": "Last 7 days",
+      "thirtyDays": "Last 30 days",
+      "ninetyDays": "Last 90 days"
+    },
+    "filter": {
+      "board": "Board",
+      "allBoards": "All boards"
+    },
+    "dimension": {
+      "workspace": "Board",
+      "service": "Service",
+      "taskType": "Task type"
+    },
+    "breakdown": {
+      "title": "Breakdown by"
+    },
+    "totals": {
+      "title": "This window",
+      "metered": "Metered spend",
+      "subscription": "Subscription",
+      "calls": "LLM calls",
+      "tokens": "Tokens",
+      "illustrative": "Subscription costs are illustrative — those plans are flat-rate, not billed per token, and are never counted as spend."
+    },
+    "trend": {
+      "title": "Spend over time",
+      "empty": "No recorded usage in this window."
+    },
+    "legend": {
+      "metered": "Metered",
+      "subscription": "Subscription"
+    },
+    "spend": {
+      "byModel": "Spend by model",
+      "byAgentKind": "Spend by agent kind",
+      "heading": "Spend",
+      "empty": "No recorded usage in this window.",
+      "calls": "{count} call | {count} calls",
+      "tokens": "{input} in / {output} out",
+      "subscriptionAside": "+{value} subscription"
+    },
+    "activity": {
+      "heading": "Runs",
+      "empty": "No runs in this window.",
+      "runs": "{count} run | {count} runs",
+      "avg": "avg {value}"
+    },
+    "status": {
+      "done": "Completed",
+      "failed": "Failed",
+      "running": "Running",
+      "other": "Other"
+    }
+  },
   "auth": {
     "gate": {
       "loading": "Loading…"
@@ -2256,7 +2323,26 @@
         "loading": "Loading infrastructure settings…",
         "kubeNoun": "the Kubernetes handler",
         "kubeOverrideNoun": "the Kubernetes override",
-        "customNoun": "this handler"
+        "customNoun": "this handler",
+        "cloudflareNoun": "the Cloudflare handler"
+      },
+      "cloudflare": {
+        "intro": "Stands up a per-pull-request Cloudflare Worker by driving the target repository's own preview workflow. cat-factory never talks to Cloudflare directly: it creates a deployment, reads its status, and posts an inactive status to tear down.",
+        "label": "Display name",
+        "subdomain": "workers.dev subdomain",
+        "subdomainHint": "The preview URL becomes https://WORKER.SUBDOMAIN.workers.dev — enter just the subdomain label, without \".workers.dev\".",
+        "token": "VCS API token",
+        "tokenPlaceholder": "Paste a fine-grained token",
+        "tokenKeep": "Leave blank to keep the stored token",
+        "tokenHint": "Needs Deployments: read & write on the repository, and nothing else.",
+        "repo": "Workflow repository (optional)",
+        "repoHint": "Leave blank to use each service frame's own repository. Pin it only when one repository holds the preview workflow for several services.",
+        "advanced": "Advanced",
+        "workerTemplate": "Worker name template",
+        "environmentTemplate": "Deployment environment template",
+        "templateHint": "These are the contract with the preview workflow: cat-factory derives the URL from them and the workflow names its resources the same way. Leave blank to use the reference workflow's naming. Available placeholders: pullNumber, branch, blockId.",
+        "apiBaseUrl": "VCS API base URL",
+        "connectedAs": "Previews deploy to {subdomain}.workers.dev."
       }
     },
     "providerConnection": {
@@ -4599,6 +4685,7 @@
     "provisionType": {
       "kubernetes": "Kubernetes",
       "docker-compose": "Docker Compose",
+      "cloudflare": "Cloudflare Workers",
       "custom": "Custom",
       "infraless": "No infrastructure"
     },
@@ -4606,6 +4693,7 @@
       "local-docker": "Local Docker",
       "local-k3s": "Local k3s",
       "remote-kubernetes": "Remote Kubernetes",
+      "cloudflare": "Cloudflare preview",
       "remote-custom": "Remote custom (HTTP)",
       "none": "None"
     }