@zapier/zapier-sdk-cli 0.13.5 → 0.13.6

package/dist/index.d.ts

@@ -1,4 +1,156 @@
-import { ZapierSdk, BaseEvent } from '@zapier/zapier-sdk';
+import { AppItem, Manifest, GetSdkType, ZapierSdk, BaseEvent } from '@zapier/zapier-sdk';
+import { z } from 'zod';
+
+declare const BuildManifestSchema: z.ZodObject<{
+    appKeys: z.ZodArray<z.ZodString, "many">;
+    skipWrite: z.ZodOptional<z.ZodBoolean>;
+    configPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    appKeys: string[];
+    configPath?: string | undefined;
+    skipWrite?: boolean | undefined;
+}, {
+    appKeys: string[];
+    configPath?: string | undefined;
+    skipWrite?: boolean | undefined;
+}>;
+type BuildManifestOptions = z.infer<typeof BuildManifestSchema> & {
+    onProgress?: (event: ManifestBuildProgressEvent) => void;
+};
+type ManifestBuildProgressEvent = {
+    type: "apps_lookup_start";
+    count: number;
+} | {
+    type: "app_found";
+    app: AppItem;
+} | {
+    type: "apps_lookup_complete";
+    count: number;
+} | {
+    type: "app_processing_start";
+    appKey: string;
+    slug?: string;
+} | {
+    type: "manifest_entry_built";
+    appKey: string;
+    manifestKey: string;
+    version: string;
+} | {
+    type: "manifest_updated";
+    appKey: string;
+    manifestKey: string;
+    version: string;
+} | {
+    type: "app_processing_complete";
+    appKey: string;
+} | {
+    type: "app_processing_error";
+    appKey: string;
+    error: string;
+};
+interface BuildManifestResult {
+    manifest?: Manifest;
+    errors: Array<{
+        appKey: string;
+        error: string;
+    }>;
+}
+
+interface BuildManifestPluginProvides {
+    buildManifest: (options: BuildManifestOptions) => Promise<BuildManifestResult>;
+    context: {
+        meta: {
+            buildManifest: {
+                inputSchema: typeof BuildManifestSchema;
+            };
+        };
+    };
+}
+
+declare const GenerateAppTypesSchema: z.ZodObject<{
+    appKeys: z.ZodArray<z.ZodString, "many">;
+    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    skipWrite: z.ZodOptional<z.ZodBoolean>;
+    typesOutputDirectory: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    appKeys: string[];
+    authenticationIds?: string[] | undefined;
+    skipWrite?: boolean | undefined;
+    typesOutputDirectory?: string | undefined;
+}, {
+    appKeys: string[];
+    authenticationIds?: string[] | undefined;
+    skipWrite?: boolean | undefined;
+    typesOutputDirectory?: string | undefined;
+}>;
+type GenerateAppTypesOptions = z.infer<typeof GenerateAppTypesSchema> & {
+    onProgress?: (event: AppTypesProgressEvent) => void;
+};
+type AppTypesProgressEvent = {
+    type: "apps_lookup_start";
+    count: number;
+} | {
+    type: "app_found";
+    app: AppItem;
+} | {
+    type: "apps_lookup_complete";
+    count: number;
+} | {
+    type: "authentications_lookup_start";
+    count: number;
+} | {
+    type: "authentications_lookup_complete";
+    count: number;
+} | {
+    type: "app_processing_start";
+    appKey: string;
+    slug?: string;
+} | {
+    type: "authentication_matched";
+    appKey: string;
+    authenticationId: number;
+    authenticationTitle: string;
+} | {
+    type: "authentication_not_matched";
+    appKey: string;
+} | {
+    type: "type_generated";
+    manifestKey: string;
+    sizeBytes: number;
+} | {
+    type: "file_written";
+    manifestKey: string;
+    filePath: string;
+} | {
+    type: "app_processing_complete";
+    appKey: string;
+} | {
+    type: "app_processing_error";
+    appKey: string;
+    error: string;
+};
+interface GenerateAppTypesResult {
+    typeDefinitions: Record<string, string>;
+    writtenFiles?: Record<string, string>;
+    errors: Array<{
+        appKey: string;
+        error: string;
+    }>;
+}
+
+interface GenerateAppTypesPluginProvides {
+    generateAppTypes: (options: GenerateAppTypesOptions) => Promise<GenerateAppTypesResult>;
+    context: {
+        meta: {
+            generateAppTypes: {
+                inputSchema: typeof GenerateAppTypesSchema;
+            };
+        };
+    };
+}
+
+interface ZapierSdkCli extends GetSdkType<ZapierSdk & BuildManifestPluginProvides & GenerateAppTypesPluginProvides> {
+}
 
 interface ZapierCliSdkOptions {
     debug?: boolean;
@@ -15,7 +167,7 @@ interface ZapierCliSdkOptions {
  * Create a Zapier SDK instance configured specifically for the CLI
  * Includes all CLI-specific plugins in addition to the standard SDK functionality
  */
-declare function createZapierCliSdk(options?: ZapierCliSdkOptions): ZapierSdk;
+declare function createZapierCliSdk(options?: ZapierCliSdkOptions): ZapierSdkCli;
 
 /**
  * CLI-specific telemetry event definitions

package/dist/index.mjs

@@ -11,9 +11,9 @@ import { startMcpServerAsProcess } from '@zapier/zapier-sdk-mcp';
 import { buildSync } from 'esbuild';
 import * as fs from 'fs';
 import * as path from 'path';
-import { resolve, join } from 'path';
-import * as ts from 'typescript';
+import { join, resolve } from 'path';
 import { mkdir, writeFile, access } from 'fs/promises';
+import * as ts from 'typescript';
 
 // src/sdk.ts
 
@@ -232,7 +232,7 @@ var LoginSchema = z.object({
 
 // package.json
 var package_default = {
-  version: "0.13.5"};
+  version: "0.13.6"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {
@@ -520,6 +520,146 @@ var AddSchema = z.object({
 }).describe(
   "Add apps with manifest locking and TypeScript type generation - updates .zapierrc with app versions and generates TypeScript definition files"
 );
+async function detectTypesOutputDirectory() {
+  const candidates = ["src", "lib"];
+  for (const candidate of candidates) {
+    try {
+      await access(candidate);
+      return join(candidate, "zapier", "apps");
+    } catch {
+    }
+  }
+  return "./zapier/apps/";
+}
+var addPlugin = ({ sdk }) => {
+  const add = createFunction(async function add2(options) {
+    const {
+      appKeys,
+      authenticationIds,
+      configPath,
+      typesOutput = await detectTypesOutputDirectory()
+    } = options;
+    const resolvedTypesOutput = resolve(typesOutput);
+    console.log(`\u{1F4E6} Adding ${appKeys.length} app(s)...`);
+    const appSlugAndKeyMap = /* @__PURE__ */ new Map();
+    const handleManifestProgress = (event) => {
+      switch (event.type) {
+        case "apps_lookup_start":
+          console.log(`\u{1F4E6} Looking up ${event.count} app(s)...`);
+          break;
+        case "app_found":
+          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("\u26A0\uFE0F No apps found");
+          }
+          break;
+        case "app_processing_start":
+          const appName = event.slug ? `${event.slug} (${event.appKey})` : event.appKey;
+          console.log(`\u{1F4E6} Adding ${appName}...`);
+          break;
+        case "manifest_updated":
+          const appDisplay = appSlugAndKeyMap.get(event.appKey) || event.appKey;
+          console.log(
+            `\u{1F4DD} Locked ${appDisplay} to ${event.appKey}@${event.version} using key '${event.manifestKey}'`
+          );
+          break;
+        case "app_processing_error":
+          const errorApp = appSlugAndKeyMap.get(event.appKey) || event.appKey;
+          console.warn(`\u26A0\uFE0F ${event.error} for ${errorApp}`);
+          break;
+      }
+    };
+    const handleTypesProgress = (event) => {
+      switch (event.type) {
+        case "authentications_lookup_start":
+          console.log(`\u{1F510} Looking up ${event.count} authentication(s)...`);
+          break;
+        case "authentications_lookup_complete":
+          console.log(`\u{1F510} Found ${event.count} authentication(s)`);
+          break;
+        case "authentication_matched":
+          const appWithAuth = appSlugAndKeyMap.get(event.appKey) || event.appKey;
+          console.log(
+            `\u{1F510} Using authentication ${event.authenticationId} (${event.authenticationTitle}) for ${appWithAuth}`
+          );
+          break;
+        case "authentication_not_matched":
+          const appWithoutAuth = appSlugAndKeyMap.get(event.appKey) || event.appKey;
+          console.warn(
+            `\u26A0\uFE0F No matching authentication found for ${appWithoutAuth}`
+          );
+          break;
+        case "file_written":
+          console.log(
+            `\u{1F527} Generated types for ${event.manifestKey} at ${event.filePath}`
+          );
+          break;
+        case "app_processing_error":
+          const errorApp = appSlugAndKeyMap.get(event.appKey) || event.appKey;
+          console.warn(`\u26A0\uFE0F ${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 || {};
+    const successfulApps = Object.keys(results).filter(
+      (manifestKey) => typesResult.writtenFiles?.[manifestKey]
+    );
+    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,
+    context: {
+      meta: {
+        add: {
+          categories: ["utility"],
+          inputSchema: AddSchema
+        }
+      }
+    }
+  };
+};
+var GenerateAppTypesSchema = z.object({
+  appKeys: z.array(z.string().min(1, "App key cannot be empty")).min(1, "At least one app key is required").describe(
+    "One or more app keys to generate types for (e.g., 'slack', 'github', 'trello')"
+  ),
+  authenticationIds: z.array(z.string()).optional().describe(
+    "Authentication IDs to use for type generation (e.g., ['123', '456'])"
+  ),
+  skipWrite: z.boolean().optional().describe(
+    "If true, returns type definitions without writing to disk. If false or omitted, writes type files."
+  ),
+  typesOutputDirectory: z.string().optional().describe(
+    "Directory for TypeScript type files. Required when skipWrite is false or omitted."
+  )
+}).describe(
+  "Generate TypeScript type definitions for apps - can optionally write to disk or just return type strings"
+);
 var AstTypeGenerator = class {
   constructor() {
     this.factory = ts.factory;
@@ -1088,69 +1228,92 @@ Usage:
     return Array.from(allKeys);
   }
 };
-async function detectTypesOutputDirectory() {
-  const candidates = ["src", "lib"];
-  for (const candidate of candidates) {
-    try {
-      await access(candidate);
-      return join(candidate, "zapier", "apps");
-    } catch {
-    }
+
+// src/utils/manifest-helpers.ts
+function getManifestKey(app) {
+  return app.slug || app.key;
+}
+function createManifestEntry(app) {
+  if (!app.version) {
+    throw new Error(
+      `App ${app.key} does not have a version. Implementation ID: ${app.implementation_id}`
+    );
   }
-  return "./zapier/apps/";
+  return {
+    implementationName: app.key,
+    version: app.version
+  };
 }
-var addPlugin = ({ sdk, context }) => {
-  const add = createFunction(async function add2(options) {
+var generateAppTypesPlugin = ({ sdk }) => {
+  const generateAppTypes = createFunction(async function generateAppTypes2(options) {
     const {
       appKeys,
       authenticationIds,
-      configPath,
-      typesOutput = await detectTypesOutputDirectory()
+      skipWrite = false,
+      typesOutputDirectory,
+      onProgress
     } = options;
-    const resolvedTypesOutput = resolve(typesOutput);
-    await mkdir(resolvedTypesOutput, { recursive: true });
-    console.log(`\u{1F4E6} Looking up ${appKeys.length} app(s)...`);
+    if (!skipWrite && !typesOutputDirectory) {
+      throw new Error(
+        "typesOutputDirectory is required when skipWrite is false"
+      );
+    }
+    const result = {
+      typeDefinitions: {},
+      errors: []
+    };
+    onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
     const appsIterator = sdk.listApps({ appKeys }).items();
     const apps = [];
     for await (const app of appsIterator) {
       apps.push(app);
+      onProgress?.({ type: "app_found", app });
     }
+    onProgress?.({ type: "apps_lookup_complete", count: apps.length });
     if (apps.length === 0) {
-      console.warn("\u26A0\uFE0F No apps found");
-      return;
+      return result;
     }
-    let authentications = [];
+    const authentications = [];
     if (authenticationIds && authenticationIds.length > 0) {
-      console.log(
-        `\u{1F510} Looking up ${authenticationIds.length} authentication(s)...`
-      );
+      onProgress?.({
+        type: "authentications_lookup_start",
+        count: authenticationIds.length
+      });
       const authsIterator = sdk.listAuthentications({ authenticationIds }).items();
       for await (const auth of authsIterator) {
         authentications.push(auth);
       }
-      console.log(`\u{1F510} Found ${authentications.length} authentication(s)`);
+      onProgress?.({
+        type: "authentications_lookup_complete",
+        count: authentications.length
+      });
+    }
+    if (!skipWrite && typesOutputDirectory) {
+      await mkdir(typesOutputDirectory, { recursive: true });
+    }
+    if (!skipWrite) {
+      result.writtenFiles = {};
     }
     for (const app of apps) {
-      const appSlugAndKey = app.slug ? `${app.slug} (${app.key})` : app.key;
-      console.log(`\u{1F4E6} Adding ${appSlugAndKey}...`);
+      onProgress?.({
+        type: "app_processing_start",
+        appKey: app.key,
+        slug: app.slug
+      });
       try {
         if (!app.version) {
-          console.warn(
-            `\u26A0\uFE0F Invalid implementation ID format for '${appSlugAndKey}': ${app.implementation_id}. Expected format: <implementationName>@<version>. Skipping...`
-          );
+          const error = `Invalid implementation ID format: ${app.implementation_id}. Expected format: <implementationName>@<version>`;
+          result.errors.push({
+            appKey: app.key,
+            error
+          });
+          onProgress?.({
+            type: "app_processing_error",
+            appKey: app.key,
+            error
+          });
           continue;
         }
-        const [manifestKey] = await context.updateManifestEntry(
-          app.key,
-          {
-            implementationName: app.key,
-            version: app.version
-          },
-          configPath
-        );
-        console.log(
-          `\u{1F4DD} Locked ${appSlugAndKey} to ${app.key}@${app.version} using key '${manifestKey}'`
-        );
         let authenticationId;
         if (authentications.length > 0) {
           const matchingAuth = authentications.find((auth) => {
@@ -1158,43 +1321,171 @@ var addPlugin = ({ sdk, context }) => {
           });
           if (matchingAuth) {
             authenticationId = matchingAuth.id;
-            console.log(
-              `\u{1F510} Using authentication ${authenticationId} (${matchingAuth.title}) for ${appSlugAndKey}`
-            );
+            onProgress?.({
+              type: "authentication_matched",
+              appKey: app.key,
+              authenticationId: matchingAuth.id,
+              authenticationTitle: matchingAuth.title || ""
+            });
           } else {
-            console.warn(
-              `\u26A0\uFE0F No matching authentication found for ${appSlugAndKey}`
-            );
+            onProgress?.({
+              type: "authentication_not_matched",
+              appKey: app.key
+            });
           }
         }
-        const typesPath = join(resolvedTypesOutput, `${manifestKey}.d.ts`);
+        const manifestKey = getManifestKey(app);
         try {
           const generator = new AstTypeGenerator();
-          const typeDefinitions = await generator.generateTypes({
+          const typeDefinitionString = await generator.generateTypes({
             app,
             authenticationId,
             sdk
           });
-          await writeFile(typesPath, typeDefinitions, "utf8");
-          console.log(`\u{1F527} Generated types for ${manifestKey} at ${typesPath}`);
+          result.typeDefinitions[manifestKey] = typeDefinitionString;
+          onProgress?.({
+            type: "type_generated",
+            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) {
-          console.warn(
-            `\u26A0\uFE0F Failed to generate types for ${appSlugAndKey}: ${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
+          });
         }
       } catch (error) {
-        console.warn(`\u26A0\uFE0F Failed to process ${appSlugAndKey}: ${error}`);
+        const errorMessage = `Failed to process app: ${error}`;
+        result.errors.push({
+          appKey: app.key,
+          error: errorMessage
+        });
+        onProgress?.({
+          type: "app_processing_error",
+          appKey: app.key,
+          error: errorMessage
+        });
       }
     }
