@zapier/zapier-sdk-cli 0.13.9 → 0.13.11

package/dist/index.mjs

@@ -1,9 +1,9 @@
-import { createFunction, OutputPropertySchema, DEFAULT_CONFIG_PATH, getOsInfo, getPlatformVersions, getCiPlatform, isCi, createZapierSdkWithoutRegistry, registryPlugin, getReleaseId, getCurrentTimestamp, generateEventId, toSnakeCase } from '@zapier/zapier-sdk';
+import { createFunction, OutputPropertySchema, DEFAULT_CONFIG_PATH, getOsInfo, getPlatformVersions, getCiPlatform, isCi, createZapierSdkWithoutRegistry, registryPlugin, getReleaseId, getCurrentTimestamp, generateEventId, ZapierValidationError, ZapierUnknownError, toSnakeCase } from '@zapier/zapier-sdk';
 import open from 'open';
 import crypto from 'crypto';
 import express from 'express';
 import pkceChallenge from 'pkce-challenge';
-import { getLoggedInUser, logout, ZAPIER_BASE, LOGIN_CLIENT_ID, AUTH_MODE_HEADER, updateLogin, getConfigPath } from '@zapier/zapier-sdk-cli-login';
+import { getLoggedInUser, logout, getAuthTokenUrl, getAuthAuthorizeUrl, ZAPIER_AUTH_CLIENT_ID, AUTH_MODE_HEADER, updateLogin, getConfigPath } from '@zapier/zapier-sdk-cli-login';
 import ora from 'ora';
 import chalk from 'chalk';
 import { z } from 'zod';
@@ -11,7 +11,7 @@ import { startMcpServerAsProcess } from '@zapier/zapier-sdk-mcp';
 import { buildSync } from 'esbuild';
 import * as fs from 'fs';
 import * as path from 'path';
-import { join, resolve } from 'path';
+import { resolve, join } from 'path';
 import { mkdir, writeFile, access } from 'fs/promises';
 import * as ts from 'typescript';
 
