@zapier/zapier-sdk-cli 0.9.0 → 0.11.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}`);
     }
@@ -247,7 +303,7 @@ var SchemaParameterResolver = class {
     const inputs = {};
     let processedFieldKeys = /* @__PURE__ */ new Set();
     let iteration = 0;
-    const maxIterations = 5;
+    const maxIterations = 10;
     while (iteration < maxIterations) {
       iteration++;
       const updatedContext = {
@@ -262,11 +318,11 @@ var SchemaParameterResolver = class {
           `Fetching input fields for ${param.name}${iteration > 1 ? ` (iteration ${iteration})` : ""}...`
         )
       );
-      const fields = await typedResolver.fetch(
+      const rootFieldItems = await typedResolver.fetch(
         updatedContext.sdk,
         updatedContext.resolvedParams
       );
-      if (!fields || fields.length === 0) {
+      if (!rootFieldItems || rootFieldItems.length === 0) {
         if (iteration === 1) {
           console.log(
             chalk3.yellow(`No input fields required for this action.`)
@@ -274,47 +330,125 @@ var SchemaParameterResolver = class {
         }
         break;
       }
-      const newFields = fields.filter(
-        (field) => !(field.key && processedFieldKeys.has(field.key))
+      const fieldStats = await this.processFieldItems(
+        rootFieldItems,
+        inputs,
+        processedFieldKeys,
+        [],
+        iteration
       );
-      if (newFields.length === 0) {
+      if (fieldStats.newRequired === 0 && fieldStats.newOptional === 0) {
         break;
       }
-      const newRequiredFields = newFields.filter(
-        (field) => field.required
-      );
-      const newOptionalFields = newFields.filter(
-        (field) => !field.required
+      if (fieldStats.newRequired === 0 && fieldStats.optionalSkipped) {
+        break;
+      }
+    }
+    if (iteration >= maxIterations) {
+      console.log(
+        chalk3.yellow(
+          `
+\u26A0\uFE0F  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`
+        )
       );
-      if (newRequiredFields.length > 0) {
+    }
+    return inputs;
+  }
+  /**
+   * Recursively processes fieldsets and their fields, maintaining natural structure
+   * and creating nested inputs as needed (e.g., fieldset "foo" becomes inputs.foo = [{}])
+   */
+  async processFieldItems(items, targetInputs, processedFieldKeys, fieldsetPath = [], iteration = 1) {
+    let newRequiredCount = 0;
+    let newOptionalCount = 0;
+    let optionalSkipped = false;
+    for (const item of items) {
+      const typedItem = item;
+      if (typedItem.type === "fieldset" && typedItem.fields && typedItem.key) {
+        const fieldsetTitle = typedItem.title || typedItem.key;
+        const pathDisplay = fieldsetPath.length > 0 ? ` (in ${fieldsetPath.join(" > ")})` : "";
         console.log(
-          chalk3.blue(
+          chalk3.cyan(
             `
-\u{1F4DD} Please provide values for the following ${iteration === 1 ? "" : "additional "}input fields:`
+\u{1F4C1} Processing fieldset: ${fieldsetTitle}${pathDisplay}`
           )
         );
-        for (const field of newRequiredFields) {
-          await this.promptForField(field, inputs);
-          processedFieldKeys.add(field.key);
+        if (!targetInputs[typedItem.key]) {
+          targetInputs[typedItem.key] = [{}];
+        }
+        const fieldsetTarget = targetInputs[typedItem.key][0];
+        const nestedPath = [...fieldsetPath, fieldsetTitle];
+        const nestedStats = await this.processFieldItems(
+          typedItem.fields,
+          fieldsetTarget,
+          processedFieldKeys,
+          nestedPath,
+          iteration
+        );
+        newRequiredCount += nestedStats.newRequired;
+        newOptionalCount += nestedStats.newOptional;
+        if (nestedStats.optionalSkipped) {
+          optionalSkipped = true;
+        }
+      } else if (typedItem.type === "input_field" && typedItem.key) {
+        if (processedFieldKeys.has(typedItem.key)) {
+          continue;
+        }
+        const isRequired = typedItem.is_required || false;
+        if (isRequired) {
+          newRequiredCount++;
+          if (newRequiredCount === 1 && fieldsetPath.length === 0) {
+            console.log(
+              chalk3.blue(
+                `
+\u{1F4DD} Please provide values for the following ${iteration === 1 ? "" : "additional "}input fields:`
+              )
+            );
+          }
+          await this.promptForField(typedItem, targetInputs);
+          processedFieldKeys.add(typedItem.key);
+        } else {
+          newOptionalCount++;
         }
       }
