@zapier/zapier-sdk-cli 0.34.11 → 0.35.0

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

@@ -0,0 +1,30 @@
+import type { FunctionRegistryEntry, SdkPage } from "@zapier/zapier-sdk";
+export interface JsonErrorEntry {
+    code: string;
+    message: string;
+}
+export interface JsonEnvelope {
+    data: unknown;
+    nextCursor?: string;
+    errors: JsonErrorEntry[];
+}
+type PagedSource = AsyncIterable<SdkPage> | PromiseLike<SdkPage>;
+export interface CliRenderer {
+    renderPaginatedList(source: PagedSource, functionInfo: FunctionRegistryEntry): Promise<void>;
+    renderCollectedList(items: unknown[], options: {
+        maxItems?: number;
+        userSpecifiedMaxItems?: boolean;
+        functionInfo?: FunctionRegistryEntry;
+    }): void;
+    renderItem(value: unknown, options?: {
+        outputFile?: unknown;
+        commandName?: string;
+        functionInfo?: FunctionRegistryEntry;
+    }): void;
+    renderResponse(response: Response): Promise<void>;
+    renderError(error: unknown): never;
+}
+export declare function buildJsonErrors(error: unknown): JsonErrorEntry[];
+export declare function createJsonRenderer(): CliRenderer;
+export declare function createInteractiveRenderer(): CliRenderer;
+export {};

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

