@zapier/zapier-sdk-cli 0.13.9 → 0.13.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk-cli",
-  "version": "0.13.9",
+  "version": "0.13.10",
   "description": "Command line interface for Zapier SDK",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -44,8 +44,8 @@
     "typescript": "^5.8.3",
     "zod": "^3.25.67",
     "@zapier/zapier-sdk": "0.13.7",
-    "@zapier/zapier-sdk-mcp": "0.3.20",
-    "@zapier/zapier-sdk-cli-login": "0.3.3"
+    "@zapier/zapier-sdk-cli-login": "0.3.3",
+    "@zapier/zapier-sdk-mcp": "0.3.20"
   },
   "devDependencies": {
     "@types/express": "^5.0.3",

package/src/plugins/add/index.ts

@@ -161,15 +161,6 @@ export const addPlugin: Plugin<
     if (successfulApps.length > 0) {
       console.log(`✅ Added ${successfulApps.length} app(s) to manifest`);
     }
-
-    // Report any errors
-    const allErrors = [...manifestResult.errors, ...typesResult.errors];
-    if (allErrors.length > 0) {
-      console.warn(`\n⚠️ ${allErrors.length} error(s) occurred:`);
-      allErrors.forEach(({ appKey, error }) => {
-        console.warn(`  - ${appKey}: ${error}`);
-      });
-    }
   }, AddSchema);
 
   return {

package/src/plugins/buildManifest/index.test.ts

@@ -7,7 +7,11 @@ import type {
   ManifestEntry,
   UpdateManifestEntryOptions,
 } from "@zapier/zapier-sdk";
-import { createSdk } from "@zapier/zapier-sdk";
+import {
+  createSdk,
+  ZapierUnknownError,
+  ZapierValidationError,
+} from "@zapier/zapier-sdk";
 
 const mockSlackApp: AppItem = {
   key: "SlackCLIAPI",
@@ -170,7 +174,6 @@ describe("buildManifest plugin", () => {
       // Should return manifest with entries
       expect(result.manifest).toBeDefined();
       expect(result.manifest?.apps).toBeDefined();
-      expect(result.errors).toEqual([]);
     });
 
     it("should process apps and create manifest entries", async () => {
@@ -182,7 +185,6 @@ describe("buildManifest plugin", () => {
       });
 
       expect(result.manifest?.apps).toBeDefined();
-      expect(result.errors).toEqual([]);
     });
 
     it("should return empty result when no apps found", async () => {
@@ -194,7 +196,6 @@ describe("buildManifest plugin", () => {
       });
 
       expect(result.manifest).toBeUndefined();
-      expect(result.errors).toEqual([]);
     });
   });
 
@@ -252,7 +253,6 @@ describe("buildManifest plugin", () => {
         implementationName: "GmailCLIAPI",
         version: "2.5.0",
       });
