@frontera-sdk/cli 1.50.24 → 1.50.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frontera-sdk/cli",
-  "version": "1.50.24",
+  "version": "1.50.26",
   "description": "The frontera CLI — scaffold, pull, save and deploy Frontera apps and automations.",
   "keywords": [
     "frontera",
@@ -39,14 +39,14 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.3.251",
-    "@frontera-sdk/functions": "1.50.24",
-    "@frontera-sdk/core": "1.50.24",
+    "@frontera-sdk/functions": "1.50.26",
+    "@frontera-sdk/core": "1.50.26",
     "ai": "^6.0.116",
     "gray-matter": "^4.0.3",
     "yaml": "^2.9.0"
   },
   "devDependencies": {
-    "@frontera-sdk/forge-contracts": "1.50.24",
+    "@frontera-sdk/forge-contracts": "1.50.26",
     "@types/bun": "^1.3.14",
     "typescript": "^5.9.3"
   }

package/src/api/workflow-api.ts

@@ -29,6 +29,17 @@ export interface WorkflowSummary {
   cron: string | null
   subjectApiName: string | null
   subjectLabel: string | null
+  /** One per webhook trigger. Absent from a service that predates webhooks. */
+  webhooks?: WorkflowWebhook[]
+}
+
+export interface WorkflowWebhook {
+  methods: string[]
+  path: string
+  auth: string
+  respond: string
+  url: string
+  testUrl: string
 }
 
 /** A row of `GET /v1/workflows/:slug/versions`. */

package/src/commands/app/init.ts