@@ -0,0 +1,226 @@
+import { ZapierCliMissingParametersError, ZapierCliExitError } from "./errors";
+import { formatErrorMessage, ZapierError } from "@zapier/zapier-sdk";
+import { formatItemsFromSchema, formatJsonOutput } from "./schema-formatter";
+import { toKebabCase } from "./string-utils";
+import chalk from "chalk";
+import inquirer from "inquirer";
+// ============================================================================
+// Shared error formatting
+// ============================================================================
+function formatMissingParamsError(error) {
+    return [
+        "Missing required parameters:",
+        ...error.params.map(({ name, isPositional }) => isPositional
+            ? `  • <${toKebabCase(name)}>`
+            : `  • --${toKebabCase(name)}`),
+    ].join("\n");
+}
+// ============================================================================
+// Shared error serialization (used by JSON renderer)
+// ============================================================================
+export function buildJsonErrors(error) {
+    if (error instanceof ZapierCliMissingParametersError) {
+        return error.params.map(({ name, isPositional }) => ({
+            code: error.code,
+            message: isPositional
+                ? `<${toKebabCase(name)}> is required in non-interactive mode`
+                : `--${toKebabCase(name)} is required in non-interactive mode`,
+        }));
+    }
+    const code = error instanceof ZapierError ? error.code : "UNKNOWN_ERROR";
+    const message = error instanceof Error ? error.message : String(error);
+    return [{ code, message }];
+}
+// ============================================================================
+// HTTP response unwrapping
+// ============================================================================
+async function unwrapHttpResponse(response) {
+    const text = await response.text().catch(() => "[unable to read body]");
+    try {
+        return {
+            statusCode: response.status,
+            headers: Object.fromEntries(response.headers.entries()),
+            body: JSON.parse(text),
+        };
+    }
+    catch {
+        throw new Error(`Failed to parse response as JSON (status: ${response.status}). Body: ${text.slice(0, 500)}`);
+    }
+}
+// ============================================================================
+// JSON renderer
+// ============================================================================
+function outputJson(envelope) {
+    console.log(JSON.stringify(envelope, null, 2));
+}
+export function createJsonRenderer() {
+    return {
+        async renderPaginatedList(source, _functionInfo) {
+            let page;
+            if (Symbol.asyncIterator in Object(source)) {
+                const iter = source[Symbol.asyncIterator]();
+                const result = await iter.next();
+                page = result.done ? undefined : result.value;
+            }
+            else {
+                page = await source;
+            }
+            const data = Array.isArray(page?.data) ? page.data : [];
+            outputJson({
+                data,
+                ...(page?.nextCursor && { nextCursor: page.nextCursor }),
+                errors: [],
+            });
+        },
+        renderCollectedList(items, _options) {
+            outputJson({ data: items, errors: [] });
+        },
+        renderItem(value, options) {
+            outputJson({
+                data: options?.outputFile
+                    ? { outputFile: options.outputFile }
+                    : (value ?? null),
+                errors: [],
+            });
+        },
+        async renderResponse(response) {
+            // Leave envelope as is for backwards compatibility
+            // until we fully deprecate fetch from CLI
+            console.log(JSON.stringify(await unwrapHttpResponse(response), null, 2));
+        },
+        renderError(error) {
+            outputJson({ data: null, errors: buildJsonErrors(error) });
+            throw new ZapierCliExitError(error instanceof Error ? error.message : String(error), 1);
+        },
+    };
+}
+// ============================================================================
+// Interactive renderer
+// ============================================================================
+function getItemName(functionInfo) {
+    if (functionInfo?.itemType)
+        return `${functionInfo.itemType} items`;
+    return "items";
+}
+function getListTitle(functionInfo) {
+    if (functionInfo.itemType)
+        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() {
+    return {
+        async renderPaginatedList(source, functionInfo) {
+            const itemName = getItemName(functionInfo);
+            if (!(Symbol.asyncIterator in Object(source))) {
+                const items = source?.data;
+                if (!Array.isArray(items) || items.length === 0) {
+                    console.log(chalk.yellow(`No ${itemName} found.`));
+                    return;
+                }
+                renderItemsForDisplay(items, functionInfo, 0);
+                console.log(chalk.green(`\n✅ Showing ${items.length} ${itemName}`));
+                return;
+            }
+            let totalShown = 0;
+            let pageCount = 0;
+            console.log(chalk.blue(`📋 ${getListTitle(functionInfo)}\n`));
+            for await (const page of source) {
+                const items = page.data ?? [];
+                pageCount++;
+                if (items.length === 0 && pageCount === 1) {
+                    console.log(chalk.yellow(`No ${itemName} found.`));
+                    return;
+                }
+                if (items.length === 0)
+                    break;
+                if (pageCount > 1) {
+                    console.clear();
+                    console.log(chalk.blue(`📋 ${getListTitle(functionInfo)}\n`));
+                }
+                renderItemsForDisplay(items, functionInfo, totalShown);
+                totalShown += items.length;
+                console.log(chalk.green(`\n✅ Showing ${totalShown} ${itemName} (page ${pageCount})`));
+                if (page.nextCursor) {
+                    const { continueReading } = await inquirer.prompt([
+                        {
+                            type: "confirm",
+                            name: "continueReading",
+                            message: "Load next page?",
+                            default: true,
+                        },
+                    ]);
+                    if (!continueReading)
+                        break;
+                }
+                else {
+                    break;
+                }
+            }
+            console.log(chalk.gray(`\n📄 Finished browsing ${itemName}`));
+        },
+        renderCollectedList(items, { maxItems, userSpecifiedMaxItems, functionInfo } = {}) {
+            if (!Array.isArray(items)) {
+                formatJsonOutput(items);
+                return;
+            }
+            const itemName = getItemName(functionInfo);
+            if (items.length === 0) {
+                console.log(chalk.yellow(`No ${itemName} found.`));
+                return;
+            }
+            console.log(chalk.green(`\n✅ Found ${items.length} ${itemName}:\n`));
+            renderItemsForDisplay(items, functionInfo);
+            if (userSpecifiedMaxItems && maxItems) {
+                console.log(chalk.gray(`\n📄 Showing up to ${maxItems} ${itemName} (--max-items ${maxItems})`));
+            }
+            else {
+                console.log(chalk.gray(`\n📄 All available ${itemName} shown`));
+            }
+        },
+        renderItem(value, options) {
+            if (options?.outputFile) {
+                const label = options.commandName
+                    ? `✅ ${options.commandName} completed successfully!`
+                    : "✅ Done!";
+                console.log(chalk.green(label));
+                console.log(chalk.gray(`Output written to: ${options.outputFile}`));
+            }
+            else {
+                formatJsonOutput(value);
+            }
+        },
+        async renderResponse(response) {
+            formatJsonOutput(await unwrapHttpResponse(response));
+        },
+        renderError(error) {
+            if (error instanceof ZapierCliMissingParametersError) {
+                console.error(chalk.red("❌ " + formatMissingParamsError(error)));
+                console.error("\n" + chalk.dim("Use --help to see available options"));
+                throw new ZapierCliExitError(error.message, 1);
+            }
+            if (error instanceof ZapierError) {
+                const formattedMessage = formatErrorMessage(error);
+                console.error(chalk.red("❌ Error:"), formattedMessage);
+                throw new ZapierCliExitError(formattedMessage, 1);
+            }
+            const msg = error instanceof Error ? error.message : "Unknown error";
+            console.error(chalk.red("❌ Error:"), msg);
+            throw new ZapierCliExitError(msg, 1);
+        },
+    };
+}

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

@@ -14,3 +14,20 @@ export declare class ZapierCliExitError extends ZapierCliError {
     readonly exitCode: number;
     constructor(message: string, exitCode?: number);
 }
+export interface MissingParam {
+    name: string;
+    isPositional: boolean;
+}
+export declare class ZapierCliValidationError extends ZapierCliError {
+    readonly name = "ZapierCliValidationError";
+    readonly code = "ZAPIER_CLI_VALIDATION_ERROR";
+    readonly exitCode = 1;
+    constructor(message: string);
+}
+export declare class ZapierCliMissingParametersError extends ZapierCliError {
+    readonly name = "ZapierCliMissingParametersError";
+    readonly code = "ZAPIER_CLI_MISSING_PARAMETERS";
+    readonly exitCode = 1;
+    readonly params: MissingParam[];
+    constructor(params: MissingParam[]);
+}

package/dist/src/utils/errors.js

@@ -17,3 +17,20 @@ export class ZapierCliExitError extends ZapierCliError {
         this.exitCode = exitCode;
     }
 }
