@zapier/zapier-sdk-cli 0.13.4 → 0.13.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk-cli",
-  "version": "0.13.4",
+  "version": "0.13.6",
   "description": "Command line interface for Zapier SDK",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -41,10 +41,11 @@
     "open": "^10.2.0",
     "ora": "^8.2.0",
     "pkce-challenge": "^5.0.0",
+    "typescript": "^5.8.3",
     "zod": "^3.25.67",
-    "@zapier/zapier-sdk": "0.13.4",
-    "@zapier/zapier-sdk-mcp": "0.3.17",
-    "@zapier/zapier-sdk-cli-login": "0.3.2"
+    "@zapier/zapier-sdk-cli-login": "0.3.2",
+    "@zapier/zapier-sdk": "0.13.5",
+    "@zapier/zapier-sdk-mcp": "0.3.18"
   },
   "devDependencies": {
     "@types/express": "^5.0.3",
@@ -52,7 +53,6 @@
     "@types/jsonwebtoken": "^9.0.10",
     "@types/node": "^24.0.1",
     "tsup": "^8.5.0",
-    "typescript": "^5.8.3",
     "vitest": "^3.2.3"
   },
   "scripts": {

package/src/plugins/add/index.ts

@@ -1,40 +1,22 @@
 import type {
   Plugin,
   GetSdkType,
-  GetContextType,
   ListActionsPluginProvides,
   ListAppsPluginProvides,
   ListInputFieldsPluginProvides,
   ListAuthenticationsPluginProvides,
-  ManifestPluginProvides,
-  AppItem,
 } from "@zapier/zapier-sdk";
 import { createFunction } from "@zapier/zapier-sdk";
 import { AddSchema, type AddOptions } from "./schemas";
-import { AstTypeGenerator } from "./ast-generator";
-import { mkdir, access, writeFile } from "fs/promises";
-import { resolve, join } from "path";
-
-/**
- * Detect the best default directory for TypeScript types
- * Looks for src or lib directories, falls back to current directory
- */
-async function detectTypesOutputDirectory(): Promise<string> {
-  // Check for common source directories in priority order
-  const candidates = ["src", "lib"];
-
-  for (const candidate of candidates) {
-    try {
-      await access(candidate);
-      return join(candidate, "zapier", "apps");
-    } catch {
-      // Directory doesn't exist, continue to next candidate
-    }
-  }
 
-  // Fall back to current directory
-  return "./zapier/apps/";
-}
+import { type GenerateAppTypesPluginProvides } from "../generateAppTypes";
+import { type AppTypesProgressEvent } from "../generateAppTypes/schemas";
+import { type BuildManifestPluginProvides } from "../buildManifest";
+import { type ManifestBuildProgressEvent } from "../buildManifest/schemas";
+
+import { detectTypesOutputDirectory } from "../../utils/directory-detection";
+
+import { resolve } from "path";
 export interface AddPluginProvides {
   add: (options: AddOptions) => Promise<void>;
   context: {
@@ -52,11 +34,12 @@ export const addPlugin: Plugin<
       ListActionsPluginProvides &
       ListInputFieldsPluginProvides &
       ListAuthenticationsPluginProvides &
-      ManifestPluginProvides
+      BuildManifestPluginProvides &
+      GenerateAppTypesPluginProvides
   >,
-  GetContextType<ManifestPluginProvides>,
+  {},
   AddPluginProvides
-> = ({ sdk, context }) => {
+> = ({ sdk }) => {
   const add = createFunction(async function add(options: AddOptions) {
     const {
       appKeys,
@@ -64,114 +47,129 @@ export const addPlugin: Plugin<
       configPath,
       typesOutput = await detectTypesOutputDirectory(),
     } = options;
-
     const resolvedTypesOutput = resolve(typesOutput);
 
-    // Ensure types output directory exists
-    await mkdir(resolvedTypesOutput, { recursive: true });
-
-    // Get apps using listApps (which respects existing manifest for version locking)
-    console.log(`📦 Looking up ${appKeys.length} app(s)...`);
-    const appsIterator = sdk.listApps({ appKeys }).items();
-    const apps: AppItem[] = [];
-    for await (const app of appsIterator) {
-      apps.push(app);
-    }
-
-    if (apps.length === 0) {
-      console.warn("⚠️ No apps found");
-      return;
-    }
+    console.log(`📦 Adding ${appKeys.length} app(s)...`);
+
+    // Track app names for better console output
+    const appSlugAndKeyMap = new Map<string, string>();
+
+    // Define progress handler for manifest building
+    const handleManifestProgress = (event: ManifestBuildProgressEvent) => {
+      switch (event.type) {
+        case "apps_lookup_start":
+          console.log(`📦 Looking up ${event.count} app(s)...`);
+          break;
+
+        case "app_found":
+          // Store the app display name for later use
+          const displayName = event.app.slug
+            ? `${event.app.slug} (${event.app.key})`
+            : event.app.key;
+          appSlugAndKeyMap.set(event.app.key, displayName);
+          break;
+
+        case "apps_lookup_complete":
+          if (event.count === 0) {
+            console.warn("⚠️ No apps found");
+          }
+          break;
+
+        case "app_processing_start":
+          const appName = event.slug
+            ? `${event.slug} (${event.appKey})`
+            : event.appKey;
+          console.log(`📦 Adding ${appName}...`);
+          break;
+
+        case "manifest_updated":
+          const appDisplay = appSlugAndKeyMap.get(event.appKey) || event.appKey;
+          console.log(
+            `📝 Locked ${appDisplay} to ${event.appKey}@${event.version} using key '${event.manifestKey}'`,
+          );
+          break;
 
-    // Fetch authentications if provided
-    let authentications = [];
-    if (authenticationIds && authenticationIds.length > 0) {
-      console.log(
-        `🔐 Looking up ${authenticationIds.length} authentication(s)...`,
-      );
-      const authsIterator = sdk
-        .listAuthentications({ authenticationIds })
-        .items();
-      for await (const auth of authsIterator) {
-        authentications.push(auth);
+        case "app_processing_error":
+          const errorApp = appSlugAndKeyMap.get(event.appKey) || event.appKey;
+          console.warn(`⚠️ ${event.error} for ${errorApp}`);
+          break;
       }
-      console.log(`🔐 Found ${authentications.length} authentication(s)`);
-    }
+    };
 
-    // Process each app
-    for (const app of apps) {
-      const appSlugAndKey = app.slug ? `${app.slug} (${app.key})` : app.key;
-      console.log(`📦 Adding ${appSlugAndKey}...`);
+    // Define progress handler for type generation
+    const handleTypesProgress = (event: AppTypesProgressEvent) => {
+      switch (event.type) {
+        case "authentications_lookup_start":
+          console.log(`🔐 Looking up ${event.count} authentication(s)...`);
+          break;
+
+        case "authentications_lookup_complete":
+          console.log(`🔐 Found ${event.count} authentication(s)`);
+          break;
+
+        case "authentication_matched":
+          const appWithAuth =
+            appSlugAndKeyMap.get(event.appKey) || event.appKey;
+          console.log(
+            `🔐 Using authentication ${event.authenticationId} (${event.authenticationTitle}) for ${appWithAuth}`,
+          );
+          break;
 
-      try {
-        if (!app.version) {
+        case "authentication_not_matched":
+          const appWithoutAuth =
+            appSlugAndKeyMap.get(event.appKey) || event.appKey;
           console.warn(
-            `⚠️ Invalid implementation ID format for '${appSlugAndKey}': ${app.implementation_id}. Expected format: <implementationName>@<version>. Skipping...`,
+            `⚠️ No matching authentication found for ${appWithoutAuth}`,
           );
-          continue;
-        }
-
-        // Update manifest using manifest plugin's function
-        const [manifestKey] = await context.updateManifestEntry(
-          app.key,
-          {
-            implementationName: app.key,
-            version: app.version,
-          },
-          configPath,
-        );
-
-        console.log(
-          `📝 Locked ${appSlugAndKey} to ${app.key}@${app.version} using key '${manifestKey}'`,
-        );
-
-        // Find matching authentication for this app if authentications were provided
-        let authenticationId: number | undefined;
-        if (authentications.length > 0) {
-          // Match authentication by app_key
-          const matchingAuth = authentications.find((auth) => {
-            return auth.app_key === app.key;
-          });
-
-          if (matchingAuth) {
-            authenticationId = matchingAuth.id;
-            console.log(
-              `🔐 Using authentication ${authenticationId} (${matchingAuth.title}) for ${appSlugAndKey}`,
-            );
-          } else {
-            console.warn(
-              `⚠️ No matching authentication found for ${appSlugAndKey}`,
-            );
-          }
-        }
-
-        // Generate types using the manifest key for consistency
-        const typesPath = join(resolvedTypesOutput, `${manifestKey}.d.ts`);
-
-        try {
-          // Use AST-based generator directly
-          const generator = new AstTypeGenerator();
-          const typeDefinitions = await generator.generateTypes({
-            app,
-            authenticationId,
-            sdk,
-          });
-
-          // Write to file
-          await writeFile(typesPath, typeDefinitions, "utf8");
-          console.log(`🔧 Generated types for ${manifestKey} at ${typesPath}`);
-        } catch (error) {
-          console.warn(
-            `⚠️ Failed to generate types for ${appSlugAndKey}: ${error}`,
+          break;
+
+        case "file_written":
+          console.log(
+            `🔧 Generated types for ${event.manifestKey} at ${event.filePath}`,
           );
-          // Continue even if type generation fails
-        }
-      } catch (error) {
-        console.warn(`⚠️ Failed to process ${appSlugAndKey}: ${error}`);
+          break;
+
+        case "app_processing_error":
+          const errorApp = appSlugAndKeyMap.get(event.appKey) || event.appKey;
+          console.warn(`⚠️ ${event.error} for ${errorApp}`);
+          break;
       }
+    };
+
+    const manifestResult = await sdk.buildManifest({
+      appKeys,
+      skipWrite: false,
+      configPath,
+      onProgress: handleManifestProgress,
+    });
+
+    const typesResult = await sdk.generateAppTypes({
+      appKeys,
+      authenticationIds,
+      skipWrite: false,
+      typesOutputDirectory: resolvedTypesOutput,
+      onProgress: handleTypesProgress,
+    });
+
+    const results = manifestResult.manifest?.apps || {};
+
+    // Final summary
+    const successfulApps = Object.keys(results).filter(
+      (manifestKey) => typesResult.writtenFiles?.[manifestKey],
+    );
+
+    if (successfulApps.length > 0) {
+      console.log(`✅ Added ${successfulApps.length} app(s) to manifest`);
     }
 
-    console.log(`✅ Added ${apps.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 {