@zapier/zapier-sdk-cli 0.9.0 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk-cli",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Command line interface for Zapier SDK",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -42,9 +42,9 @@
     "ora": "^8.2.0",
     "pkce-challenge": "^5.0.0",
     "zod": "^3.25.67",
-    "@zapier/zapier-sdk": "0.9.0",
+    "@zapier/zapier-sdk": "0.10.0",
     "@zapier/zapier-sdk-cli-login": "0.3.2",
-    "@zapier/zapier-sdk-mcp": "0.3.5"
+    "@zapier/zapier-sdk-mcp": "0.3.7"
   },
   "devDependencies": {
     "@types/express": "^5.0.3",

package/src/plugins/add/index.ts

@@ -99,17 +99,13 @@ export const addPlugin: Plugin<
 
     // Process each app
     for (const app of apps) {
-      console.log(`📦 Adding ${app.key}...`);
+      const appSlugAndKey = app.slug ? `${app.slug} (${app.key})` : app.key;
+      console.log(`📦 Adding ${appSlugAndKey}...`);
 
       try {
-        // Extract implementation name and version from current_implementation_id
-        const currentImplementationId = app.current_implementation_id;
-        const [implementationName, version] =
-          currentImplementationId.split("@");
-
-        if (!implementationName || !version) {
+        if (!app.version) {
           console.warn(
-            `⚠️ Invalid implementation ID format for '${app.key}': ${currentImplementationId}. Expected format: <implementationName>@<version>. Skipping...`,
+            `⚠️ Invalid implementation ID format for '${appSlugAndKey}': ${app.implementation_id}. Expected format: <implementationName>@<version>. Skipping...`,
           );
           continue;
         }
@@ -118,14 +114,14 @@ export const addPlugin: Plugin<
         const [manifestKey] = await context.updateManifestEntry(
           app.key,
           {
-            implementationName,
-            version,
+            implementationName: app.key,
+            version: app.version,
           },
           configPath,
         );
 
         console.log(
-          `📝 Locked ${app.key} to ${implementationName}@${version} using key '${manifestKey}'`,
+          `📝 Locked ${appSlugAndKey} to ${app.key}@${app.version} using key '${manifestKey}'`,
         );
 
         // Find matching authentication for this app if authentications were provided
@@ -139,10 +135,12 @@ export const addPlugin: Plugin<
           if (matchingAuth) {
             authenticationId = matchingAuth.id;
             console.log(
-              `🔐 Using authentication ${authenticationId} (${matchingAuth.title}) for ${app.key}`,
+              `🔐 Using authentication ${authenticationId} (${matchingAuth.title}) for ${appSlugAndKey}`,
             );
           } else {
-            console.warn(`⚠️ No matching authentication found for ${app.key}`);
+            console.warn(
+              `⚠️ No matching authentication found for ${appSlugAndKey}`,
+            );
           }
         }
 
@@ -162,11 +160,13 @@ export const addPlugin: Plugin<
           await writeFile(typesPath, typeDefinitions, "utf8");
           console.log(`🔧 Generated types for ${manifestKey} at ${typesPath}`);
         } catch (error) {
-          console.warn(`⚠️ Failed to generate types for ${app.key}: ${error}`);
+          console.warn(
+            `⚠️ Failed to generate types for ${appSlugAndKey}: ${error}`,
+          );
           // Continue even if type generation fails
         }
       } catch (error) {
-        console.warn(`⚠️ Failed to process ${app.key}: ${error}`);
+        console.warn(`⚠️ Failed to process ${appSlugAndKey}: ${error}`);
       }
     }
 

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { hasResolver, isPositional } from "@zapier/zapier-sdk";
+import { isPositional, type FunctionRegistryEntry } from "@zapier/zapier-sdk";
 
 // ============================================================================
 // Types
