@zapier/zapier-sdk-cli 0.16.0 → 0.16.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk-cli",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "description": "Command line interface for Zapier SDK",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -47,8 +47,8 @@
     "semver": "^7.7.3",
     "typescript": "^5.8.3",
     "zod": "4.2.1",
-    "@zapier/zapier-sdk-mcp": "0.4.0",
     "@zapier/zapier-sdk-cli-login": "0.3.5",
+    "@zapier/zapier-sdk-mcp": "0.4.0",
     "@zapier/zapier-sdk": "0.16.0"
   },
   "devDependencies": {

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

@@ -350,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;