@@ -238,8 +238,9 @@ export const appInit: Command = {
 
     let installed = false
     if (!flagBool(ctx, 'no-install')) {
-      ctx.output.note('Installing dependencies with bun…')
-      const result = await installDependencies(target)
+      const result = await ctx.output.task('Installing dependencies with bun', () =>
+        installDependencies(target),
+      )
       installed = result.installed
       ctx.output.note(
         result.installed
@@ -255,8 +256,10 @@ export const appInit: Command = {
     // command that finishes the job instead of being swallowed.
     let components = false
     if (framework === 'next' && !flagBool(ctx, 'no-components')) {
-      ctx.output.note(`Adding shadcn components: ${BASELINE_COMPONENTS.join(', ')}…`)
-      const result = await addShadcnComponents(target)
+      const result = await ctx.output.task(
+        `Adding shadcn components: ${BASELINE_COMPONENTS.join(', ')}`,
+        () => addShadcnComponents(target),
+      )
       components = result.added
       ctx.output.note(result.added ? `  ${result.summary}` : `  not added: ${result.summary}`)
       ctx.output.note('')

package/src/commands/workflow/get.ts

@@ -25,12 +25,17 @@ export const workflowGet: Command = {
     const slug = requireSlug(ctx)
     const client = new WorkflowApi(ctx.apiUrl, ctx.token, ctx.workspaceId)
     const [workflow, versions] = await Promise.all([client.get(slug), client.versions(slug)])
+    const webhooks = (workflow.webhooks ?? []).flatMap((h) => {
+      const methods = h.methods.join(',')
+      return [`${methods} ${h.url}  (${h.auth}, ${h.respond})`, `${'test'.padEnd(methods.length)} ${h.testUrl}`]
+    })
 
     const facts = [
       `${workflow.slug}${workflow.enabled ? '' : '  (disabled)'}`,
       workflow.description ? `  ${workflow.description}` : '',
       `  live       ${workflow.liveVersion === null ? 'nothing — no version has been promoted' : `v${workflow.liveVersion}`}`,
       `  triggers   ${(workflow.triggerKinds ?? []).join(', ') || 'none'}`,
+      webhooks.length > 0 ? `  webhooks   ${webhooks.join('\n             ')}` : '',
       // Only when bound. An unbound workflow has no subject line to print, and
       // an empty one reads as a missing value rather than an absent concept.
       workflow.subjectApiName ? `  subject    ${workflow.subjectLabel ?? workflow.subjectApiName}` : '',

package/src/output.ts

@@ -12,10 +12,51 @@ export interface Output {
   render(data: unknown, toText: (data: unknown) => string): void
   /** Progress and warnings. Always stderr, so piping stays clean. */
   note(message: string): void
+  /**
+   * Run something slow and say so while it runs.
+   *
+   * `note` announces and then goes quiet, which is fine for a step that takes
+   * a moment and wrong for one that takes half a minute: installing packages
+   * and adding components both sit there with a cursor and no evidence the
+   * command is alive. This keeps a line moving for exactly as long as the work
+   * takes, then replaces it with the outcome and how long it took.
+   *
+   * The value and the failure both pass straight through — this is a wrapper
+   * around work, not a place where errors are handled.
+   */
+  task<T>(label: string, run: () => Promise<T>): Promise<T>
   /** Report a failure and return the exit code the shell should use. */
   fail(err: unknown): ExitCode
 }
 
+/**
+ * Braille frames: one character wide in every terminal font, so the line does
+ * not jump as it spins.
+ */
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+const SPINNER_INTERVAL_MS = 80
+
+/**
+ * Colour for the progress line, decided against STDERR.
+ *
+ * `help.ts` asks the same question of stdout, which is right for help text and
+ * wrong here: progress is written to stderr, and a run whose stdout is piped
+ * into a file still has a terminal on the other stream. Honouring NO_COLOR the
+ * same way keeps one rule across the CLI.
+ */
+function colorOnErr(): boolean {
+  if (process.env.NO_COLOR !== undefined) return false
+  if (process.env.FORCE_COLOR !== undefined) return true
+  return process.stderr.isTTY === true
+}
+
+const paintErr = (code: string) => (text: string) =>
+  colorOnErr() ? `\u001b[${code}m${text}\u001b[39m` : text
+
+const green = paintErr('32')
+const red = paintErr('31')
+const grey = paintErr('90')
+
 const defaultStreams: Streams = {
   out: (chunk) => process.stdout.write(chunk),
   err: (chunk) => process.stderr.write(chunk),
@@ -51,6 +92,52 @@ export function createOutput(
       streams.err(`${message}\n`)
     },
 
+    async task(label, run) {
+      // Animation only where a human is watching. Piped or redirected, the
+      // carriage returns would land in the file as one unreadable line, and in
+      // CI logs as thousands of them — so those get the label once and the
+      // result once, which is what a log is for.
+      const animate = !quiet && streams === defaultStreams && process.stderr.isTTY === true
+      if (quiet) return run()
+      if (!animate) {
+        streams.err(`${label}\n`)
+        return run()
+      }
+
+      const started = Date.now()
+      let frame = 0
+      const paint = () => {
+        // The frame itself stays the terminal's own colour: it is motion, not
+        // status. Colour arrives once with the ✓ or ✗, where it means something.
+        const spin = SPINNER_FRAMES[frame++ % SPINNER_FRAMES.length]!
+        streams.err(`\r\u001b[2K${spin} ${label}`)
+      }
+      paint()
+      const timer = setInterval(paint, SPINNER_INTERVAL_MS)
+
+      // `unref` so a spinner can never be the reason the process stays alive:
+      // a timer is a handle, and one left running outlives the work it was
+      // describing.
+      timer.unref?.()
+
+      const stop = (mark: string) => {
+        clearInterval(timer)
+        const seconds = ((Date.now() - started) / 1000).toFixed(1)
+        streams.err(`\r\u001b[2K${mark} ${label} ${grey(`[${seconds}s]`)}\n`)
+      }
+
+      try {
+        const result = await run()
+        stop(green('✓'))
+        return result
+      } catch (err) {
+        // The line is closed before the error travels on, or the failure prints
+        // over a half-finished spinner.
+        stop(red('✗'))
+        throw err
+      }
+    },
+
     fail(err) {
       const envelope = toEnvelope(err)
       if (mode === 'json') {