+export class ZapierCliValidationError extends ZapierCliError {
+    constructor(message) {
+        super(message);
+        this.name = "ZapierCliValidationError";
+        this.code = "ZAPIER_CLI_VALIDATION_ERROR";
+        this.exitCode = 1;
+    }
+}
+export class ZapierCliMissingParametersError extends ZapierCliError {
+    constructor(params) {
+        super(`Missing required parameters: ${params.map((p) => p.name).join(", ")}`);
+        this.name = "ZapierCliMissingParametersError";
+        this.code = "ZAPIER_CLI_MISSING_PARAMETERS";
+        this.exitCode = 1;
+        this.params = params;
+    }
+}

package/dist/src/utils/parameter-resolver.d.ts

@@ -1,10 +1,24 @@
 import { z } from "zod";
 import { type ZapierSdk } from "@zapier/zapier-sdk";
 export declare class SchemaParameterResolver {
-    resolveParameters(schema: z.ZodSchema, providedParams: unknown, sdk: ZapierSdk, functionName?: string): Promise<unknown>;
+    resolveParameters(schema: z.ZodSchema, providedParams: unknown, sdk: ZapierSdk, functionName?: string, options?: {
+        interactiveMode?: boolean;
+    }): Promise<unknown>;
     private extractParametersFromSchema;
     private analyzeFieldSchema;
     private createResolvableParameter;
+    /**
+     * Calls `tryResolveWithoutPrompt` on a dynamic resolver.
+     * Returns the resolution result object, or null if unresolvable / throws.
+     * Note: { resolvedValue: null } is a valid result (e.g. connectionId when app has no auth);
+     * only a null return from the resolver itself means "could not auto-resolve".
+     */
+    private tryAutoResolve;
+    /**
+     * Non-interactive resolution: auto-resolves what it can via tryAutoResolve,
+     * throws ZapierCliMissingParametersError for anything that requires user input.
+     */
+    private resolveRequiredParamsNonInteractive;
     private resolveParameter;
     private resolveFieldsRecursively;
     /**

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

@@ -2,7 +2,18 @@ import inquirer from "inquirer";
 import chalk from "chalk";
 import { z } from "zod";
 import { runWithTelemetryContext, } from "@zapier/zapier-sdk";
-import { ZapierCliUserCancellationError } from "./errors";
+import { isPositional } from "@zapier/zapier-sdk";
+import { ZapierCliUserCancellationError, ZapierCliMissingParametersError, ZapierCliValidationError, } from "./errors";
+// Zod validation errors are structured objects; flatten them into a
+// readable "field: reason" string for CLI error messages.
+function formatZodError(error) {
+    return error.issues
+        .map((issue) => {
+        const field = issue.path.length > 0 ? issue.path.join(".") : "input";
+        return `${field}: ${issue.message}`;
+    })
+        .join(", ");
+}
 // ============================================================================
 // Local Resolution Helper Functions
 // ============================================================================
@@ -50,8 +61,9 @@ function getLocalResolutionOrderForParams(paramNames, resolvers) {
 // Schema Parameter Resolver
 // ============================================================================
 export class SchemaParameterResolver {
-    async resolveParameters(schema, providedParams, sdk, functionName) {
+    async resolveParameters(schema, providedParams, sdk, functionName, options) {
         return runWithTelemetryContext(async () => {
+            const interactiveMode = options?.interactiveMode ?? true;
             // 1. Try to parse with current parameters
             const parseResult = schema.safeParse(providedParams);
             // Get all schema parameters to check which ones have resolvers
@@ -70,9 +82,10 @@ export class SchemaParameterResolver {
                 // Schema-required parameters are always functionally required
                 if (param.isRequired)
                     return true;
-                // Only inputs is functionally required for run-action
+                // Keep inputs prompting in interactive mode, but do not force it in
+                // non-interactive mode (--json), where optional inputs should remain optional.
                 if (param.name === "inputs") {
-                    return true;
+                    return interactiveMode;
                 }
                 return false;
             });
@@ -97,7 +110,7 @@ export class SchemaParameterResolver {
             if (functionallyRequired.length === 0 && alwaysPrompt.length === 0) {
                 // No functionally required parameters missing, but check if we can parse
                 if (!parseResult.success) {
-                    throw parseResult.error;
+                    throw new ZapierCliValidationError(formatZodError(parseResult.error));
                 }
                 return parseResult.data;
             }
@@ -131,19 +144,24 @@ export class SchemaParameterResolver {
                     return param;
                 })
                     .filter((param) => param !== undefined);
-                for (const param of orderedRequiredParams) {
-                    try {
-                        const value = await this.resolveParameter(param, context, functionName);
-                        this.setNestedValue(resolvedParams, param.path, value);
-                        // Update context with newly resolved value
-                        context.resolvedParams = resolvedParams;
-                    }
-                    catch (error) {
-                        if (this.isUserCancellation(error)) {
-                            console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                            throw new ZapierCliUserCancellationError();
+                if (!interactiveMode) {
+                    await this.resolveRequiredParamsNonInteractive(orderedRequiredParams, context, resolvedParams, functionName);
+                }
+                else {
+                    for (const param of orderedRequiredParams) {
+                        try {
+                            const value = await this.resolveParameter(param, context, functionName);
+                            this.setNestedValue(resolvedParams, param.path, value);
+                            // Update context with newly resolved value
+                            context.resolvedParams = resolvedParams;
+                        }
+                        catch (error) {
+                            if (this.isUserCancellation(error)) {
+                                console.log(chalk.yellow("\n\nOperation cancelled by user"));
+                                throw new ZapierCliUserCancellationError();
+                            }
+                            throw error;
                         }
-                        throw error;
                     }
                 }
                 // Remove resolved dependencies from other categories to avoid double-prompting
@@ -151,8 +169,10 @@ export class SchemaParameterResolver {
                 alwaysPrompt.splice(0, alwaysPrompt.length, ...alwaysPrompt.filter((p) => !resolvedParamNames.has(p.name)));
                 trulyOptional.splice(0, trulyOptional.length, ...trulyOptional.filter((p) => !resolvedParamNames.has(p.name)));
             }
-            // 3. Resolve parameters that should always be prompted for (but can be skipped)
-            if (alwaysPrompt.length > 0) {
+            // 3. Resolve parameters that should always be prompted for (but can be skipped).
+            // Skipped entirely in non-interactive mode - if connectionId was needed, it should
+            // have been passed explicitly via --connection-id.
+            if (interactiveMode && alwaysPrompt.length > 0) {
                 const alwaysPromptNames = alwaysPrompt.map((p) => p.name);
                 const alwaysPromptResolutionOrder = getLocalResolutionOrderForParams(alwaysPromptNames, localResolvers);
                 const orderedAlwaysPromptParams = alwaysPromptResolutionOrder
@@ -174,8 +194,8 @@ export class SchemaParameterResolver {
                     }
                 }
             }
-            // 4. Ask user if they want to resolve truly optional parameters
-            if (trulyOptional.length > 0) {
+            // 4. Ask user if they want to resolve truly optional parameters (skipped in non-interactive mode)
+            if (interactiveMode && trulyOptional.length > 0) {
                 const optionalNames = trulyOptional.map((p) => p.name).join(", ");
                 const shouldResolveOptional = await inquirer.prompt([
                     {
@@ -212,8 +232,7 @@ export class SchemaParameterResolver {
             // 5. Validate final parameters
             const finalResult = schema.safeParse(resolvedParams);
             if (!finalResult.success) {
-                console.error(chalk.red("❌ Parameter validation failed after resolution:"));
-                throw finalResult.error;
+                throw new ZapierCliValidationError(`Parameter validation failed: ${formatZodError(finalResult.error)}`);
             }
             return finalResult.data;
         });
@@ -258,6 +277,50 @@ export class SchemaParameterResolver {
             isRequired,
         };
     }
+    /**
+     * Calls `tryResolveWithoutPrompt` on a dynamic resolver.
+     * Returns the resolution result object, or null if unresolvable / throws.
+     * Note: { resolvedValue: null } is a valid result (e.g. connectionId when app has no auth);
+     * only a null return from the resolver itself means "could not auto-resolve".
+     */
+    async tryAutoResolve(dynamicResolver, context) {
+        if (!dynamicResolver.tryResolveWithoutPrompt)
+            return null;
+        try {
+            return await dynamicResolver.tryResolveWithoutPrompt(context.sdk, context.resolvedParams);
+        }
+        catch (err) {
+            console.warn(`Auto-resolver threw unexpectedly; treating as unresolved. Error: ${err instanceof Error ? err.message : String(err)}`);
+            return null;
+        }
+    }
+    /**
+     * Non-interactive resolution: auto-resolves what it can via tryAutoResolve,
+     * throws ZapierCliMissingParametersError for anything that requires user input.
+     */
+    async resolveRequiredParamsNonInteractive(params, context, resolvedParams, functionName) {
+        const missingParams = [];
+        for (const param of params) {
+            const resolver = this.getResolver(param.name, context.sdk, functionName);
+            const autoResolution = resolver?.type === "dynamic"
+                ? await this.tryAutoResolve(resolver, context)
+                : null;
+            if (autoResolution != null) {
+                this.setNestedValue(resolvedParams, param.path, autoResolution.resolvedValue);
+                context.resolvedParams = resolvedParams;
+            }
+            else {
+                missingParams.push({
+                    name: param.name,
+                    // Required params render as positional CLI args (<name>); so do explicitly positional optional params.
+                    isPositional: param.isRequired || isPositional(param.schema),
+                });
+            }
+        }
+        if (missingParams.length > 0) {
+            throw new ZapierCliMissingParametersError(missingParams);
+        }
+    }
     async resolveParameter(param, context, functionName) {
         const resolver = this.getResolver(param.name, context.sdk, functionName);
         if (!resolver) {
@@ -279,16 +342,9 @@ export class SchemaParameterResolver {
         }
         else if (resolver.type === "dynamic") {
             const dynamicResolver = resolver;
-            if (dynamicResolver.tryResolveWithoutPrompt) {
-                try {
-                    const preResolvedValue = await dynamicResolver.tryResolveWithoutPrompt(context.sdk, context.resolvedParams);
-                    if (preResolvedValue != null) {
-                        return preResolvedValue.resolvedValue;
-                    }
-                }
-                catch {
-                    // Fall through to fetch/prompt if pre-resolution fails
-                }
+            const autoResolution = await this.tryAutoResolve(dynamicResolver, context);
+            if (autoResolution != null) {
+                return autoResolution.resolvedValue;
             }
             // Only show "Fetching..." for required parameters that typically have many options
             if (param.isRequired && param.name !== "connectionId") {

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

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

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

@@ -0,0 +1,6 @@
+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();
+}