@zapier/zapier-sdk-cli 0.4.4 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk-cli",
-  "version": "0.4.4",
+  "version": "0.6.0",
   "description": "Command line interface for Zapier SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -31,9 +31,9 @@
     "ora": "^8.2.0",
     "pkce-challenge": "^5.0.0",
     "zod": "^3.25.67",
-    "@zapier/zapier-sdk": "0.5.1",
-    "@zapier/zapier-sdk-mcp": "0.1.3",
-    "@zapier/zapier-sdk-cli-login": "0.3.1"
+    "@zapier/zapier-sdk": "0.6.0",
+    "@zapier/zapier-sdk-cli-login": "0.3.2",
+    "@zapier/zapier-sdk-mcp": "0.2.0"
   },
   "devDependencies": {
     "@types/express": "^5.0.3",

package/src/cli.test.ts

@@ -8,8 +8,7 @@ describe("CLI", () => {
       cwd: __dirname + "/..",
     });
 
-    expect(result).toContain("Usage:");
-    expect(result).toContain("Commands:");
     expect(result).toContain("Options:");
+    expect(result).toContain("Commands:");
   });
 });

package/src/cli.ts

@@ -16,7 +16,7 @@ const program = new Command();
 
 program
   .name("zapier-sdk")
-  .description("CLI for Zapier SDK - Commands auto-generated from SDK schemas")
+  .description("CLI for Zapier SDK")
   .version("1.0.0")
   .option("--debug", "Enable debug logging");
 

package/src/commands/bundle-code/cli.ts

@@ -46,7 +46,11 @@ export function createBundleCodeCommand(): Command {
         command.option(flags.join(", "), param.description);
       } else {
         const flagSignature = flags.join(", ") + ` <${param.type}>`;
-        command.option(flagSignature, param.description, param.default);
+        command.option(
+          flagSignature,
+          param.description || "",
+          param.default as string | boolean | string[] | undefined,
+        );
       }
     }
   });
