@zapier/zapier-sdk-cli 0.13.9 → 0.13.11

package/src/plugins/generateAppTypes/index.ts

@@ -8,7 +8,11 @@ import type {
   ManifestPluginProvides,
   AppItem,
 } from "@zapier/zapier-sdk";
-import { createFunction } from "@zapier/zapier-sdk";
+import {
+  createFunction,
+  ZapierValidationError,
+  ZapierUnknownError,
+} from "@zapier/zapier-sdk";
 import {
   GenerateAppTypesSchema,
   type GenerateAppTypesOptions,
@@ -17,7 +21,8 @@ import {
 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 interface GenerateAppTypesPluginProvides {
   generateAppTypes: (
@@ -50,20 +55,14 @@ export const generateAppTypesPlugin: Plugin<
       appKeys,
       authenticationIds,
       skipWrite = false,
-      typesOutputDirectory,
+      typesOutputDirectory = await detectTypesOutputDirectory(),
       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 resolvedTypesOutput = resolve(typesOutputDirectory);
 
     const result: GenerateAppTypesResult = {
       typeDefinitions: {},
-      errors: [],
     };
 
     // Get apps using listApps (which respects existing manifest for version locking)
@@ -100,8 +99,8 @@ export const generateAppTypesPlugin: Plugin<
     }
 
     // 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
@@ -119,17 +118,18 @@ export const generateAppTypesPlugin: Plugin<
 
       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
@@ -158,63 +158,55 @@ export const generateAppTypesPlugin: Plugin<
         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,
+        });
 
-          onProgress?.({
-            type: "type_generated",
-            manifestKey,
-            sizeBytes: typeDefinitionString.length,
-          });
+        result.typeDefinitions[manifestKey] = typeDefinitionString;
 
-          // Write to file if skipWrite is false
-          if (!skipWrite && typesOutputDirectory && result.writtenFiles) {
-            const filePath = join(typesOutputDirectory, `${manifestKey}.d.ts`);
-            await writeFile(filePath, typeDefinitionString, "utf8");
+        onProgress?.({
+          type: "type_generated",
+          manifestKey,
+          sizeBytes: typeDefinitionString.length,
+        });
 
-            result.writtenFiles[manifestKey] = filePath;
+        // Write to file if skipWrite is false
+        if (!skipWrite && resolvedTypesOutput && result.writtenFiles) {
+          const filePath = join(resolvedTypesOutput, `${manifestKey}.d.ts`);
+          await writeFile(filePath, typeDefinitionString, "utf8");
 
-            onProgress?.({
-              type: "file_written",
-              manifestKey,
-              filePath,
-            });
-          }
+          result.writtenFiles[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,
+            type: "file_written",
+            manifestKey,
+            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
+          });
+        }
       }
     }
 

package/src/plugins/generateAppTypes/schemas.ts

@@ -58,8 +58,4 @@ export type AppTypesProgressEvent =
 export interface GenerateAppTypesResult {
   typeDefinitions: Record<string, string>; // manifestKey -> type definition string
   writtenFiles?: Record<string, string>; // manifestKey -> file path (only when skipWrite is false)
-  errors: Array<{
-    appKey: string;
-    error: string;
-  }>;
 }

package/src/plugins/login/index.ts

@@ -29,22 +29,36 @@ interface LoginPluginProvides {
 const CLI_COMMAND_EXECUTED_EVENT_SUBJECT =
   "platform.sdk.CliCommandExecutedEvent";
 
-const loginWithSdk = createFunction(async function loginWithSdk(
-  options: LoginOptions,
-): Promise<void> {
-  const timeoutSeconds = options.timeout ? parseInt(options.timeout, 10) : 300;
-  if (isNaN(timeoutSeconds) || timeoutSeconds <= 0) {
-    throw new Error("Timeout must be a positive number");
-  }
+// Internal type for loginWithSdk that includes SDK URL options
+interface LoginWithSdkOptions extends LoginOptions {
+  baseUrl?: string;
+  authBaseUrl?: string;
+  authClientId?: string;
+}
+
+const loginWithSdk = createFunction(
+  async (options: LoginWithSdkOptions): Promise<void> => {
+    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(timeoutSeconds * 1000); // Convert to milliseconds
-  const user = await getLoggedInUser();
+    await login({
+      timeoutMs: timeoutSeconds * 1000,
+      baseUrl: options.baseUrl,
+      authBaseUrl: options.authBaseUrl,
+      authClientId: options.authClientId,
+    });
+    const user = await getLoggedInUser();
 
-  console.log(`✅ Successfully logged in as ${user.email}`);
+    console.log(`✅ Successfully logged in as ${user.email}`);
 
-  // Force immediate exit to prevent hanging (especially in development with tsx)
-  setTimeout(() => process.exit(0), 100);
-}, LoginSchema);
+    // Force immediate exit to prevent hanging (especially in development with tsx)
+    setTimeout(() => process.exit(0), 100);
+  },
+);
 
 export const loginPlugin: Plugin<
   {},
@@ -58,7 +72,12 @@ export const loginPlugin: Plugin<
     let errorMessage: string | null = 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;

package/src/utils/auth/login.ts

@@ -6,16 +6,20 @@ import type { Socket } from "net";
 
 import {
   AUTH_MODE_HEADER,
-  LOGIN_CLIENT_ID,
+  ZAPIER_AUTH_CLIENT_ID,
   LOGIN_PORTS,
   LOGIN_TIMEOUT_MS,
-  ZAPIER_BASE,
 } from "../constants";
 import { spinPromise } from "../spinner";
 import log from "../log";
 import api from "../api/client";
 import getCallablePromise from "../getCallablePromise";
-import { updateLogin, logout } from "@zapier/zapier-sdk-cli-login";
+import {
+  updateLogin,
+  logout,
+  getAuthTokenUrl,
+  getAuthAuthorizeUrl,
+} from "@zapier/zapier-sdk-cli-login";
 
 const findAvailablePort = (): Promise<number> => {
   return new Promise((resolve, reject) => {
@@ -62,7 +66,22 @@ const generateRandomString = () => {
   ).join("");
 };
 
-const login = async (timeoutMs: number = LOGIN_TIMEOUT_MS): Promise<string> => {
+interface LoginOptions {
+  timeoutMs?: number;
+  baseUrl?: string;
+  authBaseUrl?: string;
+  authClientId?: string;
+}
+
+const login = async ({
+  timeoutMs = LOGIN_TIMEOUT_MS,
+  baseUrl,
+  authBaseUrl,
+  authClientId,
+}: LoginOptions): Promise<string> => {
+  const authOptions = { baseUrl, authBaseUrl };
+  const tokenUrl = getAuthTokenUrl(authOptions);
+  const authorizeUrl = getAuthAuthorizeUrl(authOptions);
   // Force logout
   logout();
 
@@ -106,9 +125,9 @@ const login = async (timeoutMs: number = LOGIN_TIMEOUT_MS): Promise<string> => {
   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(),
@@ -165,12 +184,12 @@ const login = async (timeoutMs: number = LOGIN_TIMEOUT_MS): Promise<string> => {
     refresh_token: string;
     expires_in: number;
   }>(
-    `${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,
     },
     {

package/src/utils/constants.ts

@@ -1,7 +1,6 @@
 // Import shared OAuth constants from login package
 export {
-  ZAPIER_BASE,
-  LOGIN_CLIENT_ID,
+  ZAPIER_AUTH_CLIENT_ID,
   AUTH_MODE_HEADER,
 } from "@zapier/zapier-sdk-cli-login";