@zapier/zapier-sdk-cli 0.13.4 → 0.13.6

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @zapier/zapier-sdk-cli
 
+## 0.13.6
+
+### Patch Changes
+
+- 05ce6f7: 1. Extracted manifest creation and type generation into flexible base plugins that can be used by other consumers. 2. Updated updateManifestEntry function from base SDK to allow manipulating manifest as file or as JSON
+- Updated dependencies [05ce6f7]
+  - @zapier/zapier-sdk@0.13.5
+  - @zapier/zapier-sdk-mcp@0.3.18
+
+## 0.13.5
+
+### Patch Changes
+
+- 7184f27: Move typescript package from devDependencies to dependencies since it is needed at runtime for the CLI's add command.
+
 ## 0.13.4
 
 ### Patch Changes

package/README.md

@@ -28,7 +28,9 @@
   - [`request`](#request)
 - [Utilities](#utilities)
   - [`add`](#add)
+  - [`build-manifest`](#build-manifest)
   - [`bundle-code`](#bundle-code)
+  - [`generate-app-types`](#generate-app-types)
   - [`get-login-config-path`](#get-login-config-path)
   - [`mcp`](#mcp)
 
@@ -384,6 +386,24 @@ Add apps with manifest locking and TypeScript type generation - updates .zapierr
 npx zapier-sdk add <app-keys> [--authentication-ids] [--config-path] [--types-output]
 ```
 
+#### `build-manifest`
+
+Build manifest entries for apps - can optionally write to disk or just return JSON
+
+**Options:**
+
+| Option          | Type      | Required | Default | Possible Values | Description                                                                                                  |
+| --------------- | --------- | -------- | ------- | --------------- | ------------------------------------------------------------------------------------------------------------ |
+| `<app-keys>`    | `array`   | ✅       | —       | —               | One or more app keys to build manifest entries for (e.g., 'slack', 'github', 'trello')                       |
+| `--skip-write`  | `boolean` | ❌       | —       | —               | If true, returns manifest entries without writing to disk. If false or omitted, writes to the manifest file. |
+| `--config-path` | `string`  | ❌       | —       | —               | Path to the manifest file. Only used when skipWrite is false or omitted.                                     |
+
+**Usage:**
+
+```bash
+npx zapier-sdk build-manifest <app-keys> [--skip-write] [--config-path]
+```
+
 #### `bundle-code`
 
 Bundle TypeScript code into executable JavaScript
@@ -405,6 +425,25 @@ Bundle TypeScript code into executable JavaScript
 npx zapier-sdk bundle-code <input> [--output] [--string] [--minify] [--target] [--cjs]
 ```
 
+#### `generate-app-types`
+
+Generate TypeScript type definitions for apps - can optionally write to disk or just return type strings
+
+**Options:**
+
+| Option                     | Type      | Required | Default | Possible Values | Description                                                                                        |
+| -------------------------- | --------- | -------- | ------- | --------------- | -------------------------------------------------------------------------------------------------- |
+| `<app-keys>`               | `array`   | ✅       | —       | —               | One or more app keys to generate types for (e.g., 'slack', 'github', 'trello')                     |
+| `--authentication-ids`     | `array`   | ❌       | —       | —               | Authentication IDs to use for type generation (e.g., ['123', '456'])                               |
+| `--skip-write`             | `boolean` | ❌       | —       | —               | If true, returns type definitions without writing to disk. If false or omitted, writes type files. |
+| `--types-output-directory` | `string`  | ❌       | —       | —               | Directory for TypeScript type files. Required when skipWrite is false or omitted.                  |
+
+**Usage:**
+
+```bash
+npx zapier-sdk generate-app-types <app-keys> [--authentication-ids] [--skip-write] [--types-output-directory]
+```
+
 #### `get-login-config-path`
 
 Show the path to the login configuration file

package/dist/cli.cjs

@@ -17,8 +17,8 @@ var zapierSdkMcp = require('@zapier/zapier-sdk-mcp');
 var esbuild = require('esbuild');
 var fs = require('fs');
 var path = require('path');
-var ts = require('typescript');
 var promises = require('fs/promises');
+var ts = require('typescript');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -1407,7 +1407,7 @@ var LoginSchema = zod.z.object({
 
 // package.json
 var package_default = {
-  version: "0.13.4"};
+  version: "0.13.6"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {
@@ -1695,6 +1695,146 @@ var AddSchema = zod.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 promises.access(candidate);
+      return path.join(candidate, "zapier", "apps");
+    } catch {
+    }
+  }
+  return "./zapier/apps/";
+}
+var addPlugin = ({ sdk: sdk2 }) => {
+  const add = zapierSdk.createFunction(async function add2(options) {
+    const {
+      appKeys,
+      authenticationIds,
+      configPath,
+      typesOutput = await detectTypesOutputDirectory()
+    } = options;
+    const resolvedTypesOutput = path.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 sdk2.buildManifest({
+      appKeys,
+      skipWrite: false,
+      configPath,
+      onProgress: handleManifestProgress
+    });
+    const typesResult = await sdk2.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 = zod.z.object({
+  appKeys: zod.z.array(zod.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: zod.z.array(zod.z.string()).optional().describe(
+    "Authentication IDs to use for type generation (e.g., ['123', '456'])"
+  ),
+  skipWrite: zod.z.boolean().optional().describe(
+    "If true, returns type definitions without writing to disk. If false or omitted, writes type files."
+  ),
+  typesOutputDirectory: zod.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__namespace.factory;
@@ -2263,69 +2403,92 @@ Usage:
     return Array.from(allKeys);
   }
 };
-async function detectTypesOutputDirectory() {
-  const candidates = ["src", "lib"];
-  for (const candidate of candidates) {
-    try {
-      await promises.access(candidate);
-      return path.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: sdk2, context }) => {
-  const add = zapierSdk.createFunction(async function add2(options) {
+var generateAppTypesPlugin = ({ sdk: sdk2 }) => {
+  const generateAppTypes = zapierSdk.createFunction(async function generateAppTypes2(options) {
     const {
       appKeys,
       authenticationIds,
-      configPath,
-      typesOutput = await detectTypesOutputDirectory()
+      skipWrite = false,
+      typesOutputDirectory,
+      onProgress
     } = options;
-    const resolvedTypesOutput = path.resolve(typesOutput);
-    await promises.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 = sdk2.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 = sdk2.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 promises.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) => {
@@ -2333,43 +2496,171 @@ var addPlugin = ({ sdk: sdk2, 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 = path.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: sdk2
           });
-          await promises.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 = path.join(typesOutputDirectory, `${manifestKey}.d.ts`);
+            await promises.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) {
+        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
+        });
+      }
+    }
+    return result;
+  }, GenerateAppTypesSchema);
+  return {
+    generateAppTypes,
+    context: {
+      meta: {
+        generateAppTypes: {
+          categories: ["utility"],
+          inputSchema: GenerateAppTypesSchema
         }
+      }
+    }
+  };
+};
+var BuildManifestSchema = zod.z.object({
+  appKeys: zod.z.array(zod.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: zod.z.boolean().optional().describe(
+    "If true, returns manifest entries without writing to disk. If false or omitted, writes to the manifest file."
+  ),
+  configPath: zod.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: sdk2, context }) => {
+  const buildManifest = zapierSdk.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 = sdk2.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) {
-        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);
+    result.manifest = updatedManifest;
+    return result;
+  }, BuildManifestSchema);
   return {
-    add,
+    buildManifest,
     context: {
       meta: {
-        add: {
+        buildManifest: {
           categories: ["utility"],
-          inputSchema: AddSchema
+          inputSchema: BuildManifestSchema
         }
       }
     }
@@ -2378,23 +2669,15 @@ var addPlugin = ({ sdk: sdk2, context }) => {
 
 // src/sdk.ts
 function createZapierCliSdk(options = {}) {
-  let sdk2 = zapierSdk.createZapierSdkWithoutRegistry({
+  return zapierSdk.createZapierSdkWithoutRegistry({
     debug: options.debug,
     eventEmission: options.eventEmission
-  });
-  sdk2 = sdk2.addPlugin(bundleCodePlugin);
-  sdk2 = sdk2.addPlugin(getLoginConfigPathPlugin);
-  sdk2 = sdk2.addPlugin(addPlugin);
-  sdk2 = sdk2.addPlugin(mcpPlugin);
-  sdk2 = sdk2.addPlugin(loginPlugin);
-  sdk2 = sdk2.addPlugin(logoutPlugin);
-  const finalSdk = sdk2.addPlugin(zapierSdk.registryPlugin);
-  return finalSdk;
+  }).addPlugin(generateAppTypesPlugin).addPlugin(buildManifestPlugin).addPlugin(bundleCodePlugin).addPlugin(getLoginConfigPathPlugin).addPlugin(addPlugin).addPlugin(mcpPlugin).addPlugin(loginPlugin).addPlugin(logoutPlugin).addPlugin(zapierSdk.registryPlugin);
 }
 
 // package.json with { type: 'json' }
 var package_default2 = {
-  version: "0.13.4"};
+  version: "0.13.6"};
 
 // src/cli.ts
 var program = new commander.Command();