padrone 1.5.0 → 1.7.0

package/src/extension/progress-renderer.ts

@@ -0,0 +1,338 @@
+import type {
+  PadroneBarConfig,
+  PadroneProgressIndicator,
+  PadroneProgressOptions,
+  PadroneProgressShow,
+  PadroneProgressUpdate,
+  PadroneSpinnerConfig,
+  PadroneSpinnerPreset,
+} from '../core/runtime.ts';
+
+// ---------------------------------------------------------------------------
+// Spinner presets & resolution
+// ---------------------------------------------------------------------------
+
+const spinnerPresets: Record<PadroneSpinnerPreset, string[]> = {
+  dots: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
+  line: ['-', '\\', '|', '/'],
+  arc: ['◜', '◠', '◝', '◞', '◡', '◟'],
+  bounce: ['⠁', '⠂', '⠄', '⡀', '⢀', '⠠', '⠐', '⠈'],
+};
+
+type ResolvedSpinnerConfig = { frames: string[]; interval: number; show: PadroneProgressShow };
+
+function resolveSpinnerConfig(config?: PadroneSpinnerConfig): ResolvedSpinnerConfig {
+  if (config === false) return { frames: [], interval: 80, show: 'never' };
+  if (config === true) return { frames: spinnerPresets.dots, interval: 80, show: 'always' };
+  if (typeof config === 'string') return { frames: spinnerPresets[config], interval: 80, show: 'auto' };
+  if (typeof config === 'object') {
+    return {
+      frames: config.frames ?? spinnerPresets.dots,
+      interval: config.interval ?? 80,
+      show: config.show ?? 'auto',
+    };
+  }
+  return { frames: spinnerPresets.dots, interval: 80, show: 'auto' };
+}
+
+// ---------------------------------------------------------------------------
+// Bar resolution & rendering
+// ---------------------------------------------------------------------------
+
+type ResolvedBarConfig = {
+  width: number;
+  filled: string;
+  empty: string;
+  animation: 'bounce' | 'slide' | 'pulse';
+  show: PadroneProgressShow;
+};
+
+const defaultBarConfig: ResolvedBarConfig = { width: 20, filled: '█', empty: '░', animation: 'bounce', show: 'auto' };
+
+function resolveBarConfig(bar: boolean | PadroneBarConfig | undefined): ResolvedBarConfig | undefined {
+  if (bar === false) return undefined;
+  if (!bar) return { ...defaultBarConfig };
+  if (bar === true) return { ...defaultBarConfig, show: 'always' };
+  return {
+    width: bar.width ?? 20,
+    filled: bar.filled ?? '█',
+    empty: bar.empty ?? '░',
+    animation: bar.animation ?? 'bounce',
+    show: bar.show ?? 'always',
+  };
+}
+
+const SEGMENT_RATIO = 0.25;
+const pulseGradient = ['░', '▒', '▓', '█', '▓', '▒', '░'];
+
+function formatIndeterminate(cfg: ResolvedBarConfig, frame: number): string {
+  const { width, filled, empty, animation } = cfg;
+  const pad = ''.padStart(4);
+
+  if (animation === 'pulse') {
+    const idx = frame % pulseGradient.length;
+    return `${pad} ${pulseGradient[idx]!.repeat(width)}`;
+  }
+
+  const seg = Math.max(2, Math.round(width * SEGMENT_RATIO));
+  const travel = width - seg;
+
+  if (animation === 'slide') {
+    const offset = frame % (travel + 1);
+    return `${pad} ${empty.repeat(offset)}${filled.repeat(seg)}${empty.repeat(travel - offset)}`;
+  }
+
+  // bounce (default)
+  const cycle = travel * 2;
+  const pos = frame % cycle;
+  const offset = pos <= travel ? pos : cycle - pos;
+  return `${pad} ${empty.repeat(offset)}${filled.repeat(seg)}${empty.repeat(width - offset - seg)}`;
+}
+
+function formatBar(progress: number | undefined, cfg: ResolvedBarConfig, frame: number): string {
+  if (progress === undefined) return formatIndeterminate(cfg, frame);
+  const { width, filled, empty } = cfg;
+  const clamped = Math.max(0, Math.min(1, progress));
+  const filledCount = Math.round(clamped * width);
+  const pct = `${Math.round(clamped * 100)}%`.padStart(4);
+  return `${pct} ${filled.repeat(filledCount)}${empty.repeat(width - filledCount)}`;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function parseUpdate(value: PadroneProgressUpdate): { message?: string; progress?: number; indeterminate?: boolean; time?: boolean } {
+  if (typeof value === 'string') return { message: value };
+  if (typeof value === 'number') return { progress: value };
+  return value;
+}
+
+function formatDuration(ms: number): string {
+  const totalSeconds = Math.floor(ms / 1000);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) return `${hours}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
+  return `${minutes}:${String(seconds).padStart(2, '0')}`;
+}
+
+function estimateEta(samples: { time: number; progress: number }[]): number | undefined {
+  if (samples.length < 2) return undefined;
+  const first = samples[0]!;
+  const last = samples[samples.length - 1]!;
+  const progressDelta = last.progress - first.progress;
+  if (progressDelta <= 0) return undefined;
+  const timeDelta = last.time - first.time;
+  const rate = progressDelta / timeDelta;
+  const remaining = 1 - last.progress;
+  if (remaining <= 0) return 0;
+  return remaining / rate;
+}
+
+// ---------------------------------------------------------------------------
+// Factory type
+// ---------------------------------------------------------------------------
+
+/** Factory function that creates a `PadroneProgressIndicator`. */
+export type PadroneProgressRenderer = (message: string, options?: PadroneProgressOptions) => PadroneProgressIndicator;
+
+// ---------------------------------------------------------------------------
+// Default terminal renderer
+// ---------------------------------------------------------------------------
+
+/**
+ * Creates a terminal progress indicator (spinner, bar, or both).
+ * Returns a no-op indicator in non-TTY/CI environments.
+ */
+export function createTerminalProgress(message: string, options?: PadroneProgressOptions): PadroneProgressIndicator {
+  const spinnerCfg = resolveSpinnerConfig(options?.spinner);
+  const successIcon = options?.successIndicator ?? '✔';
+  const errorIcon = options?.errorIndicator ?? '✖';
+  const barCfg = resolveBarConfig(options?.bar);
+
+  const formatFinal = (icon: string, msg: string) => (icon ? `${icon} ${msg}\n` : `${msg}\n`);
+
+  if (typeof process === 'undefined' || !process.stderr?.isTTY) {
+    return {
+      update() {},
+      succeed(msg, opts) {
+        if (msg === null) return;
+        const icon = opts?.indicator ?? successIcon;
+        if (msg || message) process?.stderr?.write?.(formatFinal(icon, msg || message));
+      },
+      fail(msg, opts) {
+        if (msg === null) return;
+        const icon = opts?.indicator ?? errorIcon;
+        if (msg || message) process?.stderr?.write?.(formatFinal(icon, msg || message));
+      },
+      stop() {},
+      pause() {},
+      resume() {},
+    };
+  }
+
+  // biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI escape stripping requires matching ESC
+  const ansiPattern = /\x1b\[[0-9;]*m/g;
+
+  if (spinnerCfg.show === 'never' && (!barCfg || barCfg.show === 'never') && !message) {
+    return { update() {}, succeed() {}, fail() {}, stop() {}, pause() {}, resume() {} };
+  }
+
+  const showTime = options?.time ?? false;
+  const showEta = options?.eta ?? false;
+
+  let spinnerFrame = 0;
+  let barFrame = 0;
+  let text = message;
+  let progress: number | undefined;
+  let indeterminate = false;
+  let stopped = false;
+  let paused = false;
+  let timeEnabled = showTime;
+  let startTime = showTime ? Date.now() : 0;
+  const etaSamples: { time: number; progress: number }[] = [];
+  let etaMs: number | undefined;
+  let etaCalculatedAt = 0;
+
+  const writeStderr = process.stderr.write.bind(process.stderr);
+  const writeStdout = process.stdout.write.bind(process.stdout);
+  let prevLineCount = 0;
+
+  const clearLines = () => {
+    if (prevLineCount > 1) {
+      // Move cursor up and clear each wrapped line above the current one
+      for (let i = 1; i < prevLineCount; i++) writeStderr('\x1b[1A\x1b[2K');
+    }
+    writeStderr('\x1b[2K\r');
+    prevLineCount = 0;
+  };
+
+  /** Count how many terminal rows `str` occupies, accounting for line wrapping. */
+  const lineCount = (str: string): number => {
+    const cols = process.stderr.columns || 80;
+    // Strip ANSI escape sequences for accurate width measurement
+    const visible = str.replace(ansiPattern, '');
+    return Math.max(1, Math.ceil(visible.length / cols));
+  };
+
+  const render = () => {
+    if (paused || stopped) return;
+
+    const barVisible = barCfg && (barCfg.show === 'always' || (barCfg.show === 'auto' && (progress !== undefined || indeterminate)));
+    const spinnerVisible = spinnerCfg.show === 'always' || (spinnerCfg.show === 'auto' && !barVisible);
+
+    let line = '';
+    if (barVisible) line += formatBar(progress, barCfg!, barFrame);
+    const hasEta = showEta && progress !== undefined && progress < 1 && etaMs !== undefined;
+    if (timeEnabled || hasEta) {
+      const parts: string[] = [];
+      if (timeEnabled) parts.push(`⏱ ${formatDuration(Date.now() - startTime)}`);
+      if (hasEta) {
+        const elapsed = Date.now() - etaCalculatedAt;
+        parts.push(`ETA ${formatDuration(Math.max(0, etaMs! - elapsed))}`);
+      }
+      if (line) line += ' ';
+      line += parts.join(' | ');
+    }
+    if (spinnerVisible) {
+      if (line) line += ' ';
+      line += frames[spinnerFrame] ?? '';
+    }
+    if (text) {
+      if (line) line += ' ';
+      line += text;
+    }
+
+    if (line) {
+      clearLines();
+      writeStderr(line);
+      prevLineCount = lineCount(line);
+    } else {
+      clearLines();
+    }
+  };
+
+  const { frames } = spinnerCfg;
+  const needsAnimation = spinnerCfg.show !== 'never' || (barCfg && barCfg.show !== 'never');
+  const tickInterval = barCfg && barCfg.show !== 'never' ? Math.min(80, spinnerCfg.interval) : spinnerCfg.interval;
+
+  const timer = needsAnimation
+    ? setInterval(() => {
+        spinnerFrame = (spinnerFrame + 1) % (frames.length || 1);
+        barFrame++;
+        render();
+      }, tickInterval)
+    : undefined;
+
+  render();
+
+  const clear = () => {
+    if (stopped) return;
+    stopped = true;
+    paused = false;
+    if (timer) clearInterval(timer);
+    clearLines();
+  };
+
+  return {
+    update(value) {
+      if (stopped) return;
+      const parsed = parseUpdate(value);
+      if (parsed.message !== undefined) text = parsed.message;
+      if (parsed.progress !== undefined) {
+        progress = parsed.progress;
+        if (showEta) {
+          const now = Date.now();
+          etaSamples.push({ time: now, progress: parsed.progress });
+          const estimated = estimateEta(etaSamples);
+          if (estimated !== undefined) {
+            etaMs = estimated;
+            etaCalculatedAt = now;
+          }
+        }
+      }
+      if (parsed.indeterminate !== undefined) {
+        indeterminate = parsed.indeterminate;
+        if (indeterminate) progress = undefined;
+      }
+      if (parsed.time !== undefined) {
+        if (parsed.time && !timeEnabled) {
+          timeEnabled = true;
+          startTime = Date.now();
+        } else if (!parsed.time) {
+          timeEnabled = false;
+        }
+      }
+      render();
+    },
+    succeed(msg, opts) {
+      clear();
+      if (msg === null) return;
+      const finalMsg = msg ?? text;
+      const icon = opts?.indicator ?? successIcon;
+      if (finalMsg) writeStderr(formatFinal(icon, finalMsg));
+    },
+    fail(msg, opts) {
+      clear();
+      if (msg === null) return;
+      const finalMsg = msg ?? text;
+      const icon = opts?.indicator ?? errorIcon;
+      if (finalMsg) writeStderr(formatFinal(icon, finalMsg));
+    },
+    stop() {
+      clear();
+    },
+    pause() {
+      if (stopped || paused) return;
+      paused = true;
+      clearLines();
+      writeStdout('\x1b[2K\r');
+    },
+    resume() {
+      if (stopped || !paused) return;
+      paused = false;
+      render();
+    },
+  };
+}

package/src/extension/progress.ts

@@ -0,0 +1,299 @@
+import { defineInterceptor } from '../core/interceptors.ts';
+import type { PadroneBarConfig, PadroneProgressIndicator, PadroneProgressOptions, PadroneSpinnerConfig } from '../core/runtime.ts';
+import type { AnyPadroneBuilder, CommandTypesBase } from '../types/index.ts';
+import type { WithInterceptor } from '../util/type-utils.ts';
+import type { PadroneProgressRenderer } from './progress-renderer.ts';
+import { createTerminalProgress } from './progress-renderer.ts';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/** A progress message value: a plain string, `null` to suppress, or an object with a message and custom indicator icon. */
+export type PadroneProgressMessage = string | null | { message?: string | null; indicator?: string };
+
+/** Per-phase message configuration for progress indicators. */
+export type PadroneProgressMessages<TRes = unknown> = {
+  /** Message shown during async validation. Defaults to `''` (spinner only). */
+  validation?: string;
+  /** Message shown while the command's action is running. */
+  progress?: string;
+  /** Message shown when the command succeeds. `null` to suppress. Defaults to the `progress` message. */
+  success?: PadroneProgressMessage | ((result: TRes) => PadroneProgressMessage);
+  /** Message shown when the command fails. `null` to suppress. Defaults to the error message. */
+  error?: PadroneProgressMessage | ((error: unknown) => PadroneProgressMessage);
+};
+
+/**
+ * Progress indicator configuration with messages, visual options, and renderer.
+ */
+export type PadroneProgressConfig<TRes = unknown> = {
+  /** Per-phase messages. A string sets the `progress` message; an object configures individual phases. */
+  message?: string | PadroneProgressMessages<TRes>;
+  /** Spinner configuration. Default `show` is `'auto'` (visible when bar is not shown). `true` forces spinner to always show (even alongside a bar). */
+  spinner?: PadroneSpinnerConfig;
+  /** Enable a progress bar. `true` for defaults (`show: 'always'`), or a `PadroneBarConfig` object. `false` to disable entirely. When omitted, bar defaults to `show: 'auto'`. */
+  bar?: boolean | PadroneBarConfig;
+  /** Show elapsed time since the indicator started. Can also be started on demand via `update({ time: true })`. */
+  time?: boolean;
+  /** Show estimated time remaining based on progress rate. Requires numeric `update()` calls. */
+  eta?: boolean;
+  /**
+   * Custom renderer factory. Called to create the progress indicator.
+   * Defaults to the built-in terminal renderer (`createTerminalProgress`).
+   */
+  renderer?: PadroneProgressRenderer;
+};
+
+/**
+ * Shared progress defaults that can be provided via context instead of repeating
+ * at each call site. Per-instance message fields are excluded — those always come
+ * from the constructor argument.
+ *
+ * Provide via context as `{ progressConfig: PadroneProgressDefaults }`.
+ */
+export type PadroneProgressDefaults = Pick<PadroneProgressConfig, 'message' | 'spinner' | 'bar' | 'time' | 'eta' | 'renderer'>;
+
+/** Builder/program type after applying `padroneProgress()`. Adds `{ progress: PadroneProgressIndicator }` to the command context. */
+export type WithProgress<T> = WithInterceptor<T, { progress: PadroneProgressIndicator }>;
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+const noopIndicator: PadroneProgressIndicator = {
+  update() {},
+  succeed() {},
+  fail() {},
+  stop() {},
+  pause() {},
+  resume() {},
+};
+
+function resolveMessage(field: unknown, value: unknown, fallback?: string): { message: string | null | undefined; indicator?: string } {
+  const raw = typeof field === 'function' ? (field as (v: unknown) => unknown)(value) : field;
+  if (raw === undefined) return { message: fallback };
+  if (raw === null || typeof raw === 'string') return { message: raw };
+  if (typeof raw === 'object' && raw !== null) {
+    const obj = raw as { message?: string | null; indicator?: string };
+    return { message: obj.message, indicator: obj.indicator };
+  }
+  return { message: fallback };
+}
+
+function cleanup(
+  indicator: PadroneProgressIndicator,
+  successConfig: unknown,
+  errorConfig: unknown,
+  error: unknown,
+  result: unknown,
+  isError: boolean,
+) {
+  if (isError) {
+    const fallback = error instanceof Error ? error.message : String(error);
+    const { message: errorMsg, indicator: errorIcon } = resolveMessage(errorConfig, error, fallback);
+    indicator.fail(errorMsg, errorIcon !== undefined ? { indicator: errorIcon } : undefined);
+  } else {
+    const { message: successMsg, indicator: successIcon } = resolveMessage(successConfig, result);
+    indicator.succeed(successMsg, successIcon !== undefined ? { indicator: successIcon } : undefined);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Interceptor
+// ---------------------------------------------------------------------------
+
+function resolveMessages(raw: string | PadroneProgressMessages | undefined): {
+  progress: string;
+  validation: string;
+  success: unknown;
+  error: unknown;
+} {
+  if (!raw || typeof raw === 'string') {
+    return { progress: raw || 'Working...', validation: '', success: undefined, error: undefined };
+  }
+  return {
+    progress: raw.progress ?? 'Working...',
+    validation: raw.validation ?? '',
+    success: raw.success,
+    error: raw.error,
+  };
+}
+
+function mergeMessages(
+  cmd: ReturnType<typeof resolveMessages>,
+  ctx: ReturnType<typeof resolveMessages>,
+  cmdRaw: string | PadroneProgressMessages | undefined,
+): ReturnType<typeof resolveMessages> {
+  // String shorthand: all fields come from the string, no context fallback for individual fields
+  if (typeof cmdRaw === 'string') return cmd;
+  // Object: per-field fallback to context
+  const obj = (typeof cmdRaw === 'object' ? cmdRaw : undefined) as PadroneProgressMessages | undefined;
+  return {
+    progress: obj?.progress !== undefined ? cmd.progress : (ctx.progress ?? cmd.progress),
+    validation: obj?.validation !== undefined ? cmd.validation : ctx.validation || cmd.validation,
+    success: obj?.success !== undefined ? cmd.success : (ctx.success ?? cmd.success),
+    error: obj?.error !== undefined ? cmd.error : (ctx.error ?? cmd.error),
+  };
+}
+
+function progressInterceptor(config: string | PadroneProgressConfig) {
+  const isObj = typeof config === 'object';
+  const rawMessage = typeof config === 'string' ? config : isObj ? config.message : undefined;
+  // Raw constructor values — undefined means "not set by caller"
+  const rawSpinner = isObj ? config.spinner : undefined;
+  const rawBar = isObj ? config.bar : undefined;
+  const rawRenderer = isObj ? config.renderer : undefined;
+  const rawTime = isObj ? config.time : undefined;
+  const rawEta = isObj ? config.eta : undefined;
+
+  return defineInterceptor({ id: 'padrone:progress', name: 'padrone:progress' })
+    .requires<{ progressConfig?: PadroneProgressDefaults }>()
+    .factory(() => {
+      let indicator: PadroneProgressIndicator | undefined;
+      let restoreOutput: (() => void) | undefined;
+      // Lazily resolved from context + constructor args
+      let resolvedRenderer: PadroneProgressRenderer | undefined;
+      let resolvedOptions: PadroneProgressOptions | undefined;
+      let msgs: ReturnType<typeof resolveMessages> | undefined;
+
+      function resolve(ctx: { context?: { progressConfig?: PadroneProgressDefaults } }) {
+        if (resolvedRenderer) return;
+        const ctxCfg = (ctx.context as Record<string, unknown> | undefined)?.progressConfig as PadroneProgressDefaults | undefined;
+        const spinner = rawSpinner ?? ctxCfg?.spinner;
+        const bar = rawBar ?? ctxCfg?.bar;
+        const time = rawTime ?? ctxCfg?.time;
+        const eta = rawEta ?? ctxCfg?.eta;
+        resolvedRenderer = rawRenderer ?? ctxCfg?.renderer ?? createTerminalProgress;
+        resolvedOptions =
+          spinner !== undefined || bar !== undefined || time !== undefined || eta !== undefined ? { spinner, bar, time, eta } : undefined;
+        msgs = mergeMessages(resolveMessages(rawMessage), resolveMessages(ctxCfg?.message), rawMessage);
+      }
+
+      const teardown = () => {
+        restoreOutput?.();
+        indicator = undefined;
+        restoreOutput = undefined;
+      };
+
+      return {
+        validate(ctx, next) {
+          resolve(ctx);
+          indicator = resolvedRenderer!(msgs!.validation || msgs!.progress, resolvedOptions);
+
+          const originalOutput = ctx.runtime.output;
+          const originalError = ctx.runtime.error;
+          ctx.runtime.output = (...args: unknown[]) => {
+            indicator!.pause();
+            originalOutput(...args);
+            indicator!.resume();
+          };
+          ctx.runtime.error = (text: string) => {
+            indicator!.pause();
+            originalError(text);
+            indicator!.resume();
+          };
+          restoreOutput = () => {
+            ctx.runtime.output = originalOutput;
+            ctx.runtime.error = originalError;
+          };
+
+          return next();
+        },
+
+        execute(ctx, next) {
+          // Transition from validation message to progress message
+          if (indicator && msgs!.validation) indicator.update(msgs!.progress);
+
+          const effectiveIndicator = indicator ?? noopIndicator;
+
+          const onSuccess = (value: unknown) => {
+            cleanup(effectiveIndicator, msgs!.success, msgs!.error, undefined, value, false);
+            teardown();
+          };
+          const onError = (err: unknown) => {
+            if (indicator) {
+              cleanup(indicator, msgs!.success, msgs!.error, err, undefined, true);
+              teardown();
+            }
+            throw err;
+          };
+
+          let result: any;
+          try {
+            result = next({ context: { ...(ctx.context as any), progress: effectiveIndicator } });
+          } catch (err) {
+            onError(err);
+          }
+          if (result instanceof Promise) {
+            return result.then(
+              (r) => {
+                if (r.result instanceof Promise) {
+                  return {
+                    result: r.result.then(
+                      (value: unknown) => {
+                        onSuccess(value);
+                        return value;
+                      },
+                      (err: unknown) => onError(err),
+                    ),
+                  };
+                }
+                onSuccess(r.result);
+                return r;
+              },
+              (err: unknown) => onError(err),
+            );
+          }
+          if (result!.result instanceof Promise) {
+            return {
+              result: result!.result.then(
+                (value: unknown) => {
+                  onSuccess(value);
+                  return value;
+                },
+                (err: unknown) => onError(err),
+              ),
+            };
+          }
+          onSuccess(result!.result);
+          return result;
+        },
+      };
+    })
+    .provides<{ progress: PadroneProgressIndicator }>();
+}
+
+// ---------------------------------------------------------------------------
+// Extension
+// ---------------------------------------------------------------------------
+
+/**
+ * Extension that adds an auto-managed progress indicator to the command pipeline.
+ *
+ * - `string` — a single message used for all states.
+ * - `PadroneProgressConfig` — separate messages for validation, progress, success, and error.
+ *
+ * The indicator is automatically started before validation, updated at each phase transition,
+ * and stopped on success (`.succeed()`) or failure (`.fail()`).
+ *
+ * Provides `{ progress: PadroneProgressIndicator }` on the command context.
+ * Access it in action handlers as `ctx.context.progress`.
+ *
+ * Uses the built-in terminal renderer by default. Pass a custom `renderer` for non-terminal
+ * environments (web UIs, testing, etc).
+ *
+ * Usage:
+ * ```ts
+ * createPadrone('my-cli')
+ *   .command('sync', (c) =>
+ *     c.extend(padroneProgress('Syncing...'))
+ *       .action((_args, ctx) => {
+ *         ctx.context.progress.update('halfway');
+ *       })
+ *   )
+ * ```
+ */
+export function padroneProgress<T extends CommandTypesBase>(config?: string | PadroneProgressConfig): (builder: T) => WithProgress<T> {
+  return ((builder: AnyPadroneBuilder) => builder.intercept(progressInterceptor(config ?? 'Working...'))) as any;
+}