@zapier/zapier-sdk-cli 0.4.1 → 0.4.2

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

@@ -0,0 +1,443 @@
+import { z } from "zod";
+import { hasResolver, isPositional, formatErrorMessage, ZapierError, } from "@zapier/zapier-sdk";
+import { SchemaParameterResolver } from "./parameter-resolver";
+import { formatItemsFromSchema } from "./schema-formatter";
+import chalk from "chalk";
+import util from "util";
+import inquirer from "inquirer";
+// ============================================================================
+// JSON Formatting
+// ============================================================================
+function formatJsonOutput(data) {
+    // Show success message for action results
+    if (data &&
+        typeof data === "object" &&
+        !Array.isArray(data) &&
+        (data.success !== undefined || data.id || data.status)) {
+        console.log(chalk.green("✅ Action completed successfully!\n"));
+    }
+    // Use util.inspect for colored output
+    console.log(util.inspect(data, { colors: true, depth: null, breakLength: 80 }));
+}
+// ============================================================================
+// Schema Analysis
+// ============================================================================
+function analyzeZodSchema(schema) {
+    const parameters = [];
+    if (schema instanceof z.ZodObject) {
+        const shape = schema.shape;
+        for (const [key, fieldSchema] of Object.entries(shape)) {
+            const param = analyzeZodField(key, fieldSchema);
+            if (param) {
+                parameters.push(param);
+            }
+        }
+    }
+    return parameters;
+}
+function analyzeZodField(name, schema) {
+    let baseSchema = schema;
+    let required = true;
+    let defaultValue = undefined;
+    // Unwrap optional and default wrappers
+    if (baseSchema instanceof z.ZodOptional) {
+        required = false;
+        baseSchema = baseSchema._def.innerType;
+    }
+    if (baseSchema instanceof z.ZodDefault) {
+        required = false;
+        defaultValue = baseSchema._def.defaultValue();
+        baseSchema = baseSchema._def.innerType;
+    }
+    // Determine parameter type
+    let paramType = "string";
+    let choices;
+    if (baseSchema instanceof z.ZodString) {
+        paramType = "string";
+    }
+    else if (baseSchema instanceof z.ZodNumber) {
+        paramType = "number";
+    }
+    else if (baseSchema instanceof z.ZodBoolean) {
+        paramType = "boolean";
+    }
+    else if (baseSchema instanceof z.ZodArray) {
+        paramType = "array";
+    }
+    else if (baseSchema instanceof z.ZodEnum) {
+        paramType = "string";
+        choices = baseSchema._def.values;
+    }
+    else if (baseSchema instanceof z.ZodRecord) {
+        // Handle Record<string, any> as JSON string input
+        paramType = "string";
+    }
+    // Extract resolver metadata
+    return {
+        name,
+        type: paramType,
+        required,
+        description: schema.description,
+        default: defaultValue,
+        choices,
+        hasResolver: hasResolver(name),
+        isPositional: isPositional(schema),
+    };
+}
+// ============================================================================
+// CLI Structure Derivation - Purely Generic
+// ============================================================================
+/**
+ * Convert camelCase to kebab-case
+ * e.g., listApps -> list-apps, generateTypes -> generate-types
+ */
+function toKebabCase(str) {
+    return str.replace(/([A-Z])/g, "-$1").toLowerCase();
+}
+/**
+ * Convert SDK method name directly to CLI command
+ * e.g., listApps -> list-apps, getApp -> get-app, generateTypes -> generate-types
+ */
+function methodNameToCliCommand(methodName) {
+    return toKebabCase(methodName);
+}
+// ============================================================================
+// CLI Command Generation - Completely Generic
+// ============================================================================
+export function generateCliCommands(program, sdk) {
+    // Check if SDK has registry
+    if (!sdk.__registry) {
+        console.error("SDK registry not available");
+        return;
+    }
+    // Generate one flat command for each function in the registry
+    sdk.__registry.forEach((fnInfo) => {
+        if (!fnInfo.inputSchema) {
+            console.warn(`Schema not found for ${fnInfo.name}`);
+            return;
+        }
+        // Convert methodName to kebab-case CLI command
+        const cliCommandName = methodNameToCliCommand(fnInfo.name);
+        const config = createCommandConfig(cliCommandName, fnInfo.name, fnInfo.inputSchema, sdk);
+        addCommand(program, cliCommandName, config);
+    });
+}
+function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
+    const parameters = analyzeZodSchema(schema);
+    const description = schema.description || `${cliCommandName} command`;
+    const handler = async (...args) => {
+        try {
+            // The last argument is always the command object with parsed options
+            const commandObj = args[args.length - 1];
+            const options = commandObj.opts();
+            // Check if this is a list command for pagination
+            const isListCommand = cliCommandName.startsWith("list-");
+            const hasPaginationParams = parameters.some((p) => p.name === "maxItems" || p.name === "pageSize");
+            const hasUserSpecifiedMaxItems = "maxItems" in options && options.maxItems !== undefined;
+            const shouldUseJson = options.json;
+            // Convert CLI args to SDK method parameters
+            const rawParams = convertCliArgsToSdkParams(parameters, args.slice(0, -1), options);
+            // Resolve missing parameters interactively using schema metadata
+            const resolver = new SchemaParameterResolver();
+            const resolvedParams = await resolver.resolveParameters(schema, rawParams, sdk);
+            // Special handling for commands that write to files
+            const hasOutputFile = resolvedParams.output;
+            if (hasOutputFile) {
+                // Call the SDK method for file output commands
+                await sdk[sdkMethodName](resolvedParams);
+                console.log(chalk.green(`✅ ${cliCommandName} completed successfully!`));
+                console.log(chalk.gray(`Output written to: ${resolvedParams.output}`));
+                return;
+            }
+            // Handle paginated list commands with async iteration
+            if (isListCommand &&
+                hasPaginationParams &&
+                !shouldUseJson &&
+                !hasUserSpecifiedMaxItems) {
+                // Get the async iterator directly from the SDK method call
+                const sdkIterator = sdk[sdkMethodName](resolvedParams);
+                await handlePaginatedListWithAsyncIteration(sdkMethodName, sdkIterator, schema);
+            }
+            else {
+                // Call the SDK method and handle non-paginated results
+                const result = await sdk[sdkMethodName](resolvedParams);
+                const items = result?.data ? result.data : result;
+                if (shouldUseJson) {
+                    console.log(JSON.stringify(items, null, 2));
+                }
+                else if (isListCommand) {
+                    formatNonPaginatedResults(items, resolvedParams.maxItems, hasUserSpecifiedMaxItems, shouldUseJson, schema, sdkMethodName);
+                }
+                else {
+                    formatJsonOutput(items);
+                }
+            }
+        }
+        catch (error) {
+            // Handle Zod validation errors more gracefully
+            if (error instanceof Error && error.message.includes('"code"')) {
+                try {
+                    const validationErrors = JSON.parse(error.message);
+                    console.error(chalk.red("❌ Validation Error:"));
+                    validationErrors.forEach((err) => {
+                        const field = err.path?.join(".") || "unknown";
+                        console.error(chalk.yellow(`  • ${field}: ${err.message}`));
+                    });
+                    console.error("\n" + chalk.dim(`Use --help to see available options`));
+                }
+                catch {
+                    console.error(chalk.red("Error:"), error.message);
+                }
+            }
+            else if (error instanceof ZapierError) {
+                // Handle SDK errors with clean, user-friendly messages using our formatter
+                const formattedMessage = formatErrorMessage(error);
+                console.error(chalk.red("❌ Error:"), formattedMessage);
+            }
+            else {
+                // Handle other errors
+                const errorMessage = error instanceof Error ? error.message : "Unknown error";
+                console.error(chalk.red("❌ Error:"), errorMessage);
+            }
+            process.exit(1);
+        }
+    };
+    return {
+        description,
+        parameters,
+        handler,
+    };
+}
+function addCommand(program, commandName, config) {
+    const command = program.command(commandName).description(config.description);
+    // Add parameters to command
+    config.parameters.forEach((param) => {
+        // Convert camelCase to kebab-case for CLI display
+        const kebabName = param.name.replace(/([A-Z])/g, "-$1").toLowerCase();
+        if (param.hasResolver && param.required) {
+            // Required parameters with resolvers become optional positional arguments (resolver handles prompting)
+            command.argument(`[${kebabName}]`, param.description || `${kebabName} parameter`);
+        }
+        else if (param.required) {
+            // Required parameters without resolvers become required positional arguments
+            command.argument(`<${kebabName}>`, param.description || `${kebabName} parameter`);
+        }
+        else if (param.isPositional) {
+            // Optional parameters marked as positional become optional positional arguments
+            command.argument(`[${kebabName}]`, param.description || `${kebabName} parameter`);
+        }
+        else {
+            // Optional parameters become flags (whether they have resolvers or not)
+            const flags = [`--${kebabName}`];
+            if (param.type === "boolean") {
+                command.option(flags.join(", "), param.description);
+            }
+            else if (param.type === "array") {
+                // For arrays, use variadic syntax to collect multiple values
+                const flagSignature = flags.join(", ") + ` <values...>`;
+                command.option(flagSignature, param.description, param.default);
+            }
+            else {
+                const flagSignature = flags.join(", ") + ` <${param.type}>`;
+                command.option(flagSignature, param.description, param.default);
+            }
+        }
+    });
+    // Add formatting options for all commands
+    command.option("--json", "Output raw JSON instead of formatted results");
+    command.action(config.handler);
+}
+// ============================================================================
+// Parameter Conversion
+// ============================================================================
+function convertCliArgsToSdkParams(parameters, positionalArgs, options) {
+    const sdkParams = {};
+    // Handle positional arguments (required parameters or optional positional parameters)
+    let argIndex = 0;
+    parameters.forEach((param) => {
+        if ((param.required || param.isPositional) &&
+            argIndex < positionalArgs.length) {
+            // Use the original camelCase parameter name for the SDK
+            sdkParams[param.name] = convertValue(positionalArgs[argIndex], param.type);
+            argIndex++;
+        }
+    });
+    // Handle option flags
+    Object.entries(options).forEach(([key, value]) => {
+        // Convert kebab-case back to camelCase
+        const camelKey = key.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+        const param = parameters.find((p) => p.name === camelKey);
+        if (param && value !== undefined) {
+            sdkParams[camelKey] = convertValue(value, param.type);
+        }
+    });
+    return sdkParams;
+}
+function convertValue(value, type) {
+    switch (type) {
+        case "number":
+            return Number(value);
+        case "boolean":
+            return Boolean(value);
+        case "array":
+            return Array.isArray(value) ? value : [value];
+        case "string":
+        default:
+            // Handle JSON string for objects
+            if (typeof value === "string" &&
+                (value.startsWith("{") || value.startsWith("["))) {
+                try {
+                    return JSON.parse(value);
+                }
+                catch {
+                    return value;
+                }
+            }
+            return value;
+    }
+}
+// ============================================================================
+// Pagination Handlers
+// ============================================================================
+async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, schema) {
+    const itemName = getItemNameFromMethod(sdkMethodName);
+    let totalShown = 0;
+    let pageCount = 0;
+    console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName)}\n`));
+    try {
+        // Use async iteration to go through pages
+        for await (const page of sdkResult) {
+            const items = page.data || page;
+            pageCount++;
+            if (!Array.isArray(items)) {
+                console.log(chalk.yellow(`No ${itemName} found.`));
+                return;
+            }
+            if (items.length === 0 && pageCount === 1) {
+                console.log(chalk.yellow(`No ${itemName} found.`));
+                return;
+            }
+            if (items.length === 0) {
+                break; // No more items
+            }
+            // Clear screen for subsequent pages (not the first)
+            if (pageCount > 1) {
+                console.clear();
+                console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName)}\n`));
+            }
+            // Format and display items using schema
+            if (schema) {
+                formatItemsFromSchema(schema, items);
+            }
+            else {
+                formatItemsGeneric(items);
+            }
+            totalShown += items.length;
+            console.log(chalk.green(`\n✅ Showing ${totalShown} ${itemName} (page ${pageCount})`));
+            // Only prompt if there's a nextCursor (more pages available)
+            if (page.nextCursor) {
+                const { continueReading } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "continueReading",
+                        message: `Load next page?`,
+                        default: true,
+                    },
+                ]);
+                if (!continueReading) {
+                    break;
+                }
+            }
+            else {
+                // No more pages available, exit gracefully
+                break;
+            }
+        }
+        console.log(chalk.gray(`\n📄 Finished browsing ${itemName}`));
+    }
+    catch (error) {
+        // If the result is not async iterable, fall back to showing the first page
+        const items = sdkResult?.data || sdkResult;
+        if (Array.isArray(items)) {
+            if (items.length === 0) {
+                console.log(chalk.yellow(`No ${itemName} found.`));
+                return;
+            }
+            if (schema) {
+                formatItemsFromSchema(schema, items);
+            }
+            else {
+                formatItemsGeneric(items);
+            }
+            console.log(chalk.green(`\n✅ Showing ${items.length} ${itemName}`));
+        }
+        else {
+            throw error;
+        }
+    }
+}
+function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxItems, useRawJson, schema, methodName) {
+    if (!Array.isArray(result)) {
+        if (useRawJson) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            formatJsonOutput(result);
+        }
+        return;
+    }
+    if (useRawJson) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    const itemName = methodName ? getItemNameFromMethod(methodName) : "items";
+    if (result.length === 0) {
+        console.log(chalk.yellow(`No ${itemName} found.`));
+        return;
+    }
+    console.log(chalk.green(`\n✅ Found ${result.length} ${itemName}:\n`));
+    // Use schema for formatting
+    if (schema) {
+        formatItemsFromSchema(schema, result);
+    }
+    else {
+        // Fallback to generic formatting
+        formatItemsGeneric(result);
+    }
+    // Show appropriate status message
+    if (userSpecifiedMaxItems && requestedMaxItems) {
+        console.log(chalk.gray(`\n📄 Showing up to ${requestedMaxItems} ${itemName} (--max-items ${requestedMaxItems})`));
+    }
+    else {
+        console.log(chalk.gray(`\n📄 All available ${itemName} shown`));
+    }
+}
+function formatItemsGeneric(items) {
+    // Fallback formatting for items without schema metadata
+    items.forEach((item, index) => {
+        const name = item.title || item.name || item.key || item.id || "Item";
+        console.log(`${chalk.gray(`${index + 1}.`)} ${chalk.cyan(name)}`);
+        if (item.description) {
+            console.log(`   ${chalk.dim(item.description)}`);
+        }
+        console.log();
+    });
+}
+// Generic helper functions that infer from schema description or method name
+function getItemNameFromMethod(methodName) {
+    // Extract from method name: listApps -> apps, listActions -> actions
+    const listMatch = methodName.match(/^list(.+)$/);
+    if (listMatch) {
+        return listMatch[1].toLowerCase();
+    }
+    // Fallback to generic
+    return "items";
+}
+function getListTitleFromMethod(methodName) {
+    const itemName = getItemNameFromMethod(methodName);
+    if (itemName === "items")
+        return "Available Items";
+    // Capitalize first letter: apps -> Apps
+    const capitalized = itemName.charAt(0).toUpperCase() + itemName.slice(1);
+    return `Available ${capitalized}`;
+}

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