-      expect(result.errors).toEqual([]);
     });
 
     it("should accumulate manifest entries across multiple apps", async () => {
@@ -426,85 +426,129 @@ describe("buildManifest plugin", () => {
   });
 
   describe("error handling", () => {
-    it("should handle apps without version", async () => {
+    it("should throw ZapierUnknownError when createManifestEntry fails", async () => {
       const sdk = createTestSdk([mockAppWithoutVersion]);
 
-      const result = await sdk.buildManifest({
-        appKeys: ["broken"],
-        skipWrite: true,
-      });
+      await expect(
+        sdk.buildManifest({
+          appKeys: ["broken"],
+          skipWrite: true,
+        }),
+      ).rejects.toThrow(ZapierUnknownError);
+    });
 
-      expect(result.errors).toHaveLength(1);
-      expect(result.errors[0]).toEqual({
-        appKey: "BrokenAPI",
-        error: expect.stringContaining("Failed to process app"),
-      });
+    it("should include app key in error message when processing fails", async () => {
+      const sdk = createTestSdk([mockAppWithoutVersion]);
+
+      await expect(
+        sdk.buildManifest({
+          appKeys: ["broken"],
+          skipWrite: true,
+        }),
+      ).rejects.toThrow(/Failed to process app BrokenAPI/);
     });
 
-    it("should emit app_processing_error event on failure", async () => {
+    it("should emit app_processing_error event before throwing", async () => {
       const sdk = createTestSdk([mockAppWithoutVersion]);
       const onProgress = vi.fn();
 
-      await sdk.buildManifest({
-        appKeys: ["broken"],
-        skipWrite: true,
-        onProgress,
-      });
+      await expect(
+        sdk.buildManifest({
+          appKeys: ["broken"],
+          skipWrite: true,
+          onProgress,
+        }),
+      ).rejects.toThrow();
 
       expect(onProgress).toHaveBeenCalledWith({
         type: "app_processing_error",
         appKey: "BrokenAPI",
-        error: expect.stringContaining("Failed to process app"),
+        error: expect.stringContaining("Failed to process app BrokenAPI"),
       });
     });
 
-    it("should continue processing other apps after error", async () => {
+    it("should throw immediately on first error and not continue processing", async () => {
       const sdk = createTestSdk([mockAppWithoutVersion, mockSlackApp]);
 
-      const result = await sdk.buildManifest({
-        appKeys: ["broken", "slack"],
-        skipWrite: true,
-      });
-
-      // Should have one error
-      expect(result.errors).toHaveLength(1);
-      expect(result.errors[0].appKey).toBe("BrokenAPI");
+      await expect(
+        sdk.buildManifest({
+          appKeys: ["broken", "slack"],
+          skipWrite: true,
+        }),
+      ).rejects.toThrow(ZapierUnknownError);
 
-      // Should still process successful app
-      expect(result.manifest?.apps?.SlackCLIAPI).toBeDefined();
+      // updateManifestEntry should not be called since first app failed
+      expect(mockUpdateManifestEntry).not.toHaveBeenCalled();
     });
 
-    it("should handle updateManifestEntry failure", async () => {
+    it("should throw ZapierUnknownError when updateManifestEntry fails", async () => {
       mockUpdateManifestEntry.mockRejectedValueOnce(new Error("Write failed"));
       const sdk = createTestSdk();
 
-      const result = await sdk.buildManifest({
-        appKeys: ["slack"],
-        skipWrite: false,
-      });
+      await expect(
+        sdk.buildManifest({
+          appKeys: ["slack"],
+          skipWrite: false,
+        }),
+      ).rejects.toThrow(ZapierUnknownError);
+    });
 
-      expect(result.errors).toHaveLength(1);
-      expect(result.errors[0]).toEqual({
-        appKey: "SlackCLIAPI",
-        error: "Failed to process app: Error: Write failed",
-      });
+    it("should include original error as cause", async () => {
+      const originalError = new Error("Write failed");
+      mockUpdateManifestEntry.mockRejectedValueOnce(originalError);
+      const sdk = createTestSdk();
+
+      try {
+        await sdk.buildManifest({
+          appKeys: ["slack"],
+          skipWrite: false,
+        });
+        expect.fail("Should have thrown");
+      } catch (error) {
+        expect(error).toBeInstanceOf(ZapierUnknownError);
+        if (error instanceof ZapierUnknownError) {
+          expect(error.cause).toBe(originalError);
+          expect(error.message).toContain("Failed to process app SlackCLIAPI");
+          expect(error.message).toContain("Write failed");
+        }
+      }
+    });
+
+    it("should preserve ZapierValidationError if thrown from underlying code", async () => {
+      const validationError = new ZapierValidationError(
+        "Invalid manifest entry",
+      );
+      mockUpdateManifestEntry.mockRejectedValueOnce(validationError);
+      const sdk = createTestSdk();
+
+      await expect(
+        sdk.buildManifest({
+          appKeys: ["slack"],
+          skipWrite: false,
+        }),
+      ).rejects.toThrow(ZapierValidationError);
     });
 
-    it("should accumulate multiple errors", async () => {
+    it("should stop processing after first app error", async () => {
       mockUpdateManifestEntry
         .mockRejectedValueOnce(new Error("First error"))
-        .mockRejectedValueOnce(new Error("Second error"));
+        .mockResolvedValueOnce([
+          "GmailCLIAPI",
+          { implementationName: "GmailCLIAPI", version: "2.5.0" },
+          { apps: {} },
+        ]);
 
       const sdk = createTestSdk();
 
-      const result = await sdk.buildManifest({
-        appKeys: ["slack", "gmail"],
-        skipWrite: false,
-      });
+      await expect(
+        sdk.buildManifest({
+          appKeys: ["slack", "gmail"],
+          skipWrite: false,
+        }),
+      ).rejects.toThrow(ZapierUnknownError);
 
-      expect(result.errors).toHaveLength(2);
-      expect(result.errors[0].appKey).toBe("SlackCLIAPI");
-      expect(result.errors[1].appKey).toBe("GmailCLIAPI");
+      // Should only call once (for first app that fails)
+      expect(mockUpdateManifestEntry).toHaveBeenCalledTimes(1);
     });
   });
 
@@ -574,7 +618,6 @@ describe("buildManifest plugin", () => {
       });
 
       expect(result.manifest).toBeUndefined();
-      expect(result.errors).toEqual([]);
     });
 
     it("should not call updateManifestEntry when no apps found", async () => {

package/src/plugins/buildManifest/index.ts

@@ -7,7 +7,11 @@ import type {
   AppItem,
   Manifest,
 } from "@zapier/zapier-sdk";
-import { createFunction } from "@zapier/zapier-sdk";
+import {
+  createFunction,
+  ZapierValidationError,
+  ZapierUnknownError,
+} from "@zapier/zapier-sdk";
 import {
   BuildManifestSchema,
   type BuildManifestOptions,
@@ -38,10 +42,6 @@ export const buildManifestPlugin: Plugin<
   ): Promise<BuildManifestResult> {
     const { appKeys, skipWrite = false, configPath, onProgress } = options;
 
-    const result: BuildManifestResult = {
-      errors: [],
-    };
-
     // Get apps using listApps (which respects existing manifest for version locking)
     onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
     const appsIterator = sdk.listApps({ appKeys }).items();
@@ -53,7 +53,7 @@ export const buildManifestPlugin: Plugin<
     onProgress?.({ type: "apps_lookup_complete", count: apps.length });
 
     if (apps.length === 0) {
-      return result;
+      return {};
     }
 
     let updatedManifest: Manifest | undefined;
@@ -96,22 +96,25 @@ export const buildManifestPlugin: Plugin<
 
         onProgress?.({ type: "app_processing_complete", appKey: app.key });
       } catch (error) {
-        const errorMessage = `Failed to process app: ${error}`;
-        result.errors.push({
-          appKey: app.key,
-          error: errorMessage,
-        });
+        const errorMessage = `Failed to process app ${app.key}: ${error instanceof Error ? error.message : String(error)}`;
+
         onProgress?.({
           type: "app_processing_error",
           appKey: app.key,
           error: errorMessage,
         });
+
+        if (error instanceof ZapierValidationError) {
+          throw error; // Preserve the specific error type
+        } else {
+          throw new ZapierUnknownError(errorMessage, {
+            cause: error, // Works for both Error and non-Error
+          });
+        }
       }
     }
 
-    result.manifest = updatedManifest;
-
-    return result;
+    return { manifest: updatedManifest };
   }, BuildManifestSchema);
 
   return {

package/src/plugins/buildManifest/schemas.ts

@@ -52,8 +52,4 @@ export type ManifestBuildProgressEvent =
 
 export interface BuildManifestResult {
   manifest?: Manifest;
-  errors: Array<{
-    appKey: string;
-    error: string;
-  }>;
 }