@zapier/zapier-sdk-cli 0.59.1 → 0.59.3

package/dist/src/utils/retry.d.ts

@@ -1,6 +0,0 @@
-export declare function withRetry<T>({ action, attempts, initialDelayMs, shouldRetry, }: {
-    action: () => Promise<T>;
-    attempts?: number;
-    initialDelayMs?: number;
-    shouldRetry?: (err: unknown) => boolean;
-}): Promise<T>;

package/dist/src/utils/retry.js

@@ -1,21 +0,0 @@
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-export async function withRetry({ action, attempts = 3, initialDelayMs = 100, shouldRetry = () => true, }) {
-    if (attempts <= 0) {
-        throw new Error("withRetry: attempts must be greater than 0");
-    }
-    let lastError;
-    for (let i = 0; i < attempts; i++) {
-        try {
-            return await action();
-        }
-        catch (err) {
-            lastError = err;
-            if (!shouldRetry(err) || i >= attempts - 1)
-                break;
-            await sleep(initialDelayMs * 2 ** i);
-        }
-    }
-    throw lastError;
-}

package/dist/src/utils/schema-formatter.d.ts

@@ -1,11 +0,0 @@
-import type { z } from "zod";
-import type { OutputFormatter, ZapierSdk } from "@zapier/zapier-sdk";
-export declare function formatJsonOutput(data: unknown): void;
-export declare function formatItemsFromSchema(_functionInfo: {
-    inputSchema: z.ZodType;
-    outputSchema?: z.ZodType;
-}, items: unknown[], startingNumber?: number, options?: {
-    formatter?: OutputFormatter<ZapierSdk>;
-    sdk?: ZapierSdk;
-    params?: Record<string, unknown>;
-}): Promise<void>;

package/dist/src/utils/schema-formatter.js

