@zapier/zapier-sdk-cli 0.5.0 → 0.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk-cli",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "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.2",
+    "@zapier/zapier-sdk": "0.6.1",
     "@zapier/zapier-sdk-cli-login": "0.3.2",
-    "@zapier/zapier-sdk-mcp": "0.1.4"
+    "@zapier/zapier-sdk-mcp": "0.2.1"
   },
   "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/generate-types/cli.ts

@@ -75,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(

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/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.ts

@@ -157,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;
@@ -181,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(

package/src/utils/parameter-resolver.ts

@@ -306,7 +306,7 @@ export class SchemaParameterResolver {
   private async resolveParameter(
     param: ResolvableParameter,
     context: ResolverContext,
-  ): Promise<any> {
+  ): Promise<unknown> {
     const resolver = getResolver(param.name);
     if (!resolver) {
       throw new Error(`No resolver found for parameter: ${param.name}`);
@@ -314,39 +314,55 @@ export class SchemaParameterResolver {
 
     console.log(chalk.blue(`\n🔍 Resolving ${param.name}...`));
 
-    if (resolver.type === "static") {
+    const typedResolver = resolver as {
+      type: string;
+      inputType?: string;
+      placeholder?: string;
+      fetch?: Function;
+      prompt?: Function;
+    };
+
+    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 as any]);
       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 as any]);
         return answers[param.name];
       } catch (error) {
         // Let the main CLI error handler display user-friendly errors
         throw error;
       }
-    } else if ((resolver as any).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 as any,
+        resolver as unknown,
         context,
         param,
       );
@@ -356,14 +372,12 @@ export class SchemaParameterResolver {
   }
 
   private async resolveFieldsRecursively(
-    resolver: {
-      fetch: (sdk: unknown, params: unknown) => Promise<unknown[]>;
-      prompt: (items: unknown[], params: unknown) => unknown;
-    },
+    resolver: unknown,
     context: ResolverContext,
     param: ResolvableParameter,
-  ): Promise<Record<string, any>> {
-    const inputs: Record<string, any> = {};
+  ): Promise<Record<string, unknown>> {
+    const typedResolver = resolver as { fetch: Function };
+    const inputs: Record<string, unknown> = {};
     let processedFieldKeys = new Set<string>();
     let iteration = 0;
     const maxIterations = 5; // Prevent infinite loops
@@ -386,7 +400,7 @@ export class SchemaParameterResolver {
         ),
       );
 
-      const fields = await resolver.fetch(
+      const fields = await typedResolver.fetch(
         updatedContext.sdk,
         updatedContext.resolvedParams,
       );
@@ -516,7 +530,7 @@ export class SchemaParameterResolver {
 
   private async promptForField(
     field: unknown,
-    inputs: Record<string, any>,
+    inputs: Record<string, unknown>,
   ): Promise<void> {
     const fieldObj = field as {
       type?: string;

package/src/utils/schema-formatter.ts

@@ -13,15 +13,16 @@ interface FormattedItem {
 }
 
 interface FormatMetadata {
-  format: (item: any) => FormattedItem;
+  format: (item: unknown) => FormattedItem;
 }
 
-function getFormatMetadata(schema: any): FormatMetadata | undefined {
-  return schema?._def?.formatMeta;
+function getFormatMetadata(schema: unknown): FormatMetadata | undefined {
+  return (schema as { _def?: { formatMeta?: FormatMetadata } })?._def
+    ?.formatMeta;
 }
 
-function getOutputSchema(schema: any): any {
-  return schema?._def?.outputSchema;
+function getOutputSchema(schema: unknown): unknown {
+  return (schema as { _def?: { outputSchema?: unknown } })?._def?.outputSchema;
 }
 
 // ============================================================================
@@ -30,7 +31,7 @@ function getOutputSchema(schema: any): any {
 
 export function formatItemsFromSchema(
   inputSchema: z.ZodType,
-  items: any[],
+  items: unknown[],
 ): void {
   // Get the output schema and its format metadata
   const outputSchema = getOutputSchema(inputSchema);
@@ -54,7 +55,7 @@ export function formatItemsFromSchema(
 }
 
 function formatSingleItem(
-  item: any,
+  item: unknown,
   index: number,
   formatMeta: FormatMetadata,
 ): void {
@@ -93,13 +94,21 @@ function applyStyle(value: string, style: string): string {
   }
 }
 
-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";
+    const itemObj = item as {
+      title?: string;
+      name?: string;
+      key?: string;
+      id?: string;
+      description?: string;
+    };
+    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();
   });