-      let shouldConfigureOptional = { configure: false };
-      if (newOptionalFields.length > 0) {
+    }
+    if (newOptionalCount > 0) {
+      const optionalFields = items.filter((item) => {
+        const typedItem = item;
+        return typedItem.type === "input_field" && typedItem.key && !typedItem.is_required && !processedFieldKeys.has(typedItem.key);
+      });
+      if (optionalFields.length > 0) {
+        const pathContext = fieldsetPath.length > 0 ? ` in ${fieldsetPath.join(" > ")}` : "";
         console.log(
           chalk3.gray(
             `
-There are ${newOptionalFields.length} ${iteration === 1 ? "" : "additional "}optional field(s) available.`
+There are ${optionalFields.length} ${iteration === 1 ? "" : "additional "}optional field(s) available${pathContext}.`
           )
         );
         try {
-          shouldConfigureOptional = await inquirer.prompt([
+          const shouldConfigureOptional = await inquirer.prompt([
             {
               type: "confirm",
               name: "configure",
-              message: `Would you like to configure ${iteration === 1 ? "" : "these additional "}optional fields?`,
+              message: `Would you like to configure ${iteration === 1 ? "" : "these additional "}optional fields${pathContext}?`,
               default: false
             }
           ]);
+          if (shouldConfigureOptional.configure) {
+            console.log(chalk3.cyan(`
+Optional fields${pathContext}:`));
+            for (const field of optionalFields) {
+              await this.promptForField(field, targetInputs);
+              const typedField = field;
+              processedFieldKeys.add(typedField.key);
+            }
+          } else {
+            optionalSkipped = true;
+            optionalFields.forEach((field) => {
+              const typedField = field;
+              processedFieldKeys.add(typedField.key);
+            });
+          }
         } catch (error) {
           if (this.isUserCancellation(error)) {
             console.log(chalk3.yellow("\n\nOperation cancelled by user"));
@@ -322,32 +456,13 @@ There are ${newOptionalFields.length} ${iteration === 1 ? "" : "additional "}opt
           }
           throw error;
         }
-        if (shouldConfigureOptional.configure) {
-          console.log(chalk3.cyan(`
-Optional fields:`));
-          for (const field of newOptionalFields) {
-            await this.promptForField(field, inputs);
-            processedFieldKeys.add(field.key);
-          }
-        } else {
-          newOptionalFields.forEach(
-            (field) => processedFieldKeys.add(field.key)
-          );
-        }
-      }
-      if (newRequiredFields.length === 0 && (!newOptionalFields.length || !shouldConfigureOptional.configure)) {
-        break;
       }
     }
-    if (iteration >= maxIterations) {
-      console.log(
-        chalk3.yellow(
-          `
-\u26A0\uFE0F  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`
-        )
-      );
-    }
-    return inputs;
+    return {
+      newRequired: newRequiredCount,
+      newOptional: newOptionalCount,
+      optionalSkipped
+    };
   }
   getNestedValue(obj, path2) {
     return path2.reduce(
@@ -371,7 +486,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 +511,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 +526,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 +567,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 +587,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 +628,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 +665,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 +699,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 +710,7 @@ function analyzeZodField(name, schema) {
     description: schema.description,
     default: defaultValue,
     choices,
-    hasResolver: hasResolver(name),
+    hasResolver: paramHasResolver,
     isPositional: isPositional(schema)
   };
 }
@@ -565,12 +732,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 +796,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 +819,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 +842,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 +852,7 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk2) {
             resolvedParams.maxItems,
             hasUserSpecifiedMaxItems,
             shouldUseJson,
-            schema,
-            sdkMethodName
+            functionInfo
           );
         } else {
           formatJsonOutput(items);
@@ -810,6 +973,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 +995,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 +1021,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 +1064,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 +1076,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 +1089,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 +1097,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 +1127,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 +2167,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 +2195,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 +2214,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 +2254,7 @@ function createZapierCliSdk(options = {}) {
 
 // package.json
 var package_default = {
-  version: "0.9.0"};
+  version: "0.11.0"};
 
 // src/cli.ts
 var program = new Command();