@@ -1,131 +0,0 @@
-import chalk from "chalk";
-import util from "util";
-import wrapAnsi from "wrap-ansi";
-// ============================================================================
-// JSON Formatting
-// ============================================================================
-export function formatJsonOutput(data) {
-    // Don't print anything for undefined results (commands that just perform actions)
-    if (data === undefined) {
-        return;
-    }
-    // Use util.inspect for colored output
-    console.log(util.inspect(data, { colors: true, depth: null, breakLength: 80 }));
-}
-// ============================================================================
-// Generic Schema-Driven Formatter
-// ============================================================================
-export async function formatItemsFromSchema(_functionInfo, items, startingNumber = 0, options) {
-    // Use the registry-level formatter when the plugin declared one.
-    if (options?.formatter) {
-        let context;
-        if (options.formatter.fetch && options.sdk && options.params) {
-            for (const item of items) {
-                context = await options.formatter.fetch(options.sdk, options.params, item, context);
-            }
-        }
-        items.forEach((item, index) => {
-            const formatted = options.formatter.format(item, context);
-            formatSingleItem(formatted, startingNumber + index);
-        });
-        return;
-    }
-    // No formatter declared; fall back to generic field-sniffing.
-    formatItemsGeneric(items, startingNumber);
-}
-function formatSingleItem(formatted, itemNumber) {
-    // Build the main title line with optional subtitle
-    let titleLine = `${chalk.gray(`${itemNumber + 1}.`)} ${chalk.cyan(formatted.title)}`;
-    // Generate subtitle - always show key if available, then ID if available
-    const subtitleParts = [];
-    if (formatted.keys) {
-        subtitleParts.push(...formatted.keys);
-    }
-    else if (formatted.key) {
-        subtitleParts.push(formatted.key);
-    }
-    if (formatted.id) {
-        subtitleParts.push(formatted.id);
-    }
-    // Remove duplicates while preserving order
-    const uniqueParts = [...new Set(subtitleParts)];
-    if (uniqueParts.length > 0) {
-        titleLine += ` ${chalk.gray(`(${uniqueParts.join(", ")})`)}`;
-    }
-    console.log(titleLine);
-    // Show description if available
-    if (formatted.description) {
-        console.log(`   ${chalk.dim(formatted.description)}`);
-    }
-    // If data is provided, use JSON formatting instead of details
-    if (formatted.data !== undefined) {
-        formatJsonOutput(formatted.data);
-        console.log(); // Empty line between items
-        return;
-    }
-    // Format detail lines
-    for (const detail of formatted.details) {
-        if (detail.label) {
-            const isMultiline = detail.text.includes("\n");
-            if (isMultiline) {
-                console.log(`   ${chalk.gray(detail.label + ":")}`);
-                const displayText = formatDetailText(detail.text, DETAIL_INDENT + "   ");
-                const styledText = applyStyle(displayText, detail.style);
-                console.log(`${DETAIL_INDENT}   ${styledText}`);
-            }
-            else {
-                const styledValue = applyStyle(detail.text, detail.style);
-                console.log(`   ${chalk.gray(detail.label + ":")} ${styledValue}`);
-            }
-        }
-        else {
-            const displayText = formatDetailText(detail.text, DETAIL_INDENT);
-            const styledText = applyStyle(displayText, detail.style);
-            console.log(`   ${styledText}`);
-        }
-    }
-    console.log(); // Empty line between items
-}
-const DETAIL_INDENT = "   ";
-const DETAIL_MAX_LINES = 5;
-function formatDetailText(text, indent = DETAIL_INDENT) {
-    const columns = Math.max((process.stdout.columns || 80) - indent.length, 40);
-    const wrapped = wrapAnsi(text, columns, { hard: true, trim: false });
-    const lines = wrapped.split("\n");
-    if (lines.length <= DETAIL_MAX_LINES) {
-        return lines.join("\n" + indent);
-    }
-    return (lines.slice(0, DETAIL_MAX_LINES).join("\n" + indent) + "\n" + indent + "…");
-}
-function applyStyle(value, style) {
-    switch (style) {
-        case "dim":
-            return chalk.dim(value);
-        case "accent":
-            return chalk.magenta(value);
-        case "warning":
-            return chalk.red(value);
-        case "success":
-            return chalk.green(value);
-        case "normal":
-        default:
-            return chalk.blue(value);
-    }
-}
-function convertGenericItemToFormattedItem(item) {
-    const itemObj = item;
-    return {
-        title: itemObj.title || itemObj.name || itemObj.key || itemObj.id || "Item",
-        id: itemObj.id,
-        key: itemObj.key,
-        description: itemObj.description,
-        details: [],
-    };
-}
-function formatItemsGeneric(items, startingNumber = 0) {
-    // Convert generic items to FormattedItem and use formatSingleItem
-    items.forEach((item, index) => {
-        const formatted = convertGenericItemToFormattedItem(item);
-        formatSingleItem(formatted, startingNumber + index);
-    });
-}

package/dist/src/utils/serializeAsync.d.ts

@@ -1,2 +0,0 @@
-declare const serializeAsync: <R, A extends []>(fn: (...args: A) => Promise<R>) => ((...args: A) => Promise<R>);
-export default serializeAsync;

package/dist/src/utils/serializeAsync.js

@@ -1,16 +0,0 @@
-import { createHash } from "node:crypto";
-const promises = {};
-const serializeAsync = (fn) => async (...args) => {
-    const hash = createHash("sha256")
-        .update(fn.toString(), "utf8")
-        .digest()
-        .toString("hex");
-    const promise = promises[hash];
-    if (!promise) {
-        promises[hash] = fn(...args).finally(() => {
-            delete promises[hash];
-        });
-    }
-    return promises[hash];
-};
-export default serializeAsync;

package/dist/src/utils/spinner.d.ts

@@ -1 +0,0 @@
-export declare const spinPromise: <T>(promise: Promise<T>, text: string) => Promise<T>;

package/dist/src/utils/spinner.js