@@ -20,14 +20,17 @@ export interface CliParameter {
 // Schema Analysis
 // ============================================================================
 
-export function analyzeZodSchema(schema: z.ZodSchema): CliParameter[] {
+export function analyzeZodSchema(
+  schema: z.ZodSchema,
+  functionInfo?: FunctionRegistryEntry,
+): CliParameter[] {
   const parameters: CliParameter[] = [];
 
   if (schema instanceof z.ZodObject) {
     const shape = schema.shape;
 
-    for (const [key, fieldSchema] of Object.entries(shape)) {
-      const param = analyzeZodField(key, fieldSchema as z.ZodSchema);
+    for (const [key, fieldSchema] of Object.entries<z.ZodSchema>(shape)) {
+      const param = analyzeZodField(key, fieldSchema, functionInfo);
       if (param) {
         parameters.push(param);
       }
@@ -40,6 +43,7 @@ export function analyzeZodSchema(schema: z.ZodSchema): CliParameter[] {
 function analyzeZodField(
   name: string,
   schema: z.ZodSchema,
+  functionInfo?: FunctionRegistryEntry,
 ): CliParameter | null {
   let baseSchema = schema;
   let required = true;
@@ -77,6 +81,14 @@ function analyzeZodField(
     paramType = "string";
   }
 
+  // Check if this parameter has a resolver
+  let paramHasResolver = false;
+
+  // Check function-specific resolvers first
+  if (functionInfo?.resolvers?.[name]) {
+    paramHasResolver = true;
+  }
+
   // Extract resolver metadata
   return {
     name,
@@ -85,7 +97,7 @@ function analyzeZodField(
     description: schema.description,
     default: defaultValue,
     choices,
-    hasResolver: hasResolver(name),
+    hasResolver: paramHasResolver,
     isPositional: isPositional(schema),
   };
 }

package/src/utils/cli-generator.ts

@@ -2,45 +2,16 @@ import type { Command } from "commander";
 import { z } from "zod";
 import type { ZapierSdk } from "@zapier/zapier-sdk";
 import {
-  hasResolver,
   isPositional,
   formatErrorMessage,
   ZapierError,
+  type FunctionRegistryEntry,
 } from "@zapier/zapier-sdk";
 import { SchemaParameterResolver } from "./parameter-resolver";
-import { formatItemsFromSchema } from "./schema-formatter";
+import { formatItemsFromSchema, formatJsonOutput } from "./schema-formatter";
 import chalk from "chalk";
-import util from "util";
 import inquirer from "inquirer";
 
-// ============================================================================
-// JSON Formatting
-// ============================================================================
-
-function formatJsonOutput(data: unknown): void {
-  // Don't print anything for undefined results (commands that just perform actions)
-  if (data === undefined) {
-    return;
-  }
-
-  // Show success message for action results
-  if (
-    data &&
-    typeof data === "object" &&
-    !Array.isArray(data) &&
-    ((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"));
-  }
-
-  // Use util.inspect for colored output
-  console.log(
-    util.inspect(data, { colors: true, depth: null, breakLength: 80 }),
-  );
-}
-
 // ============================================================================
 // Types
 // ============================================================================
@@ -66,7 +37,10 @@ interface CliParameter {
 // Schema Analysis
 // ============================================================================
 
-function analyzeZodSchema(schema: z.ZodSchema): CliParameter[] {
+function analyzeZodSchema(
+  schema: z.ZodSchema,
+  functionInfo?: FunctionRegistryEntry,
+): CliParameter[] {
   const parameters: CliParameter[] = [];
 
   // Handle ZodEffects (schemas with .refine(), .transform(), etc.)
@@ -78,14 +52,18 @@ function analyzeZodSchema(schema: z.ZodSchema): CliParameter[] {
     // Get the underlying schema
     const innerSchema = (schema as unknown as { _def: { schema: z.ZodSchema } })
       ._def.schema;
-    return analyzeZodSchema(innerSchema);
+    return analyzeZodSchema(innerSchema, functionInfo);
   }
 
   if (schema instanceof z.ZodObject) {
     const shape = schema.shape;
 
     for (const [key, fieldSchema] of Object.entries(shape)) {
-      const param = analyzeZodField(key, fieldSchema as z.ZodSchema);
+      const param = analyzeZodField(
+        key,
+        fieldSchema as z.ZodSchema,
+        functionInfo,
+      );
       if (param) {
         parameters.push(param);
       }
@@ -98,6 +76,7 @@ function analyzeZodSchema(schema: z.ZodSchema): CliParameter[] {
 function analyzeZodField(
   name: string,
   schema: z.ZodSchema,
+  functionInfo?: FunctionRegistryEntry,
 ): CliParameter | null {
   let baseSchema = schema;
   let required = true;
@@ -150,6 +129,14 @@ function analyzeZodField(
     paramType = "string";
   }
 
+  // Check if this parameter has a resolver
+  let paramHasResolver = false;
+
+  // Check function-specific resolvers first
+  if (functionInfo?.resolvers?.[name]) {
+    paramHasResolver = true;
+  }
+
   // Extract resolver metadata
   return {
     name,
@@ -158,7 +145,7 @@ function analyzeZodField(
     description: schema.description,
     default: defaultValue,
     choices,
-    hasResolver: hasResolver(name),
+    hasResolver: paramHasResolver,
     isPositional: isPositional(schema),
   };
 }
@@ -206,12 +193,7 @@ export function generateCliCommands(program: Command, sdk: ZapierSdk): void {
     // Convert methodName to kebab-case CLI command
     const cliCommandName = methodNameToCliCommand(fnInfo.name);
 
-    const config = createCommandConfig(
-      cliCommandName,
-      fnInfo.name,
-      fnInfo.inputSchema as z.ZodSchema,
-      sdk,
-    );
+    const config = createCommandConfig(cliCommandName, fnInfo, sdk);
 
     addCommand(program, cliCommandName, config);
   });
@@ -288,11 +270,11 @@ export function generateCliCommands(program: Command, sdk: ZapierSdk): void {
 
 function createCommandConfig(
   cliCommandName: string,
-  sdkMethodName: string,
-  schema: z.ZodSchema,
+  functionInfo: FunctionRegistryEntry,
   sdk: ZapierSdk,
 ): CliCommandConfig {
-  const parameters = analyzeZodSchema(schema);
+  const schema = functionInfo.inputSchema as z.ZodSchema;
+  const parameters = analyzeZodSchema(schema, functionInfo);
   const description = schema.description || `${cliCommandName} command`;
 
   const handler = async (...args: unknown[]) => {
@@ -304,7 +286,7 @@ function createCommandConfig(
       const options = commandObj.opts();
 
       // Check if this is a list command for pagination
-      const isListCommand = cliCommandName.startsWith("list-");
+      const isListCommand = functionInfo.type === "list";
       const hasPaginationParams = parameters.some(
         (p) => p.name === "maxItems" || p.name === "pageSize",
       );
@@ -325,6 +307,7 @@ function createCommandConfig(
         schema,
         rawParams,
         sdk,
+        functionInfo.name,
       );
 
       // Handle paginated list commands with async iteration
@@ -339,11 +322,11 @@ function createCommandConfig(
           string,
           (params: unknown) => Promise<unknown> & AsyncIterable<unknown>
         >;
-        const sdkIterator = sdkObj[sdkMethodName](resolvedParams);
+        const sdkIterator = sdkObj[functionInfo.name](resolvedParams);
         await handlePaginatedListWithAsyncIteration(
-          sdkMethodName,
+          functionInfo.name,
           sdkIterator,
-          schema,
+          functionInfo,
         );
       } else {
         // Special handling for commands that write to files
@@ -354,7 +337,7 @@ function createCommandConfig(
             string,
             (params: unknown) => Promise<unknown>
           >;
-          await sdkObj[sdkMethodName](resolvedParams);
+          await sdkObj[functionInfo.name](resolvedParams);
           console.log(
             chalk.green(`✅ ${cliCommandName} completed successfully!`),
           );
@@ -367,7 +350,7 @@ function createCommandConfig(
           string,
           (params: unknown) => Promise<unknown>
         >;
-        const result: unknown = await sdkObj[sdkMethodName](resolvedParams);
+        const result: unknown = await sdkObj[functionInfo.name](resolvedParams);
         const items = (result as { data?: unknown })?.data
           ? (result as { data: unknown }).data
           : result;
@@ -380,8 +363,7 @@ function createCommandConfig(
             (resolvedParams as { maxItems?: number }).maxItems,
             hasUserSpecifiedMaxItems,
             shouldUseJson as boolean,
-            schema,
-            sdkMethodName,
+            functionInfo,
           );
         } else {
           formatJsonOutput(items);
@@ -554,6 +536,11 @@ function convertCliArgsToSdkParams(
 }
 
 function convertValue(value: unknown, type: CliParameter["type"]): unknown {
+  // Don't convert undefined values - let the resolver system handle them
+  if (value === undefined) {
+    return undefined;
+  }
+
   switch (type) {
     case "number":
       return Number(value);
@@ -585,13 +572,15 @@ function convertValue(value: unknown, type: CliParameter["type"]): unknown {
 async function handlePaginatedListWithAsyncIteration(
   sdkMethodName: string,
   sdkResult: unknown,
-  schema: z.ZodSchema,
+  functionInfo: FunctionRegistryEntry,
 ): Promise<void> {
-  const itemName = getItemNameFromMethod(sdkMethodName);
+  const itemName = getItemNameFromMethod(functionInfo);
   let totalShown = 0;
   let pageCount = 0;
 
-  console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName)}\n`));
+  console.log(
+    chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName, functionInfo)}\n`),
+  );
 
   try {
     // Use async iteration to go through pages
@@ -620,13 +609,15 @@ async function handlePaginatedListWithAsyncIteration(
       if (pageCount > 1) {
         console.clear();
         console.log(
-          chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName)}\n`),
+          chalk.blue(
+            `📋 ${getListTitleFromMethod(sdkMethodName, functionInfo)}\n`,
+          ),
         );
       }
 
-      // Format and display items using schema
-      if (schema) {
-        formatItemsFromSchema(schema as z.ZodType, items, totalShown);
+      // Format and display items using function info
+      if (functionInfo) {
+        formatItemsFromSchema(functionInfo, items, totalShown);
       } else {
         formatItemsGeneric(items, totalShown);
       }
@@ -668,8 +659,8 @@ async function handlePaginatedListWithAsyncIteration(
         return;
       }
 
-      if (schema) {
-        formatItemsFromSchema(schema as z.ZodType, items, 0);
+      if (functionInfo) {
+        formatItemsFromSchema(functionInfo, items, 0);
       } else {
         formatItemsGeneric(items, 0);
       }
@@ -686,8 +677,7 @@ function formatNonPaginatedResults(
   requestedMaxItems?: number,
   userSpecifiedMaxItems?: boolean,
   useRawJson?: boolean,
-  schema?: z.ZodSchema,
-  methodName?: string,
+  functionInfo?: FunctionRegistryEntry,
 ): void {
   if (!Array.isArray(result)) {
     if (useRawJson) {
@@ -703,7 +693,7 @@ function formatNonPaginatedResults(
     return;
   }
 
-  const itemName = methodName ? getItemNameFromMethod(methodName) : "items";
+  const itemName = functionInfo ? getItemNameFromMethod(functionInfo) : "items";
 
   if (result.length === 0) {
     console.log(chalk.yellow(`No ${itemName} found.`));
@@ -712,9 +702,9 @@ function formatNonPaginatedResults(
 
   console.log(chalk.green(`\n✅ Found ${result.length} ${itemName}:\n`));
 
-  // Use schema for formatting
-  if (schema) {
-    formatItemsFromSchema(schema as z.ZodType, result);
+  // Use function info for formatting
+  if (functionInfo) {
+    formatItemsFromSchema(functionInfo, result);
   } else {
     // Fallback to generic formatting
     formatItemsGeneric(result);
@@ -751,22 +741,21 @@ function formatItemsGeneric(
 }
 
 // Generic helper functions that infer from schema description or method name
-function getItemNameFromMethod(methodName: string): string {
-  // Extract from method name: listApps -> apps, listActions -> actions
-  const listMatch = methodName.match(/^list(.+)$/);
-  if (listMatch) {
-    return listMatch[1].toLowerCase();
+function getItemNameFromMethod(functionInfo: FunctionRegistryEntry): string {
+  if (functionInfo.itemType) {
+    return `${functionInfo.itemType} items`;
   }
 
-  // Fallback to generic
   return "items";
 }
 
-function getListTitleFromMethod(methodName: string): string {
-  const itemName = getItemNameFromMethod(methodName);
-  if (itemName === "items") return "Available Items";
+function getListTitleFromMethod(
+  methodName: string,
+  functionInfo: FunctionRegistryEntry,
+): string {
+  if (functionInfo.itemType) {
+    return `Available ${functionInfo.itemType} items`;
+  }
 
-  // Capitalize first letter: apps -> Apps
-  const capitalized = itemName.charAt(0).toUpperCase() + itemName.slice(1);
-  return `Available ${capitalized}`;
+  return `${methodName} items`;
 }