@zapier/zapier-sdk-cli 0.52.10 → 0.53.0

package/dist/src/utils/cli-renderer.d.ts

@@ -1,4 +1,4 @@
-import type { FunctionRegistryEntry, SdkPage } from "@zapier/zapier-sdk";
+import type { FunctionRegistryEntry, SdkPage, ZapierSdk } from "@zapier/zapier-sdk";
 export interface JsonErrorEntry {
     code: string;
     message: string;
@@ -15,7 +15,7 @@ export interface CliRenderer {
         maxItems?: number;
         userSpecifiedMaxItems?: boolean;
         functionInfo?: FunctionRegistryEntry;
-    }): void;
+    }): Promise<void>;
     renderItem(value: unknown, options?: {
         outputFile?: unknown;
         commandName?: string;
@@ -24,6 +24,16 @@ export interface CliRenderer {
     renderResponse(response: Response): Promise<void>;
     renderError(error: unknown): never;
 }
+/**
+ * Per-invocation context the interactive renderer threads into the registry
+ * formatter. `sdk` and `params` are passed to `formatter.fetch(...)` so a
+ * formatter can enrich items by calling back into the SDK (for example, the
+ * table-record formatter resolves field IDs to human-readable names).
+ */
+export interface RendererContext {
+    sdk?: ZapierSdk;
+    params?: Record<string, unknown>;
+}
 export declare function buildJsonErrors(error: unknown): JsonErrorEntry[];
 /**
  * Replacer for JSON.stringify that coerces Error instances to a plain
@@ -38,5 +48,5 @@ export declare function buildJsonErrors(error: unknown): JsonErrorEntry[];
  */
 export declare function jsonReplacer(_key: string, value: unknown): unknown;
 export declare function createJsonRenderer(): CliRenderer;
-export declare function createInteractiveRenderer(): CliRenderer;
+export declare function createInteractiveRenderer(context?: RendererContext): CliRenderer;
 export {};

package/dist/src/utils/cli-renderer.js

@@ -93,7 +93,7 @@ export function createJsonRenderer() {
                 errors: [],
             });
         },
