@zapier/zapier-sdk-cli 0.15.14 → 0.16.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk-cli",
-  "version": "0.15.14",
+  "version": "0.16.1",
   "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-cli-login": "0.3.5",
-    "@zapier/zapier-sdk": "0.15.13"
+    "@zapier/zapier-sdk-mcp": "0.4.0",
+    "@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.test.ts

@@ -119,6 +119,158 @@ const mockSdk = {
   listApps: vi.fn().mockResolvedValue({ data: [] }),
 } as unknown as ZapierSdk;
 
+// Schema for request command testing
+const requestSchema = z
+  .object({
+    url: z.string().describe("The URL to request"),
+    method: z.string().optional().describe("HTTP method"),
+    authenticationId: z.number().optional(),
+  })
+  .describe("Make authenticated HTTP requests");
+
+describe("CLI Response Body Handling", () => {
+  let consoleSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+  });
+
+  it("should wrap Response objects in structured envelope with statusCode, headers, body", async () => {
+    const bodyData = { ok: true, users: [{ id: 1, name: "Test User" }] };
+
+    // Create a mock Response object
+    const mockResponse = new Response(JSON.stringify(bodyData), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+
+    const mockSdkWithRequest = {
+      getRegistry: vi.fn(() => ({
+        functions: [
+          {
+            name: "request",
+            type: "single",
+            inputSchema: requestSchema,
+          },
+        ],
+        categories: [],
+      })),
+      request: vi.fn().mockResolvedValue(mockResponse),
+    } as unknown as ZapierSdk;
+
+    const program = new Command();
+    program.exitOverride();
+
+    generateCliCommands(program, mockSdkWithRequest);
+
+    await program.parseAsync([
+      "node",
+      "test",
+      "request",
+      "https://api.example.com/users",
+      "--json",
+    ]);
+
+    // Verify the SDK method was called
+    expect(mockSdkWithRequest.request).toHaveBeenCalled();
+
+    // Verify output includes the structured envelope with statusCode, headers, and body
+    const expectedEnvelope = {
+      statusCode: 200,
+      headers: { "content-type": "application/json" },
+      body: bodyData,
+    };
+    expect(consoleSpy).toHaveBeenCalledWith(
+      JSON.stringify(expectedEnvelope, null, 2),
+    );
+  });
+
+  it("should handle invalid JSON in Response with helpful error", async () => {
+    // Create a mock Response with invalid JSON
+    const mockResponse = new Response("not valid json {", {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+
+    const mockSdkWithBadResponse = {
+      getRegistry: vi.fn(() => ({
+        functions: [
+          {
+            name: "request",
+            type: "single",
+            inputSchema: requestSchema,
+          },
+        ],
+        categories: [],
+      })),
+      request: vi.fn().mockResolvedValue(mockResponse),
+    } as unknown as ZapierSdk;
+
+    const program = new Command();
+    program.exitOverride();
+    const consoleErrorSpy = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+
+    generateCliCommands(program, mockSdkWithBadResponse);
+
+    try {
+      await program.parseAsync([
+        "node",
+        "test",
+        "request",
+        "https://api.example.com/users",
+        "--json",
+      ]);
+    } catch {
+      // Expected to throw
+    }
+
+    // Verify error message includes helpful context
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining("❌"),
+      expect.stringContaining("Failed to parse response as JSON"),
+    );
+
+    consoleErrorSpy.mockRestore();
+  });
+
+  it("should handle non-Response objects normally", async () => {
+    const regularData = { apps: [{ id: 1, name: "Test App" }] };
+
+    const mockSdkRegular = {
+      getRegistry: vi.fn(() => ({
+        functions: [
+          {
+            name: "getApp",
+            type: "single",
+            inputSchema: z.object({ appKey: z.string() }).describe("Get app"),
+          },
+        ],
+        categories: [],
+      })),
+      getApp: vi.fn().mockResolvedValue(regularData),
+    } as unknown as ZapierSdk;
+
+    const program = new Command();
+    program.exitOverride();
+
+    generateCliCommands(program, mockSdkRegular);
+
+    await program.parseAsync(["node", "test", "get-app", "test-app", "--json"]);
+
+    expect(mockSdkRegular.getApp).toHaveBeenCalled();
+    expect(consoleSpy).toHaveBeenCalledWith(
+      JSON.stringify(regularData, null, 2),
+    );
+  });
+});
+
 describe("CLI Command Generation", () => {
   beforeEach(() => {
     vi.clearAllMocks();

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";
@@ -351,7 +350,30 @@ function createCommandConfig(
           string,
           (params: unknown) => Promise<unknown>
         >;
-        const result: unknown = await sdkObj[functionInfo.name](resolvedParams);
+        let result: unknown = await sdkObj[functionInfo.name](resolvedParams);
+
+        // Handle Response objects by wrapping in a structured envelope
+        if (result instanceof Response) {
+          const response = result;
+          let body: unknown;
+          try {
+            body = await response.json();
+          } catch {
+            // If JSON parsing fails, try to get text for error context
+            const text = response.bodyUsed
+              ? "[body already consumed]"
+              : await response.text().catch(() => "[unable to read body]");
+            throw new Error(
+              `Failed to parse response as JSON (status: ${response.status}). Body: ${text.slice(0, 200)}`,
+            );
+          }
+          result = {
+            statusCode: response.status,
+            headers: Object.fromEntries(response.headers.entries()),
+            body,
+          };
+        }
+
         const items = (result as { data?: unknown })?.data
           ? (result as { data: unknown }).data
           : result;

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;
 }
 
 // ============================================================================