@zapier/zapier-sdk-cli 0.9.0 → 0.10.0

package/dist/cli.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import { z } from 'zod';
-import { createFunction, OutputPropertySchema, DEFAULT_CONFIG_PATH, createZapierSdkWithoutRegistry, registryPlugin, ZapierError, formatErrorMessage, isPositional, hasResolver, getResolutionOrderForParams, getResolver } from '@zapier/zapier-sdk';
+import { createFunction, OutputPropertySchema, DEFAULT_CONFIG_PATH, createZapierSdkWithoutRegistry, registryPlugin, ZapierError, formatErrorMessage, isPositional } from '@zapier/zapier-sdk';
 import inquirer from 'inquirer';
 import chalk3 from 'chalk';
 import util from 'util';
@@ -19,12 +19,45 @@ import { resolve, join } from 'path';
 import * as ts from 'typescript';
 import { mkdir, writeFile, access } from 'fs/promises';
 
+function getLocalResolutionOrder(paramName, resolvers, resolved = /* @__PURE__ */ new Set()) {
+  const resolver = resolvers[paramName];
+  if (!resolver || resolver.type === "static") {
+    return [paramName];
+  }
+  const order = [];
+  if ("depends" in resolver && resolver.depends) {
+    for (const dependency of resolver.depends) {
+      if (!resolved.has(dependency)) {
+        order.push(...getLocalResolutionOrder(dependency, resolvers, resolved));
+        resolved.add(dependency);
+      }
+    }
+  }
+  if (!resolved.has(paramName)) {
+    order.push(paramName);
+    resolved.add(paramName);
+  }
+  return order;
+}
+function getLocalResolutionOrderForParams(paramNames, resolvers) {
+  const resolved = /* @__PURE__ */ new Set();
+  const order = [];
+  for (const paramName of paramNames) {
+    const paramOrder = getLocalResolutionOrder(paramName, resolvers, resolved);
+    for (const param of paramOrder) {
+      if (!order.includes(param)) {
+        order.push(param);
+      }
+    }
+  }
+  return order;
+}
 var SchemaParameterResolver = class {
-  async resolveParameters(schema, providedParams, sdk2) {
+  async resolveParameters(schema, providedParams, sdk2, functionName) {
     const parseResult = schema.safeParse(providedParams);
     const allParams = this.extractParametersFromSchema(schema);
     const resolvableParams = allParams.filter(
-      (param) => hasResolver(param.name)
+      (param) => this.hasResolver(param.name, sdk2, functionName)
     );
     const missingResolvable = resolvableParams.filter((param) => {
       const hasValue = this.getNestedValue(providedParams, param.path) !== void 0;
@@ -60,11 +93,16 @@ var SchemaParameterResolver = class {
     const context = {
       sdk: sdk2,
       currentParams: providedParams,
-      resolvedParams
+      resolvedParams,
+      functionName
     };
+    const localResolvers = this.getLocalResolvers(sdk2, functionName);
     if (functionallyRequired.length > 0) {
       const requiredParamNames = functionallyRequired.map((p) => p.name);
-      const requiredResolutionOrder = getResolutionOrderForParams(requiredParamNames);
+      const requiredResolutionOrder = getLocalResolutionOrderForParams(
+        requiredParamNames,
+        localResolvers
+      );
       const orderedRequiredParams = requiredResolutionOrder.map((paramName) => {
         let param = functionallyRequired.find((p) => p.name === paramName);
         if (!param) {
@@ -77,7 +115,11 @@ var SchemaParameterResolver = class {
       }).filter((param) => param !== void 0);
       for (const param of orderedRequiredParams) {
         try {
-          const value = await this.resolveParameter(param, context);
+          const value = await this.resolveParameter(
+            param,
+            context,
+            functionName
+          );
           this.setNestedValue(resolvedParams, param.path, value);
           context.resolvedParams = resolvedParams;
         } catch (error) {
@@ -104,11 +146,18 @@ var SchemaParameterResolver = class {
     }
     if (alwaysPrompt.length > 0) {
       const alwaysPromptNames = alwaysPrompt.map((p) => p.name);
-      const alwaysPromptResolutionOrder = getResolutionOrderForParams(alwaysPromptNames);
+      const alwaysPromptResolutionOrder = getLocalResolutionOrderForParams(
+        alwaysPromptNames,
+        localResolvers
+      );
       const orderedAlwaysPromptParams = alwaysPromptResolutionOrder.map((paramName) => alwaysPrompt.find((p) => p.name === paramName)).filter((param) => param !== void 0);
       for (const param of orderedAlwaysPromptParams) {
         try {
-          const value = await this.resolveParameter(param, context);
+          const value = await this.resolveParameter(
+            param,
+            context,
+            functionName
+          );
           this.setNestedValue(resolvedParams, param.path, value);
           context.resolvedParams = resolvedParams;
         } catch (error) {
@@ -132,11 +181,18 @@ var SchemaParameterResolver = class {
       ]);
       if (shouldResolveOptional.resolveOptional) {
         const optionalParamNames = trulyOptional.map((p) => p.name);
-        const optionalResolutionOrder = getResolutionOrderForParams(optionalParamNames);
+        const optionalResolutionOrder = getLocalResolutionOrderForParams(
+          optionalParamNames,
+          localResolvers
+        );
         const orderedOptionalParams = optionalResolutionOrder.map((paramName) => trulyOptional.find((p) => p.name === paramName)).filter((param) => param !== void 0);
         for (const param of orderedOptionalParams) {
           try {
-            const value = await this.resolveParameter(param, context);
+            const value = await this.resolveParameter(
+              param,
+              context,
+              functionName
+            );
             this.setNestedValue(resolvedParams, param.path, value);
             context.resolvedParams = resolvedParams;
           } catch (error) {
@@ -195,8 +251,8 @@ var SchemaParameterResolver = class {
       isRequired
     };
   }
-  async resolveParameter(param, context) {
-    const resolver = getResolver(param.name);
+  async resolveParameter(param, context, functionName) {
+    const resolver = this.getResolver(param.name, context.sdk, functionName);
     if (!resolver) {
       throw new Error(`No resolver found for parameter: ${param.name}`);
     }
@@ -281,10 +337,10 @@ var SchemaParameterResolver = class {
         break;
       }
       const newRequiredFields = newFields.filter(
-        (field) => field.required
+        (field) => field.is_required
       );
       const newOptionalFields = newFields.filter(
-        (field) => !field.required
+        (field) => !field.is_required
       );
       if (newRequiredFields.length > 0) {
         console.log(
@@ -371,7 +427,7 @@ Optional fields:`));
     const fieldPrompt = {
       type: fieldObj.type === "boolean" ? "confirm" : "input",
       name: fieldObj.key,
-      message: `${fieldObj.label || fieldObj.key}${fieldObj.required ? " (required)" : " (optional)"}:`
+      message: `${fieldObj.label || fieldObj.key}${fieldObj.is_required ? " (required)" : " (optional)"}:`
     };
     if (fieldObj.helpText) {
       fieldPrompt.prefix = chalk3.gray(`\u2139 ${fieldObj.helpText}
@@ -396,7 +452,7 @@ Optional fields:`));
       const answer = await inquirer.prompt([fieldPrompt]);
       if (answer[fieldObj.key] !== void 0 && answer[fieldObj.key] !== "") {
         inputs[fieldObj.key] = answer[fieldObj.key];
-      } else if (fieldObj.required) {
+      } else if (fieldObj.is_required) {
         throw new Error(`Required field ${fieldObj.key} cannot be empty`);
       }
     } catch (error) {
@@ -411,6 +467,40 @@ Optional fields:`));
     const errorObj = error;
     return errorObj?.name === "ExitPromptError" || errorObj?.message?.includes("User force closed") || errorObj?.isTTYError === true;
   }
+  hasResolver(paramName, sdk2, functionName) {
+    if (functionName && typeof sdk2.getRegistry === "function") {
+      const registry = sdk2.getRegistry();
+      const functionInfo = registry.functions.find(
+        (f) => f.name === functionName
+      );
+      if (functionInfo && functionInfo.resolvers?.[paramName]) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getResolver(paramName, sdk2, functionName) {
+    if (functionName && typeof sdk2.getRegistry === "function") {
+      const registry = sdk2.getRegistry();
+      const functionInfo = registry.functions.find(
+        (f) => f.name === functionName
+      );
+      if (functionInfo && functionInfo.resolvers?.[paramName]) {
+        return functionInfo.resolvers[paramName];
+      }
+    }
+    return null;
+  }
+  getLocalResolvers(sdk2, functionName) {
+    if (!functionName || typeof sdk2.getRegistry !== "function") {
+      return {};
+    }
+    const registry = sdk2.getRegistry();
+    const functionInfo = registry.functions.find(
+      (f) => f.name === functionName
+    );
+    return functionInfo?.resolvers || {};
+  }
 };
 function getFormatMetadata(schema) {
   return schema?._def?.formatMeta;
@@ -418,8 +508,16 @@ function getFormatMetadata(schema) {
 function getOutputSchema(schema) {
   return schema?._def?.outputSchema;
 }
-function formatItemsFromSchema(inputSchema, items, startingNumber = 0) {
-  const outputSchema = getOutputSchema(inputSchema);
+function formatJsonOutput(data) {
+  if (data === void 0) {
+    return;
+  }
+  console.log(
+    util.inspect(data, { colors: true, depth: null, breakLength: 80 })
+  );
+}
+function formatItemsFromSchema(functionInfo, items, startingNumber = 0) {
+  const outputSchema = functionInfo.outputSchema || getOutputSchema(functionInfo.inputSchema);
   if (!outputSchema) {
     formatItemsGeneric(items, startingNumber);
     return;
@@ -430,16 +528,26 @@ function formatItemsFromSchema(inputSchema, items, startingNumber = 0) {
     return;
   }
   items.forEach((item, index) => {
-    formatSingleItem(item, startingNumber + index, formatMeta);
+    const formatted = formatMeta.format(item);
+    formatSingleItem(formatted, startingNumber + index);
   });
 }
-function formatSingleItem(item, itemNumber, formatMeta) {
-  const formatted = formatMeta.format(item);
+function formatSingleItem(formatted, itemNumber) {
   let titleLine = `${chalk3.gray(`${itemNumber + 1}.`)} ${chalk3.cyan(formatted.title)}`;
-  if (formatted.subtitle) {
-    titleLine += ` ${chalk3.gray(formatted.subtitle)}`;
+  if (formatted.id) {
+    titleLine += ` ${chalk3.gray(`(ID: ${formatted.id})`)}`;
+  } else if (formatted.key) {
+    titleLine += ` ${chalk3.gray(`(${formatted.key})`)}`;
   }
   console.log(titleLine);
+  if (formatted.description) {
+    console.log(`   ${chalk3.dim(formatted.description)}`);
+  }
+  if (formatted.data !== void 0) {
+    formatJsonOutput(formatted.data);
+    console.log();
+    return;
+  }
   for (const detail of formatted.details) {
     const styledText = applyStyle(detail.text, detail.style);
     console.log(`   ${styledText}`);
@@ -461,40 +569,36 @@ function applyStyle(value, style) {
       return chalk3.blue(value);
   }
 }
+function convertGenericItemToFormattedItem(item) {
+  const itemObj = item;
+  return {
+    title: itemObj.title || itemObj.name || itemObj.key || itemObj.id || "Item",
+    id: itemObj.id,
+    key: itemObj.key,
+    description: itemObj.description,
+    details: []
+  };
+}
 function formatItemsGeneric(items, startingNumber = 0) {
   items.forEach((item, index) => {
-    const itemObj = item;
-    const name = itemObj.title || itemObj.name || itemObj.key || itemObj.id || "Item";
-    console.log(
-      `${chalk3.gray(`${startingNumber + index + 1}.`)} ${chalk3.cyan(name)}`
-    );
-    if (itemObj.description) {
-      console.log(`   ${chalk3.dim(itemObj.description)}`);
-    }
-    console.log();
+    const formatted = convertGenericItemToFormattedItem(item);
+    formatSingleItem(formatted, startingNumber + index);
   });
 }
-function formatJsonOutput(data) {
-  if (data === void 0) {
-    return;
-  }
-  if (data && typeof data === "object" && !Array.isArray(data) && (data.success !== void 0 || data.id || data.status)) {
-    console.log(chalk3.green("\u2705 Action completed successfully!\n"));
-  }
-  console.log(
-    util.inspect(data, { colors: true, depth: null, breakLength: 80 })
-  );
-}
-function analyzeZodSchema(schema) {
+function analyzeZodSchema(schema, functionInfo) {
   const parameters = [];
   if (schema._def && schema._def.typeName === "ZodEffects") {
     const innerSchema = schema._def.schema;
-    return analyzeZodSchema(innerSchema);
+    return analyzeZodSchema(innerSchema, functionInfo);
   }
   if (schema instanceof z.ZodObject) {
     const shape = schema.shape;
     for (const [key, fieldSchema] of Object.entries(shape)) {
-      const param = analyzeZodField(key, fieldSchema);
+      const param = analyzeZodField(
+        key,
+        fieldSchema,
+        functionInfo
+      );
       if (param) {
         parameters.push(param);
       }
@@ -502,7 +606,7 @@ function analyzeZodSchema(schema) {
   }
   return parameters;
 }
-function analyzeZodField(name, schema) {
+function analyzeZodField(name, schema, functionInfo) {
   let baseSchema = schema;
   let required = true;
   let defaultValue = void 0;
@@ -536,6 +640,10 @@ function analyzeZodField(name, schema) {
   } else if (baseSchema instanceof z.ZodRecord) {
     paramType = "string";
   }
+  let paramHasResolver = false;
+  if (functionInfo?.resolvers?.[name]) {
+    paramHasResolver = true;
+  }
   return {
     name,
     type: paramType,
@@ -543,7 +651,7 @@ function analyzeZodField(name, schema) {
     description: schema.description,
     default: defaultValue,
     choices,
-    hasResolver: hasResolver(name),
+    hasResolver: paramHasResolver,
     isPositional: isPositional(schema)
   };
 }
@@ -565,12 +673,7 @@ function generateCliCommands(program2, sdk2) {
       return;
     }
     const cliCommandName = methodNameToCliCommand(fnInfo.name);
-    const config = createCommandConfig(
-      cliCommandName,
-      fnInfo.name,
-      fnInfo.inputSchema,
-      sdk2
-    );
+    const config = createCommandConfig(cliCommandName, fnInfo, sdk2);
     addCommand(program2, cliCommandName, config);
   });
   program2.configureHelp({
@@ -634,14 +737,15 @@ function generateCliCommands(program2, sdk2) {
     }
   });
 }
-function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk2) {
-  const parameters = analyzeZodSchema(schema);
+function createCommandConfig(cliCommandName, functionInfo, sdk2) {
+  const schema = functionInfo.inputSchema;
+  const parameters = analyzeZodSchema(schema, functionInfo);
   const description = schema.description || `${cliCommandName} command`;
   const handler = async (...args) => {
     try {
       const commandObj = args[args.length - 1];
       const options = commandObj.opts();
-      const isListCommand = cliCommandName.startsWith("list-");
+      const isListCommand = functionInfo.type === "list";
       const hasPaginationParams = parameters.some(
         (p) => p.name === "maxItems" || p.name === "pageSize"
       );
@@ -656,21 +760,22 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk2) {
       const resolvedParams = await resolver.resolveParameters(
         schema,
         rawParams,
-        sdk2
+        sdk2,
+        functionInfo.name
       );
       if (isListCommand && hasPaginationParams && !shouldUseJson && !hasUserSpecifiedMaxItems) {
         const sdkObj = sdk2;
-        const sdkIterator = sdkObj[sdkMethodName](resolvedParams);
+        const sdkIterator = sdkObj[functionInfo.name](resolvedParams);
         await handlePaginatedListWithAsyncIteration(
-          sdkMethodName,
+          functionInfo.name,
           sdkIterator,
-          schema
+          functionInfo
         );
       } else {
         const hasOutputFile = resolvedParams.output;
         if (hasOutputFile) {
           const sdkObj2 = sdk2;
-          await sdkObj2[sdkMethodName](resolvedParams);
+          await sdkObj2[functionInfo.name](resolvedParams);
           console.log(
             chalk3.green(`\u2705 ${cliCommandName} completed successfully!`)
           );
@@ -678,7 +783,7 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk2) {
           return;
         }
         const sdkObj = sdk2;
-        const result = await sdkObj[sdkMethodName](resolvedParams);
+        const result = await sdkObj[functionInfo.name](resolvedParams);
         const items = result?.data ? result.data : result;
         if (shouldUseJson) {
           console.log(JSON.stringify(items, null, 2));
@@ -688,8 +793,7 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk2) {
             resolvedParams.maxItems,
             hasUserSpecifiedMaxItems,
             shouldUseJson,
-            schema,
-            sdkMethodName
+            functionInfo
           );
         } else {
           formatJsonOutput(items);
@@ -810,6 +914,9 @@ function convertCliArgsToSdkParams(parameters, positionalArgs, options) {
   return sdkParams;
 }
 function convertValue(value, type) {
+  if (value === void 0) {
+    return void 0;
+  }
   switch (type) {
     case "number":
       return Number(value);
@@ -829,12 +936,14 @@ function convertValue(value, type) {
       return value;
   }
 }
-async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, schema) {
-  const itemName = getItemNameFromMethod(sdkMethodName);
+async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, functionInfo) {
+  const itemName = getItemNameFromMethod(functionInfo);
   let totalShown = 0;
   let pageCount = 0;
-  console.log(chalk3.blue(`\u{1F4CB} ${getListTitleFromMethod(sdkMethodName)}
-`));
+  console.log(
+    chalk3.blue(`\u{1F4CB} ${getListTitleFromMethod(sdkMethodName, functionInfo)}
+`)
+  );
   try {
     for await (const page of sdkResult) {
       const items = page.data || page;
@@ -853,12 +962,14 @@ async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, s
       if (pageCount > 1) {
         console.clear();
         console.log(
-          chalk3.blue(`\u{1F4CB} ${getListTitleFromMethod(sdkMethodName)}
-`)
+          chalk3.blue(
+            `\u{1F4CB} ${getListTitleFromMethod(sdkMethodName, functionInfo)}
+`
+          )
         );
       }
-      if (schema) {
-        formatItemsFromSchema(schema, items, totalShown);
+      if (functionInfo) {
+        formatItemsFromSchema(functionInfo, items, totalShown);
       } else {
         formatItemsGeneric2(items, totalShown);
       }
@@ -894,8 +1005,8 @@ async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, s
         console.log(chalk3.yellow(`No ${itemName} found.`));
         return;
       }
-      if (schema) {
-        formatItemsFromSchema(schema, items, 0);
+      if (functionInfo) {
+        formatItemsFromSchema(functionInfo, items, 0);
       } else {
         formatItemsGeneric2(items, 0);
       }
@@ -906,7 +1017,7 @@ async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, s
     }
   }
 }
-function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxItems, useRawJson, schema, methodName) {
+function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxItems, useRawJson, functionInfo) {
   if (!Array.isArray(result)) {
     if (useRawJson) {
       console.log(JSON.stringify(result, null, 2));
@@ -919,7 +1030,7 @@ function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxIt
     console.log(JSON.stringify(result, null, 2));
     return;
   }
-  const itemName = methodName ? getItemNameFromMethod(methodName) : "items";
+  const itemName = functionInfo ? getItemNameFromMethod(functionInfo) : "items";
   if (result.length === 0) {
     console.log(chalk3.yellow(`No ${itemName} found.`));
     return;
@@ -927,8 +1038,8 @@ function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxIt
   console.log(chalk3.green(`
 \u2705 Found ${result.length} ${itemName}:
 `));
-  if (schema) {
-    formatItemsFromSchema(schema, result);
+  if (functionInfo) {
+    formatItemsFromSchema(functionInfo, result);
   } else {
     formatItemsGeneric2(result);
   }
@@ -957,18 +1068,17 @@ function formatItemsGeneric2(items, startingNumber = 0) {
     console.log();
   });
 }
-function getItemNameFromMethod(methodName) {
-  const listMatch = methodName.match(/^list(.+)$/);
-  if (listMatch) {
-    return listMatch[1].toLowerCase();
+function getItemNameFromMethod(functionInfo) {
+  if (functionInfo.itemType) {
+    return `${functionInfo.itemType} items`;
   }
   return "items";
 }
-function getListTitleFromMethod(methodName) {
-  const itemName = getItemNameFromMethod(methodName);
-  if (itemName === "items") return "Available Items";
-  const capitalized = itemName.charAt(0).toUpperCase() + itemName.slice(1);
-  return `Available ${capitalized}`;
+function getListTitleFromMethod(methodName, functionInfo) {
+  if (functionInfo.itemType) {
+    return `Available ${functionInfo.itemType} items`;
+  }
+  return `${methodName} items`;
 }
 
 // src/utils/constants.ts
@@ -1998,26 +2108,25 @@ var addPlugin = ({ sdk: sdk2, context }) => {
       console.log(`\u{1F510} Found ${authentications.length} authentication(s)`);
     }
     for (const app of apps) {
-      console.log(`\u{1F4E6} Adding ${app.key}...`);
+      const appSlugAndKey = app.slug ? `${app.slug} (${app.key})` : app.key;
+      console.log(`\u{1F4E6} Adding ${appSlugAndKey}...`);
       try {
-        const currentImplementationId = app.current_implementation_id;
-        const [implementationName, version] = currentImplementationId.split("@");
-        if (!implementationName || !version) {
+        if (!app.version) {
           console.warn(
-            `\u26A0\uFE0F Invalid implementation ID format for '${app.key}': ${currentImplementationId}. Expected format: <implementationName>@<version>. Skipping...`
+            `\u26A0\uFE0F Invalid implementation ID format for '${appSlugAndKey}': ${app.implementation_id}. Expected format: <implementationName>@<version>. Skipping...`
           );
           continue;
         }
         const [manifestKey] = await context.updateManifestEntry(
           app.key,
           {
-            implementationName,
-            version
+            implementationName: app.key,
+            version: app.version
           },
           configPath
         );
         console.log(
-          `\u{1F4DD} Locked ${app.key} to ${implementationName}@${version} using key '${manifestKey}'`
+          `\u{1F4DD} Locked ${appSlugAndKey} to ${app.key}@${app.version} using key '${manifestKey}'`
         );
         let authenticationId;
         if (authentications.length > 0) {
@@ -2027,10 +2136,12 @@ var addPlugin = ({ sdk: sdk2, context }) => {
           if (matchingAuth) {
             authenticationId = matchingAuth.id;
             console.log(
-              `\u{1F510} Using authentication ${authenticationId} (${matchingAuth.title}) for ${app.key}`
+              `\u{1F510} Using authentication ${authenticationId} (${matchingAuth.title}) for ${appSlugAndKey}`
             );
           } else {
-            console.warn(`\u26A0\uFE0F No matching authentication found for ${app.key}`);
+            console.warn(
+              `\u26A0\uFE0F No matching authentication found for ${appSlugAndKey}`
+            );
           }
         }
         const typesPath = join(resolvedTypesOutput, `${manifestKey}.d.ts`);
@@ -2044,10 +2155,12 @@ var addPlugin = ({ sdk: sdk2, context }) => {
           await writeFile(typesPath, typeDefinitions, "utf8");
           console.log(`\u{1F527} Generated types for ${manifestKey} at ${typesPath}`);
         } catch (error) {
-          console.warn(`\u26A0\uFE0F Failed to generate types for ${app.key}: ${error}`);
+          console.warn(
+            `\u26A0\uFE0F Failed to generate types for ${appSlugAndKey}: ${error}`
+          );
         }
       } catch (error) {
-        console.warn(`\u26A0\uFE0F Failed to process ${app.key}: ${error}`);
+        console.warn(`\u26A0\uFE0F Failed to process ${appSlugAndKey}: ${error}`);
       }
     }
     console.log(`\u2705 Added ${apps.length} app(s) to manifest`);
@@ -2082,7 +2195,7 @@ function createZapierCliSdk(options = {}) {
 
 // package.json
 var package_default = {
-  version: "0.9.0"};
+  version: "0.10.0"};
 
 // src/cli.ts
 var program = new Command();

package/dist/index.cjs

@@ -1075,26 +1075,25 @@ var addPlugin = ({ sdk, context }) => {
       console.log(`\u{1F510} Found ${authentications.length} authentication(s)`);
     }
     for (const app of apps) {
-      console.log(`\u{1F4E6} Adding ${app.key}...`);
+      const appSlugAndKey = app.slug ? `${app.slug} (${app.key})` : app.key;
+      console.log(`\u{1F4E6} Adding ${appSlugAndKey}...`);
       try {
-        const currentImplementationId = app.current_implementation_id;
-        const [implementationName, version] = currentImplementationId.split("@");
-        if (!implementationName || !version) {
+        if (!app.version) {
           console.warn(
-            `\u26A0\uFE0F Invalid implementation ID format for '${app.key}': ${currentImplementationId}. Expected format: <implementationName>@<version>. Skipping...`
+            `\u26A0\uFE0F Invalid implementation ID format for '${appSlugAndKey}': ${app.implementation_id}. Expected format: <implementationName>@<version>. Skipping...`
           );
           continue;
         }
         const [manifestKey] = await context.updateManifestEntry(
           app.key,
           {
-            implementationName,
-            version
+            implementationName: app.key,
+            version: app.version
           },
           configPath
         );
         console.log(
-          `\u{1F4DD} Locked ${app.key} to ${implementationName}@${version} using key '${manifestKey}'`
+          `\u{1F4DD} Locked ${appSlugAndKey} to ${app.key}@${app.version} using key '${manifestKey}'`
         );
         let authenticationId;
         if (authentications.length > 0) {
@@ -1104,10 +1103,12 @@ var addPlugin = ({ sdk, context }) => {
           if (matchingAuth) {
             authenticationId = matchingAuth.id;
             console.log(
-              `\u{1F510} Using authentication ${authenticationId} (${matchingAuth.title}) for ${app.key}`
+              `\u{1F510} Using authentication ${authenticationId} (${matchingAuth.title}) for ${appSlugAndKey}`
             );
           } else {
-            console.warn(`\u26A0\uFE0F No matching authentication found for ${app.key}`);
+            console.warn(
+              `\u26A0\uFE0F No matching authentication found for ${appSlugAndKey}`
+            );
           }
         }
         const typesPath = path.join(resolvedTypesOutput, `${manifestKey}.d.ts`);
@@ -1121,10 +1122,12 @@ var addPlugin = ({ sdk, context }) => {
           await promises.writeFile(typesPath, typeDefinitions, "utf8");
           console.log(`\u{1F527} Generated types for ${manifestKey} at ${typesPath}`);
         } catch (error) {
-          console.warn(`\u26A0\uFE0F Failed to generate types for ${app.key}: ${error}`);
+          console.warn(
+            `\u26A0\uFE0F Failed to generate types for ${appSlugAndKey}: ${error}`
+          );
         }
       } catch (error) {
-        console.warn(`\u26A0\uFE0F Failed to process ${app.key}: ${error}`);
+        console.warn(`\u26A0\uFE0F Failed to process ${appSlugAndKey}: ${error}`);
       }
     }
     console.log(`\u2705 Added ${apps.length} app(s) to manifest`);