@zapier/zapier-sdk-cli 0.4.4 → 0.6.0

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

@@ -13,7 +13,9 @@ function formatJsonOutput(data) {
     if (data &&
         typeof data === "object" &&
         !Array.isArray(data) &&
-        (data.success !== undefined || data.id || data.status)) {
+        (data.success !== undefined ||
+            data.id ||
+            data.status)) {
         console.log(chalk.green("✅ Action completed successfully!\n"));
     }
     // Use util.inspect for colored output
@@ -106,12 +108,13 @@ function methodNameToCliCommand(methodName) {
 // ============================================================================
 export function generateCliCommands(program, sdk) {
     // Check if SDK has registry
-    if (!sdk.__registry) {
+    if (typeof sdk.getRegistry !== "function") {
         console.error("SDK registry not available");
         return;
     }
-    // Generate one flat command for each function in the registry
-    sdk.__registry.forEach((fnInfo) => {
+    const registry = sdk.getRegistry();
+    // Create all commands first
+    registry.functions.forEach((fnInfo) => {
         if (!fnInfo.inputSchema) {
             console.warn(`Schema not found for ${fnInfo.name}`);
             return;
@@ -121,6 +124,57 @@ export function generateCliCommands(program, sdk) {
         const config = createCommandConfig(cliCommandName, fnInfo.name, fnInfo.inputSchema, sdk);
         addCommand(program, cliCommandName, config);
     });
+    // Override the help display to show commands grouped by category
+    program.configureHelp({
+        formatHelp: (cmd, helper) => {
+            const helpWidth = helper.helpWidth || 80;
+            let output = helper.commandUsage(cmd) + "\n";
+            if (cmd.description()) {
+                output += helper.wrap(cmd.description(), helpWidth, 0) + "\n";
+            }
+            // Add options section
+            const options = helper.visibleOptions(cmd);
+            if (options.length > 0) {
+                output += "\nOptions:\n";
+                const longestOptionLength = Math.max(...options.map((opt) => helper.optionTerm(opt).length));
+                options.forEach((option) => {
+                    const term = helper.optionTerm(option);
+                    const padding = " ".repeat(Math.max(2, longestOptionLength - term.length + 4));
+                    output += `  ${term}${padding}${helper.optionDescription(option)}\n`;
+                });
+            }
+            // Add categorized commands section
+            const commands = helper.visibleCommands(cmd);
+            if (commands.length > 0) {
+                output += "\nCommands:\n";
+                // Collect all SDK commands that belong to categories
+                const categorizedCommands = new Set();
+                // Group SDK commands by categories
+                registry.categories.forEach((category) => {
+                    const categoryCommands = commands.filter((command) => category.functions.some((functionName) => {
+                        const cliCommandName = methodNameToCliCommand(functionName);
+                        return command.name() === cliCommandName;
+                    }));
+                    if (categoryCommands.length > 0) {
+                        output += `\n  ${category.titlePlural}:\n`;
+                        categoryCommands.forEach((command) => {
+                            output += `    ${helper.subcommandTerm(command)}\n`;
+                            categorizedCommands.add(command.name());
+                        });
+                    }
+                });
+                // Add any remaining commands that aren't part of SDK categories
+                const otherCommands = commands.filter((command) => !categorizedCommands.has(command.name()));
+                if (otherCommands.length > 0) {
+                    output += `\n  Other:\n`;
+                    otherCommands.forEach((command) => {
+                        output += `    ${helper.subcommandTerm(command)}\n`;
+                    });
+                }
+            }
+            return output;
+        },
+    });
 }
 function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
     const parameters = analyzeZodSchema(schema);
@@ -140,28 +194,33 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
             // 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);
+                const sdkObj = sdk;
+                const sdkIterator = await sdkObj[sdkMethodName](resolvedParams);
                 await handlePaginatedListWithAsyncIteration(sdkMethodName, sdkIterator, schema);
             }
             else {
+                // Special handling for commands that write to files
+                const hasOutputFile = resolvedParams.output;
+                if (hasOutputFile) {
+                    // Call the SDK method for file output commands
+                    const sdkObj = sdk;
+                    await sdkObj[sdkMethodName](resolvedParams);
+                    console.log(chalk.green(`✅ ${cliCommandName} completed successfully!`));
+                    console.log(chalk.gray(`Output written to: ${hasOutputFile}`));
+                    return;
+                }
                 // Call the SDK method and handle non-paginated results
-                const result = await sdk[sdkMethodName](resolvedParams);
-                const items = result?.data ? result.data : result;
+                const sdkObj = sdk;
+                const result = await sdkObj[sdkMethodName](resolvedParams);
+                const items = result?.data
+                    ? result.data
+                    : result;
                 if (shouldUseJson) {
                     console.log(JSON.stringify(items, null, 2));
                 }
@@ -180,8 +239,9 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
                     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}`));
+                        const errorObj = err;
+                        const field = errorObj?.path?.join(".") || "unknown";
+                        console.error(chalk.yellow(`  • ${field}: ${errorObj?.message || "Unknown error"}`));
                     });
                     console.error("\n" + chalk.dim(`Use --help to see available options`));
                 }
@@ -239,7 +299,7 @@ function addCommand(program, commandName, config) {
             }
             else {
                 const flagSignature = flags.join(", ") + ` <${param.type}>`;
-                command.option(flagSignature, param.description, param.default);
+                command.option(flagSignature, param.description || "", param.default);
             }
         }
     });
@@ -415,10 +475,11 @@ function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxIt
 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)}`);
+        const itemObj = item;
+        const name = itemObj?.name || itemObj?.key || itemObj?.id || "Item";
+        console.log(`${chalk.gray(`${index + 1}.`)} ${chalk.cyan(String(name))}`);
+        if (itemObj?.description) {
+            console.log(`   ${chalk.dim(String(itemObj.description))}`);
         }
         console.log();
     });

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

@@ -1,7 +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;
+    info: (message: string, ...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+    success: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
 };
 export default log;

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { ZapierSdk } from "@zapier/zapier-sdk";
 export declare class SchemaParameterResolver {
-    resolveParameters(schema: z.ZodSchema, providedParams: any, sdk: ZapierSdk): Promise<any>;
+    resolveParameters(schema: z.ZodSchema, providedParams: unknown, sdk: ZapierSdk): Promise<unknown>;
     private extractParametersFromSchema;
     private analyzeFieldSchema;
     private createResolvableParameter;

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

@@ -55,7 +55,7 @@ export class SchemaParameterResolver {
             }
             return parseResult.data;
         }
-        // 2. Resolve functionally required parameters and their dependencies first
+        // 2. Resolve functionally required parameters first
         const resolvedParams = { ...providedParams };
         const context = {
             sdk,
@@ -214,28 +214,31 @@ export class SchemaParameterResolver {
             throw new Error(`No resolver found for parameter: ${param.name}`);
         }
         console.log(chalk.blue(`\n🔍 Resolving ${param.name}...`));
-        if (resolver.type === "static") {
+        const typedResolver = resolver;
+        if (typedResolver.type === "static") {
             // Static resolver - just prompt for input
             const promptConfig = {
-                type: resolver.inputType === "password" ? "password" : "input",
+                type: typedResolver.inputType === "password" ? "password" : "input",
                 name: param.name,
                 message: `Enter ${param.name}:`,
-                ...(resolver.placeholder && { default: resolver.placeholder }),
+                ...(typedResolver.placeholder && {
+                    default: typedResolver.placeholder,
+                }),
             };
             const answers = await inquirer.prompt([promptConfig]);
             return answers[param.name];
         }
-        else if (resolver.type === "dynamic") {
+        else if (typedResolver.type === "dynamic") {
             // Dynamic resolver - fetch options and prompt for selection
             try {
                 // Only show "Fetching..." for required parameters that typically have many options
                 if (param.isRequired && param.name !== "authenticationId") {
                     console.log(chalk.gray(`Fetching options for ${param.name}...`));
                 }
-                const items = await resolver.fetch(context.sdk, context.resolvedParams);
+                const items = await typedResolver.fetch(context.sdk, context.resolvedParams);
                 // Let the resolver's prompt handle empty lists (e.g., authenticationId can show "skip authentication")
                 const safeItems = items || [];
-                const promptConfig = resolver.prompt(safeItems, context.resolvedParams);
+                const promptConfig = typedResolver.prompt(safeItems, context.resolvedParams);
                 const answers = await inquirer.prompt([promptConfig]);
                 return answers[param.name];
             }
@@ -244,13 +247,14 @@ export class SchemaParameterResolver {
                 throw error;
             }
         }
-        else if (resolver.type === "fields") {
+        else if (typedResolver.type === "fields") {
             // Fields resolver - fetch field definitions and prompt for each input with recursive field resolution
             return await this.resolveFieldsRecursively(resolver, context, param);
         }
         throw new Error(`Unknown resolver type for ${param.name}`);
     }
     async resolveFieldsRecursively(resolver, context, param) {
+        const typedResolver = resolver;
         const inputs = {};
         let processedFieldKeys = new Set();
         let iteration = 0;
@@ -266,7 +270,7 @@ export class SchemaParameterResolver {
                 },
             };
             console.log(chalk.gray(`Fetching input fields for ${param.name}${iteration > 1 ? ` (iteration ${iteration})` : ""}...`));
-            const fields = await resolver.fetch(updatedContext.sdk, updatedContext.resolvedParams);
+            const fields = await typedResolver.fetch(updatedContext.sdk, updatedContext.resolvedParams);
             if (!fields || fields.length === 0) {
                 if (iteration === 1) {
                     console.log(chalk.yellow(`No input fields required for this action.`));
@@ -274,7 +278,8 @@ export class SchemaParameterResolver {
                 break;
             }
             // Find new fields that we haven't processed yet
-            const newFields = fields.filter((field) => !processedFieldKeys.has(field.key));
+            const newFields = fields.filter((field) => !(field.key &&
+                processedFieldKeys.has(field.key)));
             if (newFields.length === 0) {
                 // No new fields, we're done
                 break;
@@ -340,35 +345,44 @@ export class SchemaParameterResolver {
     setNestedValue(obj, path, value) {
         const lastKey = path[path.length - 1];
         const parent = path.slice(0, -1).reduce((current, key) => {
-            if (!(key in current)) {
-                current[key] = {};
+            const currentObj = current;
+            if (!(key in currentObj)) {
+                currentObj[key] = {};
             }
-            return current[key];
+            return currentObj[key];
         }, obj);
         parent[lastKey] = value;
     }
     async promptForField(field, inputs) {
+        const fieldObj = field;
         const fieldPrompt = {
-            type: field.type === "boolean" ? "confirm" : "input",
-            name: field.key,
-            message: `${field.label || field.key}${field.required ? " (required)" : " (optional)"}:`,
-            ...(field.helpText && { prefix: chalk.gray(`ℹ ${field.helpText}\n`) }),
-            ...(field.default && { default: field.default }),
+            type: fieldObj.type === "boolean" ? "confirm" : "input",
+            name: fieldObj.key,
+            message: `${fieldObj.label || fieldObj.key}${fieldObj.required ? " (required)" : " (optional)"}:`,
         };
-        if (field.choices && field.choices.length > 0) {
+        if (fieldObj.helpText) {
+            fieldPrompt.prefix = chalk.gray(`ℹ ${fieldObj.helpText}\n`);
+        }
+        if (fieldObj.default !== undefined) {
+            fieldPrompt.default = fieldObj.default;
+        }
+        if (fieldObj.choices && fieldObj.choices.length > 0) {
             fieldPrompt.type = "list";
-            fieldPrompt.choices = field.choices.map((choice) => ({
-                name: choice.label || choice.value,
-                value: choice.value,
-            }));
+            fieldPrompt.choices = fieldObj.choices.map((choice) => {
+                const choiceObj = choice;
+                return {
+                    name: choiceObj.label || choiceObj.value,
+                    value: choiceObj.value,
+                };
+            });
         }
         try {
             const answer = await inquirer.prompt([fieldPrompt]);
-            if (answer[field.key] !== undefined && answer[field.key] !== "") {
-                inputs[field.key] = answer[field.key];
+            if (answer[fieldObj.key] !== undefined && answer[fieldObj.key] !== "") {
+                inputs[fieldObj.key] = answer[fieldObj.key];
             }
-            else if (field.required) {
-                throw new Error(`Required field ${field.key} cannot be empty`);
+            else if (fieldObj.required) {
+                throw new Error(`Required field ${fieldObj.key} cannot be empty`);
             }
         }
         catch (error) {
@@ -380,8 +394,9 @@ export class SchemaParameterResolver {
         }
     }
     isUserCancellation(error) {
-        return (error?.name === "ExitPromptError" ||
-            error?.message?.includes("User force closed") ||
-            error?.isTTYError);
+        const errorObj = error;
+        return (errorObj?.name === "ExitPromptError" ||
+            errorObj?.message?.includes("User force closed") ||
+            errorObj?.isTTYError === true);
     }
 }

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

@@ -1,2 +1,2 @@
 import { z } from "zod";
-export declare function formatItemsFromSchema(inputSchema: z.ZodType, items: any[]): void;
+export declare function formatItemsFromSchema(inputSchema: z.ZodType, items: unknown[]): void;

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

@@ -1,6 +1,7 @@
 import chalk from "chalk";
 function getFormatMetadata(schema) {
-    return schema?._def?.formatMeta;
+    return schema?._def
+        ?.formatMeta;
 }
 function getOutputSchema(schema) {
     return schema?._def?.outputSchema;
@@ -61,10 +62,11 @@ function applyStyle(value, style) {
 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";
+        const itemObj = item;
+        const name = itemObj.title || itemObj.name || itemObj.key || itemObj.id || "Item";
         console.log(`${chalk.gray(`${index + 1}.`)} ${chalk.cyan(name)}`);
-        if (item.description) {
-            console.log(`   ${chalk.dim(item.description)}`);
+        if (itemObj.description) {
+            console.log(`   ${chalk.dim(itemObj.description)}`);
         }
         console.log();
     });