@@ -0,0 +1,5 @@
+export declare const ZAPIER_BASE = "https://zapier.com";
+export declare const LOGIN_CLIENT_ID = "K5eEnRE9TTmSFATdkkWhKF8NOKwoiOnYAyIqJjae";
+export declare const LOGIN_PORTS: number[];
+export declare const LOGIN_TIMEOUT_MS = 300000;
+export declare const AUTH_MODE_HEADER = "X-Auth";

package/dist/src/utils/constants.js

@@ -0,0 +1,6 @@
+export const ZAPIER_BASE = "https://zapier.com";
+// OAuth client ID for zapier-sdk CLI
+export const LOGIN_CLIENT_ID = "K5eEnRE9TTmSFATdkkWhKF8NOKwoiOnYAyIqJjae";
+export const LOGIN_PORTS = [49505, 50575, 52804, 55981, 61010, 63851];
+export const LOGIN_TIMEOUT_MS = 300000; // 5 minutes
+export const AUTH_MODE_HEADER = "X-Auth";

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

@@ -0,0 +1,6 @@
+declare const getCallablePromise: <T>() => {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (reason: unknown) => void;
+};
+export default getCallablePromise;

package/dist/src/utils/getCallablePromise.js

@@ -0,0 +1,14 @@
+const getCallablePromise = () => {
+    let resolve = () => { };
+    let reject = () => { };
+    const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+    });
+    return {
+        promise,
+        resolve,
+        reject,
+    };
+};
+export default getCallablePromise;

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