@@ -76,28 +76,28 @@ var client_default = api;
 
 // src/utils/getCallablePromise.ts
 var getCallablePromise = () => {
-  let resolve3 = () => {
+  let resolve4 = () => {
   };
   let reject = () => {
   };
   const promise = new Promise((_resolve, _reject) => {
-    resolve3 = _resolve;
+    resolve4 = _resolve;
     reject = _reject;
   });
   return {
     promise,
-    resolve: resolve3,
+    resolve: resolve4,
     reject
   };
 };
 var getCallablePromise_default = getCallablePromise;
 var findAvailablePort = () => {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     let portIndex = 0;
     const tryPort = (port) => {
       const server = express().listen(port, () => {
         server.close();
-        resolve3(port);
+        resolve4(port);
       });
       server.on("error", (err) => {
         if (err.code === "EADDRINUSE") {
@@ -130,7 +130,15 @@ var generateRandomString = () => {
     (dec) => ("0" + dec.toString(16)).substring(-2)
   ).join("");
 };
-var login = async (timeoutMs = LOGIN_TIMEOUT_MS) => {
+var login = async ({
+  timeoutMs = LOGIN_TIMEOUT_MS,
+  baseUrl,
+  authBaseUrl,
+  authClientId
+}) => {
+  const authOptions = { baseUrl, authBaseUrl };
+  const tokenUrl = getAuthTokenUrl(authOptions);
+  const authorizeUrl = getAuthAuthorizeUrl(authOptions);
   logout();
   const availablePort = await findAvailablePort();
   const redirectUri = `http://localhost:${availablePort}/oauth`;
@@ -156,9 +164,9 @@ var login = async (timeoutMs = LOGIN_TIMEOUT_MS) => {
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
   const { code_verifier: codeVerifier, code_challenge: codeChallenge } = await pkceChallenge();
-  const authUrl = `${ZAPIER_BASE}/oauth/authorize/?${new URLSearchParams({
+  const authUrl = `${authorizeUrl}?${new URLSearchParams({
     response_type: "code",
-    client_id: LOGIN_CLIENT_ID,
+    client_id: authClientId || ZAPIER_AUTH_CLIENT_ID,
     redirect_uri: redirectUri,
     scope: "internal offline_access",
     state: generateRandomString(),
@@ -187,26 +195,26 @@ var login = async (timeoutMs = LOGIN_TIMEOUT_MS) => {
   } finally {
     process.off("SIGINT", cleanup);
     process.off("SIGTERM", cleanup);
-    await new Promise((resolve3) => {
+    await new Promise((resolve4) => {
       const timeout = setTimeout(() => {
         log_default.info("Server close timed out, forcing connection shutdown...");
         connections.forEach((conn) => conn.destroy());
-        resolve3();
+        resolve4();
       }, 1e3);
       server.close(() => {
         clearTimeout(timeout);
-        resolve3();
+        resolve4();
       });
     });
   }
   log_default.info("Exchanging authorization code for tokens...");
   const { data } = await client_default.post(
-    `${ZAPIER_BASE}/oauth/token/`,
+    tokenUrl,
     {
       grant_type: "authorization_code",
       code: await promisedCode,
       redirect_uri: redirectUri,
-      client_id: LOGIN_CLIENT_ID,
+      client_id: authClientId || ZAPIER_AUTH_CLIENT_ID,
       code_verifier: codeVerifier
     },
     {
@@ -227,7 +235,7 @@ var LoginSchema = z.object({
 
 // package.json
 var package_default = {
-  version: "0.13.9"};
+  version: "0.13.11"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {
@@ -285,23 +293,35 @@ function buildCliCommandExecutedEvent({
 
 // src/plugins/login/index.ts
 var CLI_COMMAND_EXECUTED_EVENT_SUBJECT = "platform.sdk.CliCommandExecutedEvent";
-var loginWithSdk = createFunction(async function loginWithSdk2(options) {
-  const timeoutSeconds = options.timeout ? parseInt(options.timeout, 10) : 300;
-  if (isNaN(timeoutSeconds) || timeoutSeconds <= 0) {
-    throw new Error("Timeout must be a positive number");
+var loginWithSdk = createFunction(
+  async (options) => {
+    const timeoutSeconds = options.timeout ? parseInt(options.timeout, 10) : 300;
+    if (isNaN(timeoutSeconds) || timeoutSeconds <= 0) {
+      throw new Error("Timeout must be a positive number");
+    }
+    await login_default({
+      timeoutMs: timeoutSeconds * 1e3,
+      baseUrl: options.baseUrl,
+      authBaseUrl: options.authBaseUrl,
+      authClientId: options.authClientId
+    });
+    const user = await getLoggedInUser();
+    console.log(`\u2705 Successfully logged in as ${user.email}`);
+    setTimeout(() => process.exit(0), 100);
   }
-  await login_default(timeoutSeconds * 1e3);
-  const user = await getLoggedInUser();
-  console.log(`\u2705 Successfully logged in as ${user.email}`);
-  setTimeout(() => process.exit(0), 100);
-}, LoginSchema);
+);
 var loginPlugin = ({ context }) => {
   const loginWithTelemetry = async (options) => {
     const startTime = Date.now();
     let success = false;
     let errorMessage = null;
     try {
-      await loginWithSdk(options);
+      await loginWithSdk({
+        ...options,
+        baseUrl: context.options?.baseUrl,
+        authBaseUrl: context.options?.authBaseUrl,
+        authClientId: context.options?.authClientId
+      });
       success = true;
     } catch (error) {
       success = false;
@@ -618,14 +638,6 @@ var addPlugin = ({ sdk }) => {
     if (successfulApps.length > 0) {
       console.log(`\u2705 Added ${successfulApps.length} app(s) to manifest`);
     }
-    const allErrors = [...manifestResult.errors, ...typesResult.errors];
-    if (allErrors.length > 0) {
-      console.warn(`
-\u26A0\uFE0F ${allErrors.length} error(s) occurred:`);
-      allErrors.forEach(({ appKey, error }) => {
-        console.warn(`  - ${appKey}: ${error}`);
-      });
-    }
   }, AddSchema);
   return {
     add,
@@ -1245,17 +1257,12 @@ var generateAppTypesPlugin = ({ sdk }) => {
       appKeys,
       authenticationIds,
       skipWrite = false,
-      typesOutputDirectory,
+      typesOutputDirectory = await detectTypesOutputDirectory(),
       onProgress
     } = options;
-    if (!skipWrite && !typesOutputDirectory) {
-      throw new Error(
-        "typesOutputDirectory is required when skipWrite is false"
-      );
-    }
+    const resolvedTypesOutput = resolve(typesOutputDirectory);
     const result = {
-      typeDefinitions: {},
-      errors: []
+      typeDefinitions: {}
     };
     onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
     const appsIterator = sdk.listApps({ appKeys }).items();
@@ -1283,8 +1290,8 @@ var generateAppTypesPlugin = ({ sdk }) => {
         count: authentications.length
       });
     }
-    if (!skipWrite && typesOutputDirectory) {
-      await mkdir(typesOutputDirectory, { recursive: true });
+    if (!skipWrite && resolvedTypesOutput) {
+      await mkdir(resolvedTypesOutput, { recursive: true });
     }
     if (!skipWrite) {
       result.writtenFiles = {};
@@ -1297,17 +1304,18 @@ var generateAppTypesPlugin = ({ sdk }) => {
       });
       try {
         if (!app.version) {
-          const error = `Invalid implementation ID format: ${app.implementation_id}. Expected format: <implementationName>@<version>`;
-          result.errors.push({
-            appKey: app.key,
-            error
-          });
+          const errorMessage = `Invalid implementation ID format: ${app.implementation_id}. Expected format: <implementationName>@<version>`;
           onProgress?.({
             type: "app_processing_error",
             appKey: app.key,
-            error
+            error: errorMessage
+          });
+          throw new ZapierValidationError(errorMessage, {
+            details: {
+              appKey: app.key,
+              implementationId: app.implementation_id
+            }
           });
-          continue;
         }
         let authenticationId;
         if (authentications.length > 0) {
@@ -1330,56 +1338,47 @@ var generateAppTypesPlugin = ({ sdk }) => {
           }
         }
         const manifestKey = getManifestKey(app);
-        try {
-          const generator = new AstTypeGenerator();
-          const typeDefinitionString = await generator.generateTypes({
-            app,
-            authenticationId,
-            sdk
-          });
-          result.typeDefinitions[manifestKey] = typeDefinitionString;
+        const generator = new AstTypeGenerator();
+        const typeDefinitionString = await generator.generateTypes({
+          app,
+          authenticationId,
+          sdk
+        });
+        result.typeDefinitions[manifestKey] = typeDefinitionString;
+        onProgress?.({
+          type: "type_generated",
+          manifestKey,
+          sizeBytes: typeDefinitionString.length
+        });
+        if (!skipWrite && resolvedTypesOutput && result.writtenFiles) {
+          const filePath = join(resolvedTypesOutput, `${manifestKey}.d.ts`);
+          await writeFile(filePath, typeDefinitionString, "utf8");
+          result.writtenFiles[manifestKey] = filePath;
           onProgress?.({
-            type: "type_generated",
+            type: "file_written",
             manifestKey,
-            sizeBytes: typeDefinitionString.length
-          });
-          if (!skipWrite && typesOutputDirectory && result.writtenFiles) {
-            const filePath = join(typesOutputDirectory, `${manifestKey}.d.ts`);
-            await writeFile(filePath, typeDefinitionString, "utf8");
-            result.writtenFiles[manifestKey] = filePath;
-            onProgress?.({
-              type: "file_written",
-              manifestKey,
-              filePath
-            });
-          }
-          onProgress?.({
-            type: "app_processing_complete",
-            appKey: app.key
-          });
-        } catch (error) {
-          const errorMessage = `Failed to generate types: ${error}`;
-          result.errors.push({
-            appKey: app.key,
-            error: errorMessage
-          });
-          onProgress?.({
-            type: "app_processing_error",
-            appKey: app.key,
-            error: errorMessage
+            filePath
           });
         }
-      } catch (error) {
-        const errorMessage = `Failed to process app: ${error}`;
-        result.errors.push({
-          appKey: app.key,
-          error: errorMessage
+        onProgress?.({
+          type: "app_processing_complete",
+          appKey: app.key
         });
+      } catch (error) {
+        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;
+        } else {
+          throw new ZapierUnknownError(errorMessage, {
+            cause: error
+            // Works for both Error and non-Error
+          });
+        }
       }
     }
     return result;
@@ -1414,9 +1413,6 @@ var BuildManifestSchema = z.object({
 var buildManifestPlugin = ({ sdk, context }) => {
   const buildManifest = createFunction(async function buildManifest2(options) {
     const { appKeys, skipWrite = false, configPath, onProgress } = options;
-    const result = {
-      errors: []
-    };
     onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
     const appsIterator = sdk.listApps({ appKeys }).items();
     const apps = [];
@@ -1426,7 +1422,7 @@ var buildManifestPlugin = ({ sdk, context }) => {
     }
     onProgress?.({ type: "apps_lookup_complete", count: apps.length });
     if (apps.length === 0) {
-      return result;
+      return {};
     }
     let updatedManifest;
     for (const app of apps) {
@@ -1459,20 +1455,23 @@ var buildManifestPlugin = ({ sdk, context }) => {
         });
         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;
+        } else {
+          throw new ZapierUnknownError(errorMessage, {
+            cause: error
+            // Works for both Error and non-Error
+          });
+        }
       }
     }
-    result.manifest = updatedManifest;
-    return result;
+    return { manifest: updatedManifest };
   }, BuildManifestSchema);
   return {
     buildManifest,

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zapier/zapier-sdk-cli",
-    "version": "0.13.9",
+    "version": "0.13.11",
     "description": "Command line interface for Zapier SDK",
     "main": "dist/index.cjs",
     "module": "dist/index.mjs",

package/dist/src/cli.js

@@ -8,12 +8,32 @@ program
     .name("zapier-sdk")
     .description("CLI for Zapier SDK")
     .version(packageJson.version, "-v, --version", "display version number")
-    .option("--debug", "Enable debug logging");
-// Check for debug flag early
+    .option("--debug", "Enable debug logging")
+    .option("--base-url <url>", "Base URL for Zapier API endpoints")
+    .option("--auth-base-url <url>", "Base URL for Zapier authentication endpoints")
+    .option("--auth-client-id <id>", "OAuth client ID for Zapier authentication")
+    .option("--tracking-base-url <url>", "Base URL for Zapier tracking endpoints");
+// Check for debug flag early (support both flag and env var)
 const isDebugMode = process.env.DEBUG === "true" || process.argv.includes("--debug");
-// Create CLI SDK instance with all plugins
+// Extract URL options from process.argv for early SDK creation
+// We need to create the SDK before parsing to generate commands from schemas
+const baseUrlIndex = process.argv.indexOf("--base-url");
+const authBaseUrlIndex = process.argv.indexOf("--auth-base-url");
+const authClientIdIndex = process.argv.indexOf("--auth-client-id");
+const trackingBaseUrlIndex = process.argv.indexOf("--tracking-base-url");
+const baseUrl = baseUrlIndex !== -1 ? process.argv[baseUrlIndex + 1] : undefined;
+const authBaseUrl = authBaseUrlIndex !== -1 ? process.argv[authBaseUrlIndex + 1] : undefined;
+const authClientId = authClientIdIndex !== -1 ? process.argv[authClientIdIndex + 1] : undefined;
+const trackingBaseUrl = trackingBaseUrlIndex !== -1
+    ? process.argv[trackingBaseUrlIndex + 1]
+    : undefined;
+// Create CLI SDK instance with all plugins and URL options
 const sdk = createZapierCliSdk({
     debug: isDebugMode,
+    baseUrl,
+    authBaseUrl,
+    authClientId,
+    trackingBaseUrl,
 });
 // Auth commands now handled by plugins
 // Generate CLI commands from SDK schemas (including CLI plugins)

package/dist/src/plugins/add/index.js

@@ -88,14 +88,6 @@ export const addPlugin = ({ sdk }) => {
         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 {
         add,

package/dist/src/plugins/buildManifest/index.js

@@ -1,12 +1,9 @@
-import { createFunction } from "@zapier/zapier-sdk";
+import { createFunction, ZapierValidationError, ZapierUnknownError, } from "@zapier/zapier-sdk";
 import { BuildManifestSchema, } from "./schemas";
 import { createManifestEntry } from "../../utils/manifest-helpers";
 export const buildManifestPlugin = ({ sdk, context }) => {
     const buildManifest = createFunction(async function buildManifest(options) {
         const { appKeys, skipWrite = false, configPath, onProgress } = options;
-        const result = {
-            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();
@@ -17,7 +14,7 @@ export const buildManifestPlugin = ({ sdk, context }) => {
         }
         onProgress?.({ type: "apps_lookup_complete", count: apps.length });
         if (apps.length === 0) {
-            return result;
+            return {};
         }
         let updatedManifest;
         // Process each app
@@ -52,20 +49,23 @@ export const buildManifestPlugin = ({ sdk, context }) => {
                 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 {
         buildManifest,

package/dist/src/plugins/buildManifest/schemas.d.ts

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

package/dist/src/plugins/generateAppTypes/index.js

@@ -1,19 +1,16 @@
-import { createFunction } from "@zapier/zapier-sdk";
+import { createFunction, ZapierValidationError, ZapierUnknownError, } from "@zapier/zapier-sdk";
 import { GenerateAppTypesSchema, } from "./schemas";
 import { AstTypeGenerator } from "../../generators/ast-generator";
 import { getManifestKey } from "../../utils/manifest-helpers";
 import { mkdir, writeFile } from "fs/promises";
-import { join } from "path";
+import { join, resolve } from "path";
+import { detectTypesOutputDirectory } from "../../utils/directory-detection";
 export const generateAppTypesPlugin = ({ sdk }) => {
     const generateAppTypes = createFunction(async function generateAppTypes(options) {
-        const { appKeys, authenticationIds, skipWrite = false, typesOutputDirectory, onProgress, } = options;
-        // Validate that typesOutputDirectory is provided when skipWrite is false
-        if (!skipWrite && !typesOutputDirectory) {
-            throw new Error("typesOutputDirectory is required when skipWrite is false");
-        }
+        const { appKeys, authenticationIds, skipWrite = false, typesOutputDirectory = await detectTypesOutputDirectory(), onProgress, } = options;
+        const resolvedTypesOutput = resolve(typesOutputDirectory);
         const result = {
             typeDefinitions: {},
-            errors: [],
         };
         // Get apps using listApps (which respects existing manifest for version locking)
         onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
@@ -46,8 +43,8 @@ export const generateAppTypesPlugin = ({ sdk }) => {
             });
         }
         // Ensure output directory exists if we're writing files
-        if (!skipWrite && typesOutputDirectory) {
-            await mkdir(typesOutputDirectory, { recursive: true });
+        if (!skipWrite && resolvedTypesOutput) {
+            await mkdir(resolvedTypesOutput, { recursive: true });
         }
         // Initialize writtenFiles if we're writing to disk
         if (!skipWrite) {
@@ -62,17 +59,18 @@ export const generateAppTypesPlugin = ({ sdk }) => {
             });
             try {
                 if (!app.version) {
-                    const error = `Invalid implementation ID format: ${app.implementation_id}. Expected format: <implementationName>@<version>`;
-                    result.errors.push({
-                        appKey: app.key,
-                        error,
-                    });
+                    const errorMessage = `Invalid implementation ID format: ${app.implementation_id}. Expected format: <implementationName>@<version>`;
                     onProgress?.({
                         type: "app_processing_error",
                         appKey: app.key,
-                        error,
+                        error: errorMessage,
+                    });
+                    throw new ZapierValidationError(errorMessage, {
+                        details: {
+                            appKey: app.key,
+                            implementationId: app.implementation_id,
+                        },
                     });
-                    continue;
                 }
                 // Find matching authentication for this app if authentications were provided
                 let authenticationId;
@@ -98,59 +96,49 @@ export const generateAppTypesPlugin = ({ sdk }) => {
                 }
                 const manifestKey = getManifestKey(app);
                 // Generate type definitions
-                try {
-                    const generator = new AstTypeGenerator();
-                    const typeDefinitionString = await generator.generateTypes({
-                        app,
-                        authenticationId,
-                        sdk,
-                    });
-                    result.typeDefinitions[manifestKey] = typeDefinitionString;
+                const generator = new AstTypeGenerator();
+                const typeDefinitionString = await generator.generateTypes({
+                    app,
+                    authenticationId,
+                    sdk,
+                });
+                result.typeDefinitions[manifestKey] = typeDefinitionString;
+                onProgress?.({
+                    type: "type_generated",
+                    manifestKey,
+                    sizeBytes: typeDefinitionString.length,
+                });
+                // Write to file if skipWrite is false
+                if (!skipWrite && resolvedTypesOutput && result.writtenFiles) {
+                    const filePath = join(resolvedTypesOutput, `${manifestKey}.d.ts`);
+                    await writeFile(filePath, typeDefinitionString, "utf8");
+                    result.writtenFiles[manifestKey] = filePath;
                     onProgress?.({
-                        type: "type_generated",
+                        type: "file_written",
                         manifestKey,
-                        sizeBytes: typeDefinitionString.length,
-                    });
-                    // Write to file if skipWrite is false
-                    if (!skipWrite && typesOutputDirectory && result.writtenFiles) {
-                        const filePath = join(typesOutputDirectory, `${manifestKey}.d.ts`);
-                        await writeFile(filePath, typeDefinitionString, "utf8");
-                        result.writtenFiles[manifestKey] = filePath;
-                        onProgress?.({
-                            type: "file_written",
-                            manifestKey,
-                            filePath,
-                        });
-                    }
-                    onProgress?.({
-                        type: "app_processing_complete",
-                        appKey: app.key,
-                    });
-                }
-                catch (error) {
-                    const errorMessage = `Failed to generate types: ${error}`;
-                    result.errors.push({
-                        appKey: app.key,
-                        error: errorMessage,
-                    });
-                    onProgress?.({
-                        type: "app_processing_error",
-                        appKey: app.key,
-                        error: errorMessage,
+                        filePath,
                     });
                 }
-            }
-            catch (error) {
-                const errorMessage = `Failed to process app: ${error}`;
-                result.errors.push({
+                onProgress?.({
+                    type: "app_processing_complete",
                     appKey: app.key,
-                    error: errorMessage,
                 });
+            }
+            catch (error) {
+                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
+                    });
+                }
             }
         }
         return result;

package/dist/src/plugins/generateAppTypes/schemas.d.ts

@@ -65,8 +65,4 @@ export type AppTypesProgressEvent = {
 export interface GenerateAppTypesResult {
     typeDefinitions: Record<string, string>;
     writtenFiles?: Record<string, string>;
-    errors: Array<{
-        appKey: string;
-        error: string;
-    }>;
 }