@@ -54,10 +58,12 @@ export function createBundleCodeCommand(): Command {
   // Add formatting options like other commands
   command.option("--json", "Output raw JSON instead of formatted results");
 
-  command.action(async (...args: any[]) => {
+  command.action(async (...args: unknown[]) => {
     try {
       // The last argument is always the command object with parsed options
-      const commandObj = args[args.length - 1];
+      const commandObj = args[args.length - 1] as {
+        opts(): Record<string, unknown>;
+      };
       const options = commandObj.opts();
 
       // Convert CLI args to SDK method parameters
@@ -76,7 +82,16 @@ export function createBundleCodeCommand(): Command {
       console.log(chalk.blue(`📦 Bundling ${rawParams.input}...`));
 
       // Call our implementation
-      const result = await bundleCode(rawParams as any);
+      const result = await bundleCode(
+        rawParams as {
+          string: boolean;
+          input: string;
+          minify: boolean;
+          target: string;
+          cjs: boolean;
+          output?: string | undefined;
+        },
+      );
 
       if (options.json) {
         console.log(JSON.stringify({ result }, null, 2));

package/src/commands/generate-types/cli.ts

@@ -48,7 +48,11 @@ export function createGenerateTypesCommand(): Command {
         command.option(flags.join(", "), param.description);
       } else {
         const flagSignature = flags.join(", ") + ` <${param.type}>`;
-        command.option(flagSignature, param.description, param.default);
+        command.option(
+          flagSignature,
+          param.description || "",
+          param.default as string | boolean | string[] | undefined,
+        );
       }
     }
   });
@@ -56,10 +60,12 @@ export function createGenerateTypesCommand(): Command {
   // Add formatting options like other commands
   command.option("--json", "Output raw JSON instead of formatted results");
 
-  command.action(async (...args: any[]) => {
+  command.action(async (...args: unknown[]) => {
     try {
       // The last argument is always the command object with parsed options
-      const commandObj = args[args.length - 1];
+      const commandObj = args[args.length - 1] as {
+        opts(): Record<string, unknown>;
+      };
       const options = commandObj.opts();
 
       // Convert CLI args to SDK method parameters
@@ -69,9 +75,10 @@ export function createGenerateTypesCommand(): Command {
         options,
       );
 
-      // Create SDK instance
-      const sdk = createZapierSdk();
-
+      // Create SDK instance with manifest path if provided
+      const sdk = createZapierSdk({
+        manifestPath: rawParams.lockFilePath as string | undefined,
+      });
       // Resolve missing parameters interactively using schema metadata
       const resolver = new SchemaParameterResolver();
       const resolvedParams = await resolver.resolveParameters(
@@ -80,20 +87,29 @@ export function createGenerateTypesCommand(): Command {
         sdk,
       );
 
+      const params = resolvedParams as Record<string, unknown>;
       console.log(
         chalk.blue(
-          `🔧 Generating TypeScript types for ${resolvedParams.appKey}...`,
+          `🔧 Generating TypeScript types for ${params.appKey as string}...`,
         ),
       );
 
       // Call our implementation
-      const result = await generateTypes({ ...resolvedParams, sdk });
+      const generateTypesParams = {
+        appKey: params.appKey as string,
+        debug: (params.debug as boolean) ?? false,
+        authenticationId: params.authenticationId as number | undefined,
+        output: params.output as string | undefined,
+        sdk,
+      };
+      const result = await generateTypes(generateTypesParams);
 
       if (options.json) {
         console.log(JSON.stringify({ result }, null, 2));
       } else {
         const output =
-          resolvedParams.output || `./types/${resolvedParams.appKey}.d.ts`;
+          (params.output as string) ||
+          `./types/${params.appKey as string}.d.ts`;
         console.log(chalk.green("✅ TypeScript types generated successfully!"));
         console.log(chalk.gray(`Output written to: ${output}`));
       }

package/src/commands/generate-types/index.ts

@@ -64,24 +64,50 @@ export async function generateTypes(
   if (authenticationId) {
     for (const action of actions) {
       try {
+        // Check to see if the appKey is in the manifest
+        const manifestEntry = sdk.getContext().getManifestEntry(appKey);
+
         const fieldsResult = await sdk.listInputFields({
-          appKey: action.app_key,
+          // If the appKey is in the manifest, use the appKey so that the types are consistent with the manifest's version, otherwise use the action.app_key
+          appKey: manifestEntry ? appKey : action.app_key,
           actionKey: action.key,
-          actionType: action.action_type as any,
+          actionType: action.action_type,
           authenticationId: authenticationId,
         });
 
-        const fields = fieldsResult.data; // Direct array result
-        actionsWithFields.push({ ...action, inputFields: fields } as any);
+        const fields = fieldsResult.data.map((field: unknown): ActionField => {
+          const fieldObj = field as {
+            is_required?: boolean;
+            required?: boolean;
+            [key: string]: unknown;
+          };
+          return {
+            ...fieldObj,
+            required: fieldObj.is_required || fieldObj.required || false,
+          } as ActionField;
+        });
+        actionsWithFields.push({
+          ...action,
+          inputFields: fields,
+          name: action.title || action.key,
+        });
       } catch {
         // If we can't get fields for an action, include it without fields
-        actionsWithFields.push({ ...action, inputFields: [] } as any);
+        actionsWithFields.push({
+          ...action,
+          inputFields: [],
+          name: action.title || action.key,
+        });
       }
     }
   } else {
     // Convert actions to have empty input fields (will generate generic types)
     actions.forEach((action: ActionItem) => {
-      actionsWithFields.push({ ...action, inputFields: [] } as any);
+      actionsWithFields.push({
+        ...action,
+        inputFields: [],
+        name: action.title || action.key,
+      });
     });
   }
 

package/src/commands/generate-types/schemas.ts

@@ -17,6 +17,10 @@ export const GenerateTypesSchema = z
     debug: DebugPropertySchema.describe(
       "Enable debug logging during generation",
     ),
+    lockFilePath: z
+      .string()
+      .optional()
+      .describe("Path to the .zapierrc lock file (defaults to .zapierrc)"),
   })
   .describe("Generate TypeScript SDK code for a specific app");
 

package/src/utils/api/client.ts

@@ -1,13 +1,13 @@
 // Simple HTTP client for OAuth authentication
-export interface ApiResponse<T = any> {
+export interface ApiResponse<T = unknown> {
   data: T;
   status: number;
 }
 
 export const createApiClient = () => {
-  const post = async <T = any>(
+  const post = async <T = unknown>(
     url: string,
-    data: any,
+    data: Record<string, string>,
     options: {
       headers?: Record<string, string>;
     } = {},

package/src/utils/auth/login.ts

@@ -2,6 +2,7 @@ import open from "open";
 import crypto from "node:crypto";
 import express from "express";
 import pkceChallenge from "pkce-challenge";
+import type { Socket } from "net";
 
 import {
   AUTH_MODE_HEADER,
@@ -86,7 +87,7 @@ const login = async (timeoutMs: number = LOGIN_TIMEOUT_MS): Promise<string> => {
   const server = app.listen(availablePort);
 
   // Track connections to force close them if needed
-  const connections = new Set<any>();
+  const connections = new Set<Socket>();
   server.on("connection", (conn) => {
     connections.add(conn);
     conn.on("close", () => connections.delete(conn));

package/src/utils/cli-generator-utils.ts

@@ -10,7 +10,7 @@ export interface CliParameter {
   type: "string" | "number" | "boolean" | "array";
   required: boolean;
   description?: string;
-  default?: any;
+  default?: unknown;
   choices?: string[];
   hasResolver?: boolean;
   isPositional?: boolean;
@@ -43,7 +43,7 @@ function analyzeZodField(
 ): CliParameter | null {
   let baseSchema = schema;
   let required = true;
-  let defaultValue: any = undefined;
+  let defaultValue: unknown = undefined;
 
   // Unwrap optional and default wrappers
   if (baseSchema instanceof z.ZodOptional) {
@@ -96,10 +96,10 @@ function analyzeZodField(
 
 export function convertCliArgsToSdkParams(
   parameters: CliParameter[],
-  positionalArgs: any[],
-  options: Record<string, any>,
-): Record<string, any> {
-  const sdkParams: Record<string, any> = {};
+  positionalArgs: unknown[],
+  options: Record<string, unknown>,
+): Record<string, unknown> {
+  const sdkParams: Record<string, unknown> = {};
 
   // Handle positional arguments (required parameters or optional positional parameters)
   let argIndex = 0;
@@ -131,7 +131,7 @@ export function convertCliArgsToSdkParams(
   return sdkParams;
 }
 
-function convertValue(value: any, type: CliParameter["type"]): any {
+function convertValue(value: unknown, type: CliParameter["type"]): unknown {
   switch (type) {
     case "number":
       return Number(value);

package/src/utils/cli-generator.ts

@@ -17,13 +17,15 @@ import inquirer from "inquirer";
 // JSON Formatting
 // ============================================================================
 
-function formatJsonOutput(data: any): void {
+function formatJsonOutput(data: unknown): void {
   // Show success message for action results
   if (
     data &&
     typeof data === "object" &&
     !Array.isArray(data) &&
-    (data.success !== undefined || data.id || data.status)
+    ((data as Record<string, unknown>).success !== undefined ||
+      (data as Record<string, unknown>).id ||
+      (data as Record<string, unknown>).status)
   ) {
     console.log(chalk.green("✅ Action completed successfully!\n"));
   }
@@ -41,7 +43,7 @@ function formatJsonOutput(data: any): void {
 interface CliCommandConfig {
   description: string;
   parameters: CliParameter[];
-  handler: (...args: any[]) => Promise<void>;
+  handler: (...args: unknown[]) => Promise<void>;
 }
 
 interface CliParameter {
@@ -49,7 +51,7 @@ interface CliParameter {
   type: "string" | "number" | "boolean" | "array";
   required: boolean;
   description?: string;
-  default?: any;
+  default?: unknown;
   choices?: string[];
   hasResolver?: boolean;
   isPositional?: boolean;
@@ -82,7 +84,7 @@ function analyzeZodField(
 ): CliParameter | null {
   let baseSchema = schema;
   let required = true;
-  let defaultValue: any = undefined;
+  let defaultValue: unknown = undefined;
 
   // Unwrap optional and default wrappers
   if (baseSchema instanceof z.ZodOptional) {
@@ -155,13 +157,15 @@ function methodNameToCliCommand(methodName: string): string {
 
 export function generateCliCommands(program: Command, sdk: ZapierSdk): void {
   // 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;
@@ -179,6 +183,75 @@ export function generateCliCommands(program: Command, sdk: ZapierSdk): void {
 
     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<string>();
+
+        // 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(
@@ -190,10 +263,12 @@ function createCommandConfig(
   const parameters = analyzeZodSchema(schema);
   const description = schema.description || `${cliCommandName} command`;
 
-  const handler = async (...args: any[]) => {
+  const handler = async (...args: unknown[]) => {
     try {
       // The last argument is always the command object with parsed options
-      const commandObj = args[args.length - 1];
+      const commandObj = args[args.length - 1] as {
+        opts(): Record<string, unknown>;
+      };
       const options = commandObj.opts();
 
       // Check if this is a list command for pagination
@@ -201,7 +276,7 @@ function createCommandConfig(
       const hasPaginationParams = parameters.some(
         (p) => p.name === "maxItems" || p.name === "pageSize",
       );
-      const hasUserSpecifiedMaxItems =
+      const hasUserSpecifiedMaxItems: boolean =
         "maxItems" in options && options.maxItems !== undefined;
       const shouldUseJson = options.json;
 
@@ -220,18 +295,6 @@ function createCommandConfig(
         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 as any)[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 &&
@@ -240,25 +303,51 @@ function createCommandConfig(
         !hasUserSpecifiedMaxItems
       ) {
         // Get the async iterator directly from the SDK method call
-        const sdkIterator = (sdk as any)[sdkMethodName](resolvedParams);
+        const sdkObj = sdk as unknown as Record<
+          string,
+          (params: unknown) => Promise<unknown>
+        >;
+        const sdkIterator = await sdkObj[sdkMethodName](resolvedParams);
         await handlePaginatedListWithAsyncIteration(
           sdkMethodName,
           sdkIterator,
           schema,
         );
       } else {
+        // Special handling for commands that write to files
+        const hasOutputFile = (resolvedParams as { output?: unknown }).output;
+        if (hasOutputFile) {
+          // Call the SDK method for file output commands
+          const sdkObj = sdk as unknown as Record<
+            string,
+            (params: unknown) => Promise<unknown>
+          >;
+          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 as any)[sdkMethodName](resolvedParams);
-        const items = result?.data ? result.data : result;
+        const sdkObj = sdk as unknown as Record<
+          string,
+          (params: unknown) => Promise<unknown>
+        >;
+        const result: unknown = await sdkObj[sdkMethodName](resolvedParams);
+        const items = (result as { data?: unknown })?.data
+          ? (result as { data: unknown }).data
+          : result;
 
         if (shouldUseJson) {
           console.log(JSON.stringify(items, null, 2));
         } else if (isListCommand) {
           formatNonPaginatedResults(
-            items,
-            resolvedParams.maxItems,
+            items as unknown[],
+            (resolvedParams as { maxItems?: number }).maxItems,
             hasUserSpecifiedMaxItems,
-            shouldUseJson,
+            shouldUseJson as boolean,
             schema,
             sdkMethodName,
           );
@@ -272,9 +361,14 @@ function createCommandConfig(
         try {
           const validationErrors = JSON.parse(error.message);
           console.error(chalk.red("❌ Validation Error:"));
-          validationErrors.forEach((err: any) => {
-            const field = err.path?.join(".") || "unknown";
-            console.error(chalk.yellow(`  • ${field}: ${err.message}`));
+          validationErrors.forEach((err: unknown) => {
+            const errorObj = err as { path?: string[]; message?: string };
+            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`),
@@ -342,10 +436,18 @@ function addCommand(
       } 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);
+        command.option(
+          flagSignature,
+          param.description,
+          param.default as string[] | undefined,
+        );
       } else {
         const flagSignature = flags.join(", ") + ` <${param.type}>`;
-        command.option(flagSignature, param.description, param.default);
+        command.option(
+          flagSignature,
+          param.description || "",
+          param.default as string | boolean | string[] | undefined,
+        );
       }
     }
   });
@@ -362,10 +464,10 @@ function addCommand(
 
 function convertCliArgsToSdkParams(
   parameters: CliParameter[],
-  positionalArgs: any[],
-  options: Record<string, any>,
-): Record<string, any> {
-  const sdkParams: Record<string, any> = {};
+  positionalArgs: unknown[],
+  options: Record<string, unknown>,
+): Record<string, unknown> {
+  const sdkParams: Record<string, unknown> = {};
 
   // Handle positional arguments (required parameters or optional positional parameters)
   let argIndex = 0;
@@ -397,7 +499,7 @@ function convertCliArgsToSdkParams(
   return sdkParams;
 }
 
-function convertValue(value: any, type: CliParameter["type"]): any {
+function convertValue(value: unknown, type: CliParameter["type"]): unknown {
   switch (type) {
     case "number":
       return Number(value);
@@ -428,7 +530,7 @@ function convertValue(value: any, type: CliParameter["type"]): any {
 
 async function handlePaginatedListWithAsyncIteration(
   sdkMethodName: string,
-  sdkResult: any,
+  sdkResult: unknown,
   schema: z.ZodSchema,
 ): Promise<void> {
   const itemName = getItemNameFromMethod(sdkMethodName);
@@ -439,7 +541,10 @@ async function handlePaginatedListWithAsyncIteration(
 
   try {
     // Use async iteration to go through pages
-    for await (const page of sdkResult) {
+    for await (const page of sdkResult as AsyncIterable<{
+      data?: unknown[];
+      nextCursor?: string;
+    }>) {
       const items = page.data || page;
       pageCount++;
 
@@ -502,7 +607,7 @@ async function handlePaginatedListWithAsyncIteration(
     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;
+    const items = (sdkResult as { data?: unknown[] })?.data || sdkResult;
     if (Array.isArray(items)) {
       if (items.length === 0) {
         console.log(chalk.yellow(`No ${itemName} found.`));
@@ -523,7 +628,7 @@ async function handlePaginatedListWithAsyncIteration(
 }
 
 function formatNonPaginatedResults(
-  result: any[],
+  result: unknown[],
   requestedMaxItems?: number,
   userSpecifiedMaxItems?: boolean,
   useRawJson?: boolean,
@@ -573,13 +678,14 @@ function formatNonPaginatedResults(
   }
 }
 
-function formatItemsGeneric(items: any[]): void {
+function formatItemsGeneric(items: unknown[]): void {
   // 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 as Record<string, unknown>;
+    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();
   });