@@ -0,0 +1,7 @@
+declare const log: {
+    info: (message: string, ...args: any[]) => void;
+    error: (message: string, ...args: any[]) => void;
+    success: (message: string, ...args: any[]) => void;
+    warn: (message: string, ...args: any[]) => void;
+};
+export default log;

package/dist/src/utils/log.js

@@ -0,0 +1,16 @@
+import chalk from "chalk";
+const log = {
+    info: (message, ...args) => {
+        console.log(chalk.blue("ℹ"), message, ...args);
+    },
+    error: (message, ...args) => {
+        console.error(chalk.red("✖"), message, ...args);
+    },
+    success: (message, ...args) => {
+        console.log(chalk.green("✓"), message, ...args);
+    },
+    warn: (message, ...args) => {
+        console.log(chalk.yellow("⚠"), message, ...args);
+    },
+};
+export default log;

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

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { ZapierSdk } from "@zapier/zapier-sdk";
+export declare class SchemaParameterResolver {
+    resolveParameters(schema: z.ZodSchema, providedParams: any, sdk: ZapierSdk): Promise<any>;
+    private extractParametersFromSchema;
+    private analyzeFieldSchema;
+    private createResolvableParameter;
+    private resolveParameter;
+    private resolveFieldsRecursively;
+    private getNestedValue;
+    private setNestedValue;
+    private promptForField;
+    private isUserCancellation;
+}