@@ -1,21 +0,0 @@
-import ora from "ora";
-import { ZapierCliUserCancellationError } from "./errors";
-export const spinPromise = async (promise, text) => {
-    const spinner = ora(text).start();
-    try {
-        const result = await promise;
-        spinner.succeed();
-        return result;
-    }
-    catch (error) {
-        if (error instanceof ZapierCliUserCancellationError) {
-            // For user cancellation, just stop the spinner without showing failure
-            spinner.stop();
-        }
-        else {
-            // For actual errors, show failure
-            spinner.fail();
-        }
-        throw error;
-    }
-};

package/dist/src/utils/string-utils.d.ts

@@ -1 +0,0 @@
-export declare function toKebabCase(str: string): string;

package/dist/src/utils/string-utils.js

@@ -1,6 +0,0 @@
-export function toKebabCase(str) {
-    return str
-        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2")
-        .replace(/([a-z\d])([A-Z])/g, "$1-$2")
-        .toLowerCase();
-}

package/dist/src/utils/triggerDrain.d.ts

@@ -1,144 +0,0 @@
-/**
- * Shared CLI helpers for the `drain-trigger-inbox` and
- * `watch-trigger-inbox` commands. Both wrap the eager SDK callback API
- * and dispatch on the same flag set: interactive default (TTY),
- * `--exec` (binary + argv, no shell), `--exec-shell` (shell handler),
- * `--json` (drain: collect-and-print; watch: NDJSON streaming).
- */
-import { type LeasedTriggerMessageItem } from "@zapier/zapier-sdk";
-export type Callback = (message: LeasedTriggerMessageItem) => Promise<void>;
-/**
- * Marker error thrown by `createInteractiveCallback` when the user
- * picks "Skip (let lease expire)". The SDK treats it like any other
- * Error subclass — leave-leased per default `releaseOnError: false`
- * — so the lease-timeout recovery path is preserved. The CLI uses
- * the marker type to distinguish a deliberate skip from an unhandled
- * exception when counting summary lines. Not a `ZapierSignal`: the
- * SDK's signal-handling auto-releases the message, which is exactly
- * what skip-expire does *not* want.
- */
-export declare class CliSkipLeaseExpireError extends Error {
-    readonly name = "CliSkipLeaseExpireError";
-    constructor();
-}
-/**
- * Prompts the user per message. Choices:
- *
- * - **Ack**: returns normally so the SDK acks the message.
- * - **Skip (release after draining)**: throws
- *   `ZapierReleaseTriggerMessageSignal`. The SDK marks the message for
- *   release; the actual release call is deferred until the drain
- *   finishes so the same drain doesn't immediately re-lease it. After
- *   drain ends, the message returns to `available` for a future drain
- *   run or another consumer.
- * - **Skip (let lease expire)**: throws `CliSkipLeaseExpireError` so
- *   the SDK leaves the message leased (it's not a `ZapierSignal`,
- *   so the SDK's catch-all "leave on error" path applies); the lease
- *   timeout (~5 min default) is the recovery path. Use this when you
- *   want backpressure on reprocessing. The CLI catches the marker
- *   to count it as a skip in the drain summary.
- * - **Quit**: throws `ZapierAbortDrainSignal` so the SDK stops draining
- *   after the current batch finishes (in-flight callbacks complete;
- *   not-yet-started messages in the batch are released).
- *
- * Ctrl-C during the prompt is translated to `ZapierAbortDrainSignal`
- * (same as Quit) — inquirer raises `ExitPromptError`, which we catch
- * and re-throw as the abort signal.
- */
-export declare function createInteractiveCallback(): Callback;
-/**
- * Writes one JSON object per line to stdout (NDJSON) for piping. Acks
- * each message after the write resolves; if stdout is closed mid-drain
- * (broken pipe), the write throws and the message stays unacked.
- *
- * The write callback alone provides backpressure: it doesn't fire until
- * the chunk is fully committed to the underlying resource, so awaiting
- * it pauses the drain when stdout is busy. No separate `drain` listener
- * needed — and adding one would race with the callback (drain fires at
- * highWaterMark, callback fires after full commit; if drain wins, the
- * later callback's error gets dropped on the floor).
- */
-export declare function createNdjsonCallback(): Callback;
-export declare function runShellCommand(command: string, message: LeasedTriggerMessageItem, signal?: AbortSignal): Promise<void>;
-/**
- * Run a binary per message with no shell interpretation. `argv[0]` is
- * the executable; the rest are passed literally as argv to the child.
- * Otherwise identical to `runShellCommand`: stdin = message JSON, exit
- * code 0 acks, non-zero rejects, abort signal kills the child.
- */
-export declare function runExecCommand(argv: string[], message: LeasedTriggerMessageItem, signal?: AbortSignal): Promise<void>;
-/**
- * Print a single per-message error to stderr. Used as the live
- * `onError` body so failures surface as they happen (vs accumulated
- * and dumped at the end, which is broken for `watch-trigger-inbox`
- * where "the end" is Ctrl-C).
- */
-export declare function printDrainError(reason: unknown, message: LeasedTriggerMessageItem): void;
-/**
- * One-line summary printed when the CLI finished a drain in a mode
- * where the data array is uninformative (interactive, exec, exec-shell).
- * Both the bounded and forever variants use the same format.
- *
- * `skipped` is the interactive-mode count of user-driven Skip choices
- * (release-after-draining + let-lease-expire). Omitted when zero so the
- * subprocess modes — which have no skip semantics — keep their original
- * two-part summary.
- */
-export declare function printDrainSummary(counts: {
-    fulfilled: number;
-    rejected: number;
-    skipped?: number;
-}): void;
-/**
- * Warn on stderr that interactive mode is overriding an explicit
- * `continueOnError: false`. Only fires when the caller (programmatic
- * SDK consumer or future flag form that takes `=false`) opted into
- * fail-fast — bare `--continue-on-error` flag absence leaves it
- * `undefined` and doesn't trigger this. Interactive mode mechanically
- * requires continue-on-error: the "Skip (let lease expire)" choice
- * throws a plain Error to leave the message leased, and a fail-fast
- * drain would tear down on the first skip.
- */
-export declare function warnInteractiveContinueOnErrorOverride(): void;
-/**
- * Throw a CliValidationError if the current process isn't attached to
- * a real terminal on both stdin and stdout. Used by the interactive
- * default to fail fast with a useful message instead of letting
- * inquirer fall over later.
- */
-export declare function requireInteractiveTty(commandName: string): void;
-/**
- * Reject more than one of `--exec`, `--exec-shell`, and `--json`.
- * Each is a non-interactive output path and choosing implicitly is
- * ambiguous.
- */
-export declare function rejectExecJsonMutex(opts: {
-    exec?: unknown;
-    execShell?: unknown;
-    json?: unknown;
-}): void;
-/**
- * Pull argv tokens after the first `--` separator out of `process.argv`.
- * Returns `[]` when there's no `--`. Used by drain/watch to append
- * post-`--` args to the `--exec` binary, mirroring `xargs`, `gh`, and
- * `npm run -- ...` semantics.
- *
- * Read from `process.argv` rather than threading via cli-generator
- * because Commander already consumes `--` at parse time and there's
- * no per-command API for "the args after `--`" exposed through the
- * SDK options object.
- */
-export declare function getPostDashArgs(argv?: string[]): string[];
-/**
- * Combine an optional user signal with an internal one (typically the
- * SIGINT controller) into a single AbortSignal that fires when either
- * source aborts. Returns a `dispose` to detach the listeners; safe to
- * call regardless of whether the combined signal fired.
- *
- * Plain shape rather than the SDK's `combineAbortSignals`, which works
- * over `DisposableAbortSignal` handles and returns a different shape.
- */
-export declare function combineSignals(a: AbortSignal | undefined, b: AbortSignal): {
-    signal: AbortSignal;
-    dispose: () => void;
-};