@zapier/zapier-sdk-cli 0.4.4 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk-cli",
-  "version": "0.4.4",
+  "version": "0.5.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.5.2",
+    "@zapier/zapier-sdk-cli-login": "0.3.2",
+    "@zapier/zapier-sdk-mcp": "0.1.4"
   },
   "devDependencies": {
     "@types/express": "^5.0.3",

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
@@ -80,20 +86,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/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/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) {
@@ -190,10 +192,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 +205,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 +224,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 +232,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 +290,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 +365,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 +393,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 +428,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 +459,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 +470,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 +536,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 +557,7 @@ async function handlePaginatedListWithAsyncIteration(
 }
 
 function formatNonPaginatedResults(
-  result: any[],
+  result: unknown[],
   requestedMaxItems?: number,
   userSpecifiedMaxItems?: boolean,
   useRawJson?: boolean,
@@ -573,13 +607,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();
   });

package/src/utils/log.ts

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