-        renderCollectedList(items, _options) {
+        async renderCollectedList(items, _options) {
             outputJson({ data: items, errors: [] });
         },
         renderItem(value, options) {
@@ -131,22 +131,29 @@ function getListTitle(functionInfo) {
         return `Available ${functionInfo.itemType} items`;
     return "items";
 }
-function renderItemsForDisplay(items, functionInfo, startingNumber = 0) {
-    if (functionInfo?.inputSchema) {
-        formatItemsFromSchema(functionInfo, items, startingNumber);
-    }
-    else {
-        items.forEach((item, index) => {
-            const obj = item;
-            const name = obj?.name || obj?.key || obj?.id || "Item";
-            console.log(`${chalk.gray(`${startingNumber + index + 1}.`)} ${chalk.cyan(String(name))}`);
-            if (obj?.description)
-                console.log(`   ${chalk.dim(String(obj.description))}`);
-            console.log();
-        });
+export function createInteractiveRenderer(context = {}) {
+    async function renderItemsForDisplay(items, functionInfo, startingNumber = 0) {
+        if (functionInfo?.inputSchema) {
+            // `formatter` on the registry entry is typed `unknown` so the registry
+            // layer stays SDK-agnostic; cast back to the CLI-side shape here at the
+            // boundary where we actually use it.
+            await formatItemsFromSchema(functionInfo, items, startingNumber, {
+                formatter: functionInfo.formatter,
+                sdk: context.sdk,
+                params: context.params,
+            });
+        }
+        else {
+            items.forEach((item, index) => {
+                const obj = item;
+                const name = obj?.name || obj?.key || obj?.id || "Item";
+                console.log(`${chalk.gray(`${startingNumber + index + 1}.`)} ${chalk.cyan(String(name))}`);
+                if (obj?.description)
+                    console.log(`   ${chalk.dim(String(obj.description))}`);
+                console.log();
+            });
+        }
     }
-}
-export function createInteractiveRenderer() {
     return {
         async renderPaginatedList(source, functionInfo) {
             const itemName = getItemName(functionInfo);
@@ -156,7 +163,7 @@ export function createInteractiveRenderer() {
                     console.log(chalk.yellow(`No ${itemName} found.`));
                     return;
                 }
-                renderItemsForDisplay(items, functionInfo, 0);
+                await renderItemsForDisplay(items, functionInfo, 0);
                 console.log(chalk.green(`\n✅ Showing ${items.length} ${itemName}`));
                 return;
             }
@@ -176,7 +183,7 @@ export function createInteractiveRenderer() {
                     console.clear();
                     console.log(chalk.blue(`📋 ${getListTitle(functionInfo)}\n`));
                 }
-                renderItemsForDisplay(items, functionInfo, totalShown);
+                await renderItemsForDisplay(items, functionInfo, totalShown);
                 totalShown += items.length;
                 console.log(chalk.green(`\n✅ Showing ${totalShown} ${itemName} (page ${pageCount})`));
                 if (page.nextCursor) {
@@ -197,7 +204,7 @@ export function createInteractiveRenderer() {
             }
             console.log(chalk.gray(`\n📄 Finished browsing ${itemName}`));
         },
-        renderCollectedList(items, { maxItems, userSpecifiedMaxItems, functionInfo } = {}) {
+        async renderCollectedList(items, { maxItems, userSpecifiedMaxItems, functionInfo } = {}) {
             if (!Array.isArray(items)) {
                 formatJsonOutput(items);
                 return;
@@ -208,7 +215,7 @@ export function createInteractiveRenderer() {
                 return;
             }
             console.log(chalk.green(`\n✅ Found ${items.length} ${itemName}:\n`));
-            renderItemsForDisplay(items, functionInfo);
+            await renderItemsForDisplay(items, functionInfo);
             if (userSpecifiedMaxItems && maxItems) {
                 console.log(chalk.gray(`\n📄 Showing up to ${maxItems} ${itemName} (--max-items ${maxItems})`));
             }

package/dist/src/utils/log.js

@@ -1,20 +1,25 @@
 import chalk from "chalk";
+// Every method here writes to stderr. The CLI reserves stdout for the
+// program's data payload (command output, JSON, response bodies); status,
+// info, warnings, errors, and debug all belong on stderr so they don't
+// break callers piping CLI output through jq, > redirect, or JSON.parse.
+// In a TTY both streams interleave, so interactive users see no change.
 const log = {
     info: (message, ...args) => {
-        console.log(chalk.blue("ℹ"), message, ...args);
+        console.error(chalk.blue("ℹ"), message, ...args);
     },
     error: (message, ...args) => {
         console.error(chalk.red("✖"), message, ...args);
     },
     success: (message, ...args) => {
-        console.log(chalk.green("✓"), message, ...args);
+        console.error(chalk.green("✓"), message, ...args);
     },
     warn: (message, ...args) => {
-        console.log(chalk.yellow("⚠"), message, ...args);
+        console.error(chalk.yellow("⚠"), message, ...args);
     },
     debug: (message, ...args) => {
         if (process.env.DEBUG === "true" || process.argv.includes("--debug")) {
-            console.log(chalk.gray("🐛"), message, ...args);
+            console.error(chalk.gray("🐛"), message, ...args);
         }
     },
 };

package/dist/src/utils/non-interactive.d.ts

@@ -2,12 +2,13 @@
  * Resolve whether a CLI invocation should run non-interactively.
  *
  * A command is non-interactive when the user explicitly opts out via
- * `--non-interactive` / `--skip-prompts`, OR when stdin or stdout isn't a
- * TTY (CI, piped output, etc.). The TTY check matters because prompting
- * against a non-TTY stream hangs or crashes — every plugin that gates
- * inquirer prompts on this flag needs the same answer.
+ * `--non-interactive`, OR when stdin or stdout isn't a TTY (CI, piped output,
+ * etc.). The TTY check matters because prompting against a non-TTY stream
+ * hangs or crashes — every plugin that gates inquirer prompts on this flag
+ * needs the same answer.
  */
 export declare function resolveNonInteractive(options: {
     nonInteractive?: boolean;
+    /** @deprecated Use `nonInteractive` instead. */
     skipPrompts?: boolean;
 }): boolean;

package/dist/src/utils/non-interactive.js

@@ -2,13 +2,14 @@
  * Resolve whether a CLI invocation should run non-interactively.
  *
  * A command is non-interactive when the user explicitly opts out via
- * `--non-interactive` / `--skip-prompts`, OR when stdin or stdout isn't a
- * TTY (CI, piped output, etc.). The TTY check matters because prompting
- * against a non-TTY stream hangs or crashes — every plugin that gates
- * inquirer prompts on this flag needs the same answer.
+ * `--non-interactive`, OR when stdin or stdout isn't a TTY (CI, piped output,
+ * etc.). The TTY check matters because prompting against a non-TTY stream
+ * hangs or crashes — every plugin that gates inquirer prompts on this flag
+ * needs the same answer.
  */
 export function resolveNonInteractive(options) {
-    return ((options.nonInteractive ?? options.skipPrompts) === true ||
+    return (options.nonInteractive === true ||
+        options.skipPrompts === true ||
         !process.stdin.isTTY ||
         !process.stdout.isTTY);
 }

package/dist/src/utils/parameter-resolver.js

@@ -129,7 +129,9 @@ export class SchemaParameterResolver {
     debugLog(message) {
         if (this.debug) {
             this.stopSpinner();
-            console.log(chalk.gray(`[Zapier CLI] ${message}`));
+            // stderr so debug output never pollutes stdout (jq, > redirect,
+            // JSON.parse all consume stdout).
+            console.error(chalk.gray(`[Zapier CLI] ${message}`));
         }
     }
     startSpinner() {

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

@@ -1,11 +1,11 @@
 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: {
+export declare function formatItemsFromSchema(_functionInfo: {
     inputSchema: z.ZodType;
     outputSchema?: z.ZodType;
 }, items: unknown[], startingNumber?: number, options?: {
-    formatter?: OutputFormatter;
+    formatter?: OutputFormatter<ZapierSdk>;
     sdk?: ZapierSdk;
     params?: Record<string, unknown>;
 }): Promise<void>;

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

@@ -1,16 +1,6 @@
 import chalk from "chalk";
 import util from "util";
 import wrapAnsi from "wrap-ansi";
-// These functions are internal to SDK, implementing basic formatting fallback
-// TODO: Consider exposing these utilities or implementing proper CLI formatting
-function getFormatMetadata(schema) {
-    return schema?._zod
-        ?.def?.formatMeta;
-}
-function getOutputSchema(schema) {
-    return schema?._zod?.def
-        ?.outputSchema;
-}
 // ============================================================================
 // JSON Formatting
 // ============================================================================
@@ -25,8 +15,8 @@ export function formatJsonOutput(data) {
 // ============================================================================
 // Generic Schema-Driven Formatter
 // ============================================================================
-export async function formatItemsFromSchema(functionInfo, items, startingNumber = 0, options) {
-    // If a registry-level OutputFormatter is provided, use it
+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) {
@@ -40,24 +30,8 @@ export async function formatItemsFromSchema(functionInfo, items, startingNumber
         });
         return;
     }
-    // Get the output schema from function info or fall back to input schema output schema
-    const outputSchema = functionInfo.outputSchema || getOutputSchema(functionInfo.inputSchema);
-    if (!outputSchema) {
-        // Fallback to generic formatting if no output schema
-        formatItemsGeneric(items, startingNumber);
-        return;
-    }
-    const formatMeta = getFormatMetadata(outputSchema);
-    if (!formatMeta) {
-        // Fallback to generic formatting if no format metadata
-        formatItemsGeneric(items, startingNumber);
-        return;
-    }
-    // Format each item using the schema metadata
-    items.forEach((item, index) => {
-        const formatted = formatMeta.format(item);
-        formatSingleItem(formatted, startingNumber + index);
-    });
+    // No formatter declared; fall back to generic field-sniffing.
+    formatItemsGeneric(items, startingNumber);
 }
 function formatSingleItem(formatted, itemNumber) {
     // Build the main title line with optional subtitle

package/dist/src/utils/version-checker.js

@@ -1,4 +1,4 @@
-import packageJsonLib from "package-json";
+import packageJsonLib, { VersionNotFoundError } from "package-json";
 import chalk from "chalk";
 import log from "./log";
 import { getConfig } from "../login";
@@ -94,8 +94,13 @@ export async function checkForUpdates({ packageName, currentVersion, }) {
             currentPackageInfo = await fetchCachedPackageInfo(packageName, currentVersion);
         }
         catch (error) {
-            // If we can't fetch the current version info, use the latest version info
-            log.debug(`Failed to check deprecation for current version: ${error}`);
+            // A `VersionNotFoundError` is the normal state during a publish
+            // pipeline: the running CLI is the very build about to be published,
+            // so npm doesn't have it yet. Silently fall back to the latest info
+            // and only log unexpected errors.
+            if (!(error instanceof VersionNotFoundError)) {
+                log.debug(`Failed to check deprecation for current version: ${error}`);
+            }
             currentPackageInfo = latestPackageInfo;
         }
         const isDeprecated = Boolean(currentPackageInfo.deprecated);