@zapier/zapier-sdk-cli 0.9.0 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @zapier/zapier-sdk-cli
 
+## 0.10.0
+
+### Minor Changes
+
+- 3184903: No more global resolver registry, each plugin function has its own resolvers. Plugin function meta also stores output schema and some function type info to avoid some special case code for handling lists, documenting functions, etc. findFirstAuthentication throws an error to make all item functions consistent. Various other schema and output cleanup.
+
+### Patch Changes
+
+- Updated dependencies [3184903]
+  - @zapier/zapier-sdk@0.10.0
+  - @zapier/zapier-sdk-mcp@0.3.7
+
+## 0.9.1
+
+### Patch Changes
+
+- Updated dependencies [3cfed98]
+  - @zapier/zapier-sdk@0.9.1
+  - @zapier/zapier-sdk-mcp@0.3.6
+
 ## 0.9.0
 
 ### Minor Changes

package/dist/cli.cjs

@@ -52,12 +52,45 @@ var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var ts__namespace = /*#__PURE__*/_interopNamespace(ts);
 
+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) => zapierSdk.hasResolver(param.name)
+      (param) => this.hasResolver(param.name, sdk2, functionName)
     );
     const missingResolvable = resolvableParams.filter((param) => {
       const hasValue = this.getNestedValue(providedParams, param.path) !== void 0;
@@ -93,11 +126,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 = zapierSdk.getResolutionOrderForParams(requiredParamNames);
+      const requiredResolutionOrder = getLocalResolutionOrderForParams(
+        requiredParamNames,
+        localResolvers
+      );
       const orderedRequiredParams = requiredResolutionOrder.map((paramName) => {
         let param = functionallyRequired.find((p) => p.name === paramName);
         if (!param) {
@@ -110,7 +148,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) {
@@ -137,11 +179,18 @@ var SchemaParameterResolver = class {
     }
     if (alwaysPrompt.length > 0) {
       const alwaysPromptNames = alwaysPrompt.map((p) => p.name);
-      const alwaysPromptResolutionOrder = zapierSdk.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) {
@@ -165,11 +214,18 @@ var SchemaParameterResolver = class {
       ]);
       if (shouldResolveOptional.resolveOptional) {
         const optionalParamNames = trulyOptional.map((p) => p.name);
-        const optionalResolutionOrder = zapierSdk.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) {
@@ -228,8 +284,8 @@ var SchemaParameterResolver = class {
       isRequired
     };
   }
-  async resolveParameter(param, context) {
-    const resolver = zapierSdk.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}`);
     }
@@ -314,10 +370,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(
@@ -404,7 +460,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__default.default.gray(`\u2139 ${fieldObj.helpText}
@@ -429,7 +485,7 @@ Optional fields:`));
       const answer = await inquirer__default.default.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) {
@@ -444,6 +500,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;
@@ -451,8 +541,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__default.default.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;
@@ -463,16 +561,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__default.default.gray(`${itemNumber + 1}.`)} ${chalk3__default.default.cyan(formatted.title)}`;
-  if (formatted.subtitle) {
-    titleLine += ` ${chalk3__default.default.gray(formatted.subtitle)}`;
+  if (formatted.id) {
+    titleLine += ` ${chalk3__default.default.gray(`(ID: ${formatted.id})`)}`;
+  } else if (formatted.key) {
+    titleLine += ` ${chalk3__default.default.gray(`(${formatted.key})`)}`;
   }
   console.log(titleLine);
+  if (formatted.description) {
+    console.log(`   ${chalk3__default.default.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}`);
@@ -494,40 +602,36 @@ function applyStyle(value, style) {
       return chalk3__default.default.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__default.default.gray(`${startingNumber + index + 1}.`)} ${chalk3__default.default.cyan(name)}`
-    );
-    if (itemObj.description) {
-      console.log(`   ${chalk3__default.default.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__default.default.green("\u2705 Action completed successfully!\n"));
-  }
-  console.log(
-    util__default.default.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 zod.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);
       }
@@ -535,7 +639,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;
@@ -569,6 +673,10 @@ function analyzeZodField(name, schema) {
   } else if (baseSchema instanceof zod.z.ZodRecord) {
     paramType = "string";
   }
+  let paramHasResolver = false;
+  if (functionInfo?.resolvers?.[name]) {
+    paramHasResolver = true;
+  }
   return {
     name,
     type: paramType,
@@ -576,7 +684,7 @@ function analyzeZodField(name, schema) {
     description: schema.description,
     default: defaultValue,
     choices,
-    hasResolver: zapierSdk.hasResolver(name),
+    hasResolver: paramHasResolver,
     isPositional: zapierSdk.isPositional(schema)
   };
 }
@@ -598,12 +706,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({
@@ -667,14 +770,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"
       );
@@ -689,21 +793,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__default.default.green(`\u2705 ${cliCommandName} completed successfully!`)
           );
@@ -711,7 +816,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));
@@ -721,8 +826,7 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk2) {
             resolvedParams.maxItems,
             hasUserSpecifiedMaxItems,
             shouldUseJson,
-            schema,
-            sdkMethodName
+            functionInfo
           );
         } else {
           formatJsonOutput(items);
@@ -843,6 +947,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);
@@ -862,12 +969,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__default.default.blue(`\u{1F4CB} ${getListTitleFromMethod(sdkMethodName)}
-`));
+  console.log(
+    chalk3__default.default.blue(`\u{1F4CB} ${getListTitleFromMethod(sdkMethodName, functionInfo)}
+`)
+  );
   try {
     for await (const page of sdkResult) {
       const items = page.data || page;
@@ -886,12 +995,14 @@ async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, s
       if (pageCount > 1) {
         console.clear();
         console.log(
-          chalk3__default.default.blue(`\u{1F4CB} ${getListTitleFromMethod(sdkMethodName)}
-`)
+          chalk3__default.default.blue(
+            `\u{1F4CB} ${getListTitleFromMethod(sdkMethodName, functionInfo)}
+`
+          )
         );
       }
-      if (schema) {
-        formatItemsFromSchema(schema, items, totalShown);
+      if (functionInfo) {
+        formatItemsFromSchema(functionInfo, items, totalShown);
       } else {
         formatItemsGeneric2(items, totalShown);
       }
@@ -927,8 +1038,8 @@ async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, s
         console.log(chalk3__default.default.yellow(`No ${itemName} found.`));
         return;
       }
-      if (schema) {
-        formatItemsFromSchema(schema, items, 0);
+      if (functionInfo) {
+        formatItemsFromSchema(functionInfo, items, 0);
       } else {
         formatItemsGeneric2(items, 0);
       }
@@ -939,7 +1050,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));
@@ -952,7 +1063,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__default.default.yellow(`No ${itemName} found.`));
     return;
@@ -960,8 +1071,8 @@ function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxIt
   console.log(chalk3__default.default.green(`
 \u2705 Found ${result.length} ${itemName}:
 `));
-  if (schema) {
-    formatItemsFromSchema(schema, result);
+  if (functionInfo) {
+    formatItemsFromSchema(functionInfo, result);
   } else {
     formatItemsGeneric2(result);
   }
@@ -990,18 +1101,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
@@ -2031,26 +2141,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) {
@@ -2060,10 +2169,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 = path.join(resolvedTypesOutput, `${manifestKey}.d.ts`);
@@ -2077,10 +2188,12 @@ var addPlugin = ({ sdk: sdk2, 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`);
@@ -2115,7 +2228,7 @@ function createZapierCliSdk(options = {}) {
 
 // package.json
 var package_default = {
-  version: "0.9.0"};
+  version: "0.10.0"};
 
 // src/cli.ts
 var program = new commander.Command();