@zapier/zapier-sdk-cli 0.15.14 → 0.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk-cli",
-  "version": "0.15.14",
+  "version": "0.16.0",
   "description": "Command line interface for Zapier SDK",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -46,10 +46,10 @@
     "pkce-challenge": "^5.0.0",
     "semver": "^7.7.3",
     "typescript": "^5.8.3",
-    "zod": "^3.25.67",
-    "@zapier/zapier-sdk-mcp": "0.3.39",
+    "zod": "4.2.1",
+    "@zapier/zapier-sdk-mcp": "0.4.0",
     "@zapier/zapier-sdk-cli-login": "0.3.5",
-    "@zapier/zapier-sdk": "0.15.13"
+    "@zapier/zapier-sdk": "0.16.0"
   },
   "devDependencies": {
     "@types/express": "^5.0.3",

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

@@ -52,13 +52,13 @@ function analyzeZodField(
   // Unwrap optional and default wrappers
   if (baseSchema instanceof z.ZodOptional) {
     required = false;
-    baseSchema = baseSchema._def.innerType;
+    baseSchema = baseSchema._zod.def.innerType as z.ZodSchema;
   }
 
   if (baseSchema instanceof z.ZodDefault) {
     required = false;
-    defaultValue = baseSchema._def.defaultValue();
-    baseSchema = baseSchema._def.innerType;
+    defaultValue = (baseSchema._zod.def.defaultValue as () => unknown)();
+    baseSchema = baseSchema._zod.def.innerType as z.ZodSchema;
   }
 
   // Determine parameter type
@@ -75,7 +75,7 @@ function analyzeZodField(
     paramType = "array";
   } else if (baseSchema instanceof z.ZodEnum) {
     paramType = "string";
-    choices = baseSchema._def.values;
+    choices = baseSchema.options as string[];
   } else if (baseSchema instanceof z.ZodRecord) {
     // Handle Record<string, any> as JSON string input
     paramType = "string";

package/src/utils/cli-generator.ts

@@ -45,15 +45,14 @@ function analyzeZodSchema(
   const parameters: CliParameter[] = [];
 
   // Handle ZodEffects (schemas with .refine(), .transform(), etc.)
-  if (
-    (schema as unknown as { _def?: { typeName?: string } })._def &&
-    (schema as unknown as { _def: { typeName: string } })._def.typeName ===
-      "ZodEffects"
-  ) {
-    // Get the underlying schema
-    const innerSchema = (schema as unknown as { _def: { schema: z.ZodSchema } })
-      ._def.schema;
-    return analyzeZodSchema(innerSchema, functionInfo);
+  // In Zod, effects have type "effect" and inner schema is accessed via innerType
+  const schemaDef = (
+    schema as unknown as {
+      _zod?: { def?: { type?: string; innerType?: z.ZodSchema } };
+    }
+  )._zod?.def;
+  if (schemaDef?.type === "effect" && schemaDef.innerType) {
+    return analyzeZodSchema(schemaDef.innerType, functionInfo);
   }
 
   if (schema instanceof z.ZodObject) {
@@ -87,26 +86,26 @@ function analyzeZodField(
   while (true) {
     if (baseSchema instanceof z.ZodOptional) {
       required = false;
-      baseSchema = baseSchema._def.innerType;
+      baseSchema = baseSchema._zod.def.innerType as z.ZodSchema;
     } else if (baseSchema instanceof z.ZodDefault) {
       required = false;
-      defaultValue = baseSchema._def.defaultValue();
-      baseSchema = baseSchema._def.innerType;
-    } else if (
-      (
+      defaultValue = (baseSchema._zod.def.defaultValue as () => unknown)();
+      baseSchema = baseSchema._zod.def.innerType as z.ZodSchema;
+    } else {
+      // Check for ZodNullable - nullable doesn't affect CLI required status, but we need to unwrap it to get the base type
+      const zodDef = (
         baseSchema as unknown as {
-          _def?: { typeName?: string; innerType?: z.ZodSchema };
+          _zod?: { def?: { typeName?: string; innerType?: z.ZodSchema } };
         }
-      )._def &&
-      (baseSchema as unknown as { _def: { typeName: string } })._def
-        .typeName === "ZodNullable"
-    ) {
-      // nullable doesn't affect CLI required status, but we need to unwrap it to get the base type
-      baseSchema = (
-        baseSchema as unknown as { _def: { innerType: z.ZodSchema } }
-      )._def.innerType;
-    } else {
-      break; // No more wrappers to unwrap
+      )._zod?.def;
+
+      if (zodDef?.typeName === "ZodNullable" && zodDef.innerType) {
+        baseSchema = zodDef.innerType;
+        continue;
+      }
+
+      // No more wrappers to unwrap
+      break;
     }
   }
 
@@ -124,7 +123,7 @@ function analyzeZodField(
     paramType = "array";
   } else if (baseSchema instanceof z.ZodEnum) {
     paramType = "string";
-    choices = baseSchema._def.values;
+    choices = baseSchema.options as string[];
   } else if (baseSchema instanceof z.ZodRecord) {
     // Handle Record<string, any> as JSON string input
     paramType = "string";

package/src/utils/parameter-resolver.ts

@@ -364,12 +364,12 @@ export class SchemaParameterResolver {
     // Check if field is optional or has default
     if (baseSchema instanceof z.ZodOptional) {
       isRequired = false;
-      baseSchema = baseSchema._def.innerType;
+      baseSchema = baseSchema._zod.def.innerType as z.ZodSchema;
     }
 
     if (baseSchema instanceof z.ZodDefault) {
       isRequired = false;
-      baseSchema = baseSchema._def.innerType;
+      baseSchema = baseSchema._zod.def.innerType as z.ZodSchema;
     }
 
     return this.createResolvableParameter([fieldName], baseSchema, isRequired);

package/src/utils/schema-formatter.ts

@@ -6,12 +6,13 @@ import type { FormattedItem, FormatMetadata } from "@zapier/zapier-sdk";
 // TODO: Consider exposing these utilities or implementing proper CLI formatting
 
 function getFormatMetadata(schema: unknown): FormatMetadata | undefined {
-  return (schema as { _def?: { formatMeta?: FormatMetadata } })?._def
-    ?.formatMeta;
+  return (schema as { _zod?: { def?: { formatMeta?: FormatMetadata } } })?._zod
+    ?.def?.formatMeta;
 }
 
 function getOutputSchema(schema: unknown): unknown {
-  return (schema as { _def?: { outputSchema?: unknown } })?._def?.outputSchema;
+  return (schema as { _zod?: { def?: { outputSchema?: unknown } } })?._zod?.def
+    ?.outputSchema;
 }
 
 // ============================================================================