-    console.log(`\u2705 Added ${apps.length} app(s) to manifest`);
-  }, AddSchema);
+    return result;
+  }, GenerateAppTypesSchema);
   return {
-    add,
+    generateAppTypes,
     context: {
       meta: {
-        add: {
+        generateAppTypes: {
           categories: ["utility"],
-          inputSchema: AddSchema
+          inputSchema: GenerateAppTypesSchema
+        }
+      }
+    }
+  };
+};
+var BuildManifestSchema = z.object({
+  appKeys: z.array(z.string().min(1, "App key cannot be empty")).min(1, "At least one app key is required").describe(
+    "One or more app keys to build manifest entries for (e.g., 'slack', 'github', 'trello')"
+  ),
+  skipWrite: z.boolean().optional().describe(
+    "If true, returns manifest entries without writing to disk. If false or omitted, writes to the manifest file."
+  ),
+  configPath: z.string().optional().describe(
+    "Path to the manifest file. Only used when skipWrite is false or omitted."
+  )
+}).describe(
+  "Build manifest entries for apps - can optionally write to disk or just return JSON"
+);
+
+// src/plugins/buildManifest/index.ts
+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 = [];
+    for await (const app of appsIterator) {
+      apps.push(app);
+      onProgress?.({ type: "app_found", app });
+    }
+    onProgress?.({ type: "apps_lookup_complete", count: apps.length });
+    if (apps.length === 0) {
+      return result;
+    }
+    let updatedManifest;
+    for (const app of apps) {
+      onProgress?.({
+        type: "app_processing_start",
+        appKey: app.key,
+        slug: app.slug
+      });
+      try {
+        const manifestEntry = createManifestEntry(app);
+        onProgress?.({
+          type: "manifest_entry_built",
+          appKey: app.key,
+          manifestKey: manifestEntry.implementationName,
+          version: manifestEntry.version
+        });
+        const [updatedManifestKey, , manifest] = await context.updateManifestEntry({
+          appKey: app.key,
+          entry: manifestEntry,
+          configPath,
+          skipWrite,
+          manifest: updatedManifest
+        });
+        updatedManifest = manifest;
+        onProgress?.({
+          type: "manifest_updated",
+          appKey: app.key,
+          manifestKey: updatedManifestKey,
+          version: manifestEntry.version
+        });
+        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
+        });
+        onProgress?.({
+          type: "app_processing_error",
+          appKey: app.key,
+          error: errorMessage
+        });
+      }
+    }
+    result.manifest = updatedManifest;
+    return result;
+  }, BuildManifestSchema);
+  return {
+    buildManifest,
+    context: {
+      meta: {
+        buildManifest: {
+          categories: ["utility"],
+          inputSchema: BuildManifestSchema
         }
       }
     }
@@ -1203,18 +1494,10 @@ var addPlugin = ({ sdk, context }) => {
 
 // src/sdk.ts
 function createZapierCliSdk(options = {}) {
-  let sdk = createZapierSdkWithoutRegistry({
+  return createZapierSdkWithoutRegistry({
     debug: options.debug,
     eventEmission: options.eventEmission
-  });
-  sdk = sdk.addPlugin(bundleCodePlugin);
-  sdk = sdk.addPlugin(getLoginConfigPathPlugin);
-  sdk = sdk.addPlugin(addPlugin);
-  sdk = sdk.addPlugin(mcpPlugin);
-  sdk = sdk.addPlugin(loginPlugin);
-  sdk = sdk.addPlugin(logoutPlugin);
-  const finalSdk = sdk.addPlugin(registryPlugin);
-  return finalSdk;
+  }).addPlugin(generateAppTypesPlugin).addPlugin(buildManifestPlugin).addPlugin(bundleCodePlugin).addPlugin(getLoginConfigPathPlugin).addPlugin(addPlugin).addPlugin(mcpPlugin).addPlugin(loginPlugin).addPlugin(logoutPlugin).addPlugin(registryPlugin);
 }
 
 export { buildCliCommandExecutedEvent, createZapierCliSdk };

package/dist/package.json

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