@zapier/zapier-sdk-cli 0.8.4 → 0.10.0

package/dist/cli.cjs

@@ -14,9 +14,11 @@ var pkceChallenge = require('pkce-challenge');
 var ora = require('ora');
 var zapierSdkCliLogin = require('@zapier/zapier-sdk-cli-login');
 var zapierSdkMcp = require('@zapier/zapier-sdk-mcp');
+var esbuild = require('esbuild');
 var fs = require('fs');
 var path = require('path');
-var esbuild = require('esbuild');
+var ts = require('typescript');
+var promises = require('fs/promises');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -48,13 +50,47 @@ var pkceChallenge__default = /*#__PURE__*/_interopDefault(pkceChallenge);
 var ora__default = /*#__PURE__*/_interopDefault(ora);
 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;
@@ -90,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) {
@@ -107,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) {
@@ -134,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) {
@@ -162,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) {
@@ -214,19 +273,19 @@ var SchemaParameterResolver = class {
     }
     return this.createResolvableParameter([fieldName], baseSchema, isRequired);
   }
-  createResolvableParameter(path3, schema, isRequired) {
-    if (path3.length === 0) return null;
-    const name = path3[path3.length - 1];
+  createResolvableParameter(path2, schema, isRequired) {
+    if (path2.length === 0) return null;
+    const name = path2[path2.length - 1];
     return {
       name,
-      path: path3,
+      path: path2,
       schema,
       description: schema.description,
       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}`);
     }
@@ -311,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(
@@ -379,15 +438,15 @@ Optional fields:`));
     }
     return inputs;
   }
-  getNestedValue(obj, path3) {
-    return path3.reduce(
+  getNestedValue(obj, path2) {
+    return path2.reduce(
       (current, key) => current?.[key],
       obj
     );
   }
-  setNestedValue(obj, path3, value) {
-    const lastKey = path3[path3.length - 1];
-    const parent = path3.slice(0, -1).reduce((current, key) => {
+  setNestedValue(obj, path2, value) {
+    const lastKey = path2[path2.length - 1];
+    const parent = path2.slice(0, -1).reduce((current, key) => {
       const currentObj = current;
       if (!(key in currentObj)) {
         currentObj[key] = {};
@@ -401,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}
@@ -426,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) {
@@ -441,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;
@@ -448,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;
@@ -460,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}`);
@@ -491,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);
       }
@@ -532,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;
@@ -566,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,
@@ -573,7 +684,7 @@ function analyzeZodField(name, schema) {
     description: schema.description,
     default: defaultValue,
     choices,
-    hasResolver: zapierSdk.hasResolver(name),
+    hasResolver: paramHasResolver,
     isPositional: zapierSdk.isPositional(schema)
   };
 }
@@ -595,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({
@@ -664,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"
       );
@@ -686,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!`)
           );
@@ -708,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));
@@ -718,8 +826,7 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk2) {
             resolvedParams.maxItems,
             hasUserSpecifiedMaxItems,
             shouldUseJson,
-            schema,
-            sdkMethodName
+            functionInfo
           );
         } else {
           formatJsonOutput(items);
@@ -763,6 +870,7 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk2) {
 }
 function addCommand(program2, commandName, config) {
   const command = program2.command(commandName).description(config.description);
+  let hasPositionalArray = false;
   config.parameters.forEach((param) => {
     const kebabName = param.name.replace(/([A-Z])/g, "-$1").toLowerCase();
     if (param.hasResolver && param.required) {
@@ -770,6 +878,19 @@ function addCommand(program2, commandName, config) {
         `[${kebabName}]`,
         param.description || `${kebabName} parameter`
       );
+    } else if (param.required && param.type === "array" && !hasPositionalArray) {
+      hasPositionalArray = true;
+      command.argument(
+        `<${kebabName}...>`,
+        param.description || `${kebabName} parameter`
+      );
+    } else if (param.required && param.type === "array") {
+      const flags = [`--${kebabName}`];
+      const flagSignature = flags.join(", ") + ` <values...>`;
+      command.requiredOption(
+        flagSignature,
+        param.description || `${kebabName} parameter (required)`
+      );
     } else if (param.required) {
       command.argument(
         `<${kebabName}>`,
@@ -826,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);
@@ -845,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;
@@ -869,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);
       }
@@ -910,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);
       }
@@ -922,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));
@@ -935,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;
@@ -943,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);
   }
@@ -973,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
@@ -1051,28 +1178,28 @@ var client_default = api;
 
 // src/utils/getCallablePromise.ts
 var getCallablePromise = () => {
-  let resolve2 = () => {
+  let resolve3 = () => {
   };
   let reject = () => {
   };
   const promise = new Promise((_resolve, _reject) => {
-    resolve2 = _resolve;
+    resolve3 = _resolve;
     reject = _reject;
   });
   return {
     promise,
-    resolve: resolve2,
+    resolve: resolve3,
     reject
   };
 };
 var getCallablePromise_default = getCallablePromise;
 var findAvailablePort = () => {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     let portIndex = 0;
     const tryPort = (port) => {
       const server = express__default.default().listen(port, () => {
         server.close();
-        resolve2(port);
+        resolve3(port);
       });
       server.on("error", (err) => {
         if (err.code === "EADDRINUSE") {
@@ -1162,15 +1289,15 @@ var login = async (timeoutMs = LOGIN_TIMEOUT_MS) => {
   } finally {
     process.off("SIGINT", cleanup);
     process.off("SIGTERM", cleanup);
-    await new Promise((resolve2) => {
+    await new Promise((resolve3) => {
       const timeout = setTimeout(() => {
         log_default.info("Server close timed out, forcing connection shutdown...");
         connections.forEach((conn) => conn.destroy());
-        resolve2();
+        resolve3();
       }, 1e3);
       server.close(() => {
         clearTimeout(timeout);
-        resolve2();
+        resolve3();
       });
     });
   }
@@ -1265,323 +1392,6 @@ var mcpPlugin = ({ context }) => {
     }
   };
 };
-var GenerateTypesSchema = zod.z.object({
-  appKey: zapierSdk.AppKeyPropertySchema.describe("App key to generate SDK code for"),
-  authenticationId: zapierSdk.AuthenticationIdPropertySchema.optional(),
-  output: zapierSdk.OutputPropertySchema.optional().describe(
-    "Output file path (defaults to generated/<appKey>.ts)"
-  ),
-  lockFilePath: zod.z.string().optional().describe("Path to the .zapierrc lock file (defaults to .zapierrc)")
-}).describe("Generate TypeScript SDK code for a specific app");
-var generateTypesPlugin = ({ sdk: sdk2 }) => {
-  const generateTypesWithSdk = zapierSdk.createFunction(
-    async function generateTypesWithSdk2(options) {
-      return await generateTypes({ ...options, sdk: sdk2 });
-    },
-    GenerateTypesSchema
-  );
-  return {
-    generateTypes: generateTypesWithSdk,
-    context: {
-      meta: {
-        generateTypes: {
-          categories: ["utility"],
-          inputSchema: GenerateTypesSchema
-        }
-      }
-    }
-  };
-};
-function generateFetchMethodSignature() {
-  return `  /** Make authenticated HTTP requests through Zapier's Relay service */
-  fetch: (options: Omit<z.infer<typeof RelayFetchSchema>, 'authenticationId'>) => Promise<Response>`;
-}
-async function generateTypes(options) {
-  const {
-    appKey,
-    authenticationId,
-    output = `./types/${appKey}.d.ts`,
-    sdk: sdk2
-  } = options;
-  const { app, version } = parseAppIdentifier(appKey);
-  const actionsResult = await sdk2.listActions({
-    appKey: app
-  });
-  const actions = actionsResult.data;
-  if (actions.length === 0) {
-    const typeDefinitions2 = generateEmptyTypesFile(app, version);
-    if (output) {
-      fs__namespace.mkdirSync(path__namespace.dirname(output), { recursive: true });
-      fs__namespace.writeFileSync(output, typeDefinitions2, "utf8");
-    }
-    return typeDefinitions2;
-  }
-  const actionsWithFields = [];
-  if (authenticationId) {
-    for (const action of actions) {
-      try {
-        const manifestEntry = sdk2.getContext().getManifestEntry(appKey);
-        const fieldsResult = await sdk2.listInputFields({
-          // If the appKey is in the manifest, use the appKey so that the types are consistent with the manifest's version, otherwise use the action.app_key
-          appKey: manifestEntry ? appKey : action.app_key,
-          actionKey: action.key,
-          actionType: action.action_type,
-          authenticationId
-        });
-        const fields = fieldsResult.data.map((field) => {
-          const fieldObj = field;
-          return {
-            ...fieldObj,
-            required: fieldObj.is_required || fieldObj.required || false
-          };
-        });
-        actionsWithFields.push({
-          ...action,
-          inputFields: fields,
-          name: action.title || action.key
-        });
-      } catch {
-        actionsWithFields.push({
-          ...action,
-          inputFields: [],
-          name: action.title || action.key
-        });
-      }
-    }
-  } else {
-    actions.forEach((action) => {
-      actionsWithFields.push({
-        ...action,
-        inputFields: [],
-        name: action.title || action.key
-      });
-    });
-  }
-  const typeDefinitions = generateTypeDefinitions(
-    app,
-    actionsWithFields,
-    version
-  );
-  if (output) {
-    fs__namespace.mkdirSync(path__namespace.dirname(output), { recursive: true });
-    fs__namespace.writeFileSync(output, typeDefinitions, "utf8");
-  }
-  return typeDefinitions;
-}
-function parseAppIdentifier(identifier) {
-  const parts = identifier.split("@");
-  return {
-    app: parts[0],
-    version: parts[1]
-  };
-}
-function generateTypeDefinitions(appKey, actions, version) {
-  if (actions.length === 0) {
-    return generateEmptyTypesFile(appKey, version);
-  }
-  const actionsByType = actions.reduce(
-    (acc, action) => {
-      if (!acc[action.action_type]) {
-        acc[action.action_type] = [];
-      }
-      acc[action.action_type].push(action);
-      return acc;
-    },
-    {}
-  );
-  const appName = capitalize(appKey);
-  const versionComment = version ? ` * Generated for ${appKey}@${version}` : ` * Generated for ${appKey}`;
-  let output = `/* eslint-disable @typescript-eslint/naming-convention */
-/**
- * Auto-generated TypeScript types for Zapier ${appKey} actions
-${versionComment}
- * Generated on: ${(/* @__PURE__ */ new Date()).toISOString()}
- * 
- * Usage:
- *   import type { ${appName}Sdk } from './path/to/this/file'
- *   const sdk = createZapierSdk() as unknown as ${appName}Sdk
- *   
- *   // Direct usage (per-call auth):
- *   await sdk.apps.${appKey}.search.user_by_email({ authenticationId: 123, inputs: { email } })
- *   
- *   // Factory usage (pinned auth):
- *   const my${appName} = sdk.apps.${appKey}({ authenticationId: 123 })
- *   await my${appName}.search.user_by_email({ inputs: { email } })
- */
-
-import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
-import { z } from 'zod'
-import { RelayFetchSchema } from '@zapier/zapier-sdk'
-
-`;
-  actions.forEach((action) => {
-    if (action.inputFields.length > 0) {
-      const inputTypeName = `${appName}${capitalize(action.action_type)}${capitalize(
-        sanitizeActionName(action.key)
-      )}Inputs`;
-      output += `interface ${inputTypeName} {
-`;
-      action.inputFields.forEach((field) => {
-        const isOptional = !field.required;
-        const fieldType = mapFieldTypeToTypeScript(field);
-        const description = field.helpText ? `  /** ${escapeComment(field.helpText)} */
-` : "";
-        output += `${description}  ${sanitizeFieldName(field.key)}${isOptional ? "?" : ""}: ${fieldType}
-`;
-      });
-      output += `}
-
-`;
-    }
-  });
-  Object.entries(actionsByType).forEach(([actionType, typeActions]) => {
-    const typeName = `${appName}${capitalize(actionType)}Actions`;
-    output += `interface ${typeName} {
-`;
-    typeActions.forEach((action) => {
-      const actionName = sanitizeActionName(action.key);
-      const description = action.description ? `  /** ${escapeComment(action.description)} */
-` : "";
-      if (action.inputFields.length > 0) {
-        const inputTypeName = `${appName}${capitalize(action.action_type)}${capitalize(
-          sanitizeActionName(action.key)
-        )}Inputs`;
-        output += `${description}  ${actionName}: (options: { inputs: ${inputTypeName} } & Omit<ActionExecutionOptions, 'inputs'>) => Promise<ActionExecutionResult>
-`;
-      } else {
-        output += `${description}  ${actionName}: (options?: { inputs?: Record<string, any> } & ActionExecutionOptions) => Promise<ActionExecutionResult>
-`;
-      }
-    });
-    output += `}
-
-`;
-  });
-  output += `interface ${appName}AppProxy {
-`;
-  Object.keys(actionsByType).forEach((actionType) => {
-    const typeName = `${appName}${capitalize(actionType)}Actions`;
-    output += `  ${actionType}: ${typeName}
-`;
-  });
-  output += generateFetchMethodSignature() + "\n";
-  output += `}
-
-`;
-  output += `interface ${appName}AppFactory {
-`;
-  output += `  (options: { authenticationId: number }): ${appName}AppProxy
-`;
-  output += `}
-
-`;
-  output += `type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy
-
-`;
-  output += `export interface ${appName}Sdk {
-`;
-  output += `  apps: {
-`;
-  output += `    ${appKey}: ${appName}AppWithFactory
-`;
-  output += `  }
-`;
-  output += `}
-`;
-  return output;
-}
-function generateEmptyTypesFile(appKey, version) {
-  const appName = capitalize(appKey);
-  const versionComment = version ? ` * Generated for ${appKey}@${version}` : ` * Generated for ${appKey}`;
-  return `/* eslint-disable @typescript-eslint/naming-convention */
-/**
- * Auto-generated TypeScript types for Zapier ${appKey} actions
-${versionComment}
- * Generated on: ${(/* @__PURE__ */ new Date()).toISOString()}
- * 
- * No actions found for this app.
- */
-
-import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
-import { z } from 'zod'
-import { RelayFetchSchema } from '@zapier/zapier-sdk'
-
-interface ${appName}AppProxy {
-  // No actions available
-${generateFetchMethodSignature()}
-}
-
-interface ${appName}AppFactory {
-  (options: { authenticationId: number }): ${appName}AppProxy
-}
-
-type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy
-
-export interface ${appName}Sdk {
-  apps: {
-    ${appKey}: ${appName}AppWithFactory
-  }
-}
-`;
-}
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1).replace(/[-_]/g, "");
-}
-function sanitizeActionName(actionKey) {
-  let sanitized = actionKey.replace(/[^a-zA-Z0-9_$]/g, "_");
-  if (/^[0-9]/.test(sanitized)) {
-    sanitized = "_" + sanitized;
-  }
-  return sanitized;
-}
-function sanitizeFieldName(fieldKey) {
-  let sanitized = fieldKey.replace(/[^a-zA-Z0-9_$]/g, "_");
-  if (/^[0-9]/.test(sanitized)) {
-    sanitized = "_" + sanitized;
-  }
-  return sanitized;
-}
-function escapeComment(comment) {
-  return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
-}
-function mapFieldTypeToTypeScript(field) {
-  if (field.choices && field.choices.length > 0) {
-    const choiceValues = field.choices.filter(
-      (choice) => choice.value !== void 0 && choice.value !== null && choice.value !== ""
-    ).map(
-      (choice) => typeof choice.value === "string" ? `"${choice.value}"` : choice.value
-    );
-    if (choiceValues.length > 0) {
-      return choiceValues.join(" | ");
-    }
-  }
-  switch (field.type?.toLowerCase()) {
-    case "string":
-    case "text":
-    case "email":
-    case "url":
-    case "password":
-      return "string";
-    case "integer":
-    case "number":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "datetime":
-    case "date":
-      return "string";
-    // ISO date strings
-    case "file":
-      return "string";
-    // File URL or content
-    case "array":
-      return "any[]";
-    case "object":
-      return "Record<string, any>";
-    default:
-      return "string | number | boolean";
-  }
-}
 var BundleCodeSchema = zod.z.object({
   input: zod.z.string().min(1).describe("Input TypeScript file path to bundle"),
   output: zapierSdk.OutputPropertySchema.optional().describe(
@@ -1673,21 +1483,728 @@ async function bundleCode(options) {
     );
   }
 }
-var GetConfigPathSchema = zod.z.object({}).describe("Show the path to the configuration file");
-var getConfigPathPlugin = () => {
-  const getConfigPathWithSdk = zapierSdk.createFunction(
-    async function getConfigPathWithSdk2(_options) {
+var GetLoginConfigPathSchema = zod.z.object({}).describe("Show the path to the login configuration file");
+var getLoginConfigPathPlugin = () => {
+  const getLoginConfigPathWithSdk = zapierSdk.createFunction(
+    async function getLoginConfigPathWithSdk2(_options) {
       return zapierSdkCliLogin.getConfigPath();
     },
-    GetConfigPathSchema
+    GetLoginConfigPathSchema
   );
   return {
-    getConfigPath: getConfigPathWithSdk,
+    getLoginConfigPath: getLoginConfigPathWithSdk,
+    context: {
+      meta: {
+        getLoginConfigPath: {
+          categories: ["utility"],
+          inputSchema: GetLoginConfigPathSchema
+        }
+      }
+    }
+  };
+};
+var AddSchema = 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"),
+  authenticationIds: zod.z.array(zod.z.string()).optional().describe("Authentication IDs to use for type generation"),
+  configPath: zod.z.string().optional().describe(
+    `Path to Zapier config file (defaults to '${zapierSdk.DEFAULT_CONFIG_PATH}')`
+  ),
+  typesOutput: zod.z.string().optional().describe(
+    "Directory for TypeScript type files (defaults to (src|lib|.)/zapier/apps/)"
+  )
+});
+var AstTypeGenerator = class {
+  constructor() {
+    this.factory = ts__namespace.factory;
+    this.printer = ts__namespace.createPrinter({
+      newLine: ts__namespace.NewLineKind.LineFeed,
+      removeComments: false,
+      omitTrailingSemicolon: false
+    });
+  }
+  /**
+   * Generate TypeScript types using AST for a specific app
+   */
+  async generateTypes(options) {
+    const { appKey, authenticationId, sdk: sdk2 } = options;
+    const { app, version } = this.parseAppIdentifier(appKey);
+    const actionsResult = await sdk2.listActions({
+      appKey: app
+    });
+    const actions = actionsResult.data;
+    if (actions.length === 0) {
+      return this.generateEmptyTypesFile(app, version);
+    }
+    const actionsWithFields = [];
+    if (authenticationId) {
+      for (const action of actions) {
+        try {
+          const fieldsResult = await sdk2.listInputFields({
+            appKey,
+            actionKey: action.key,
+            actionType: action.action_type,
+            authenticationId
+          });
+          const fields = fieldsResult.data.map(
+            (field) => {
+              const fieldObj = field;
+              return {
+                ...fieldObj,
+                required: fieldObj.is_required || fieldObj.required || false
+              };
+            }
+          );
+          actionsWithFields.push({
+            ...action,
+            inputFields: fields,
+            name: action.title || action.key
+          });
+        } catch {
+          actionsWithFields.push({
+            ...action,
+            inputFields: [],
+            name: action.title || action.key
+          });
+        }
+      }
+    } else {
+      actions.forEach(
+        (action) => {
+          actionsWithFields.push({
+            ...action,
+            inputFields: [],
+            name: action.title || action.key,
+            app_key: action.app_key || appKey,
+            action_type: action.action_type || "write",
+            title: action.title || action.key,
+            type: "action",
+            description: action.description || ""
+          });
+        }
+      );
+    }
+    const sourceFile = this.createSourceFile(app, actionsWithFields, version);
+    return this.printer.printFile(sourceFile);
+  }
+  parseAppIdentifier(identifier) {
+    const parts = identifier.split("@");
+    return {
+      app: parts[0],
+      version: parts[1]
+    };
+  }
+  createSourceFile(appKey, actions, version) {
+    const appName = this.capitalize(appKey);
+    const versionComment = version ? ` * Generated for ${appKey}@${version}` : ` * Generated for ${appKey}`;
+    const headerComment = `Auto-generated TypeScript types for Zapier ${appKey} actions
+${versionComment.slice(3)}
+Generated on: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+This file automatically augments the base SDK types when present.
+No manual imports or type casting required.
+
+Usage:
+  import { createZapierSdk } from "@zapier/zapier-sdk";
+  
+  const zapier = createZapierSdk();
+  // Types are automatically available:
+  await zapier.apps.${appKey}.search.user_by_email({ authenticationId: 123, inputs: { email } })
+  
+  // Factory usage (pinned auth):
+  const my${appName} = zapier.apps.${appKey}({ authenticationId: 123 })
+  await my${appName}.search.user_by_email({ inputs: { email } })`;
+    const statements = [
+      // Import the SDK to activate module augmentation
+      this.createImportStatement(["@zapier/zapier-sdk"]),
+      // Import types we'll use
+      this.createTypeImportStatement(
+        [
+          "ActionExecutionOptions",
+          "ActionExecutionResult",
+          "ZapierFetchInitOptions"
+        ],
+        "@zapier/zapier-sdk"
+      )
+    ];
+    const actionsByType = this.groupActionsByType(actions);
+    actions.forEach((action) => {
+      if (action.inputFields.length > 0) {
+        const inputInterface = this.createInputInterface(appName, action);
+        statements.push(inputInterface);
+      }
+    });
+    Object.entries(actionsByType).forEach(([actionType, typeActions]) => {
+      const actionInterface = this.createActionInterface(
+        appName,
+        actionType,
+        typeActions
+      );
+      statements.push(actionInterface);
+    });
+    const appProxyInterface = this.createAppProxyInterface(
+      appName,
+      actionsByType
+    );
+    statements.push(appProxyInterface);
+    const appFactoryInterface = this.createAppFactoryInterface(appName);
+    statements.push(appFactoryInterface);
+    const appWithFactoryType = this.createAppWithFactoryType(appName);
+    statements.push(appWithFactoryType);
+    const moduleAugmentation = this.createModuleAugmentation(appKey, appName);
+    statements.push(moduleAugmentation);
+    statements.push(
+      this.factory.createExportDeclaration(
+        void 0,
+        false,
+        this.factory.createNamedExports([])
+      )
+    );
+    const sourceFile = ts__namespace.createSourceFile(
+      "generated.d.ts",
+      "",
+      ts__namespace.ScriptTarget.Latest,
+      false,
+      ts__namespace.ScriptKind.TS
+    );
+    if (statements.length > 0) {
+      ts__namespace.addSyntheticLeadingComment(
+        statements[0],
+        ts__namespace.SyntaxKind.MultiLineCommentTrivia,
+        " eslint-disable @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any ",
+        true
+      );
+      ts__namespace.addSyntheticLeadingComment(
+        statements[0],
+        ts__namespace.SyntaxKind.MultiLineCommentTrivia,
+        headerComment,
+        true
+      );
+    }
+    return this.factory.updateSourceFile(sourceFile, statements);
+  }
+  createImportStatement(imports, from) {
+    if (imports.length === 1 && !from && imports[0].startsWith("@")) {
+      return this.factory.createImportDeclaration(
+        void 0,
+        void 0,
+        this.factory.createStringLiteral(imports[0]),
+        void 0
+      );
+    }
+    const fromModule = from || imports[0];
+    const importNames = from ? imports : [];
+    return this.factory.createImportDeclaration(
+      void 0,
+      importNames.length > 0 ? this.factory.createImportClause(
+        false,
+        void 0,
+        this.factory.createNamedImports(
+          importNames.map(
+            (name) => this.factory.createImportSpecifier(
+              false,
+              void 0,
+              this.factory.createIdentifier(name)
+            )
+          )
+        )
+      ) : void 0,
+      this.factory.createStringLiteral(fromModule),
+      void 0
+    );
+  }
+  createTypeImportStatement(imports, from) {
+    return this.factory.createImportDeclaration(
+      void 0,
+      this.factory.createImportClause(
+        true,
+        // typeOnly: true
+        void 0,
+        this.factory.createNamedImports(
+          imports.map(
+            (name) => this.factory.createImportSpecifier(
+              false,
+              void 0,
+              this.factory.createIdentifier(name)
+            )
+          )
+        )
+      ),
+      this.factory.createStringLiteral(from),
+      void 0
+    );
+  }
+  groupActionsByType(actions) {
+    return actions.reduce(
+      (acc, action) => {
+        if (!acc[action.action_type]) {
+          acc[action.action_type] = [];
+        }
+        acc[action.action_type].push(action);
+        return acc;
+      },
+      {}
+    );
+  }
+  createInputInterface(appName, action) {
+    const inputTypeName = `${appName}${this.capitalize(action.action_type)}${this.capitalize(
+      this.sanitizeActionName(action.key)
+    )}Inputs`;
+    const properties = action.inputFields.map((field) => {
+      const fieldType = this.mapFieldTypeToTypeNode(field);
+      const isOptional = !field.required;
+      let property = this.factory.createPropertySignature(
+        void 0,
+        this.sanitizeFieldName(field.key),
+        isOptional ? this.factory.createToken(ts__namespace.SyntaxKind.QuestionToken) : void 0,
+        fieldType
+      );
+      if (field.helpText) {
+        property = ts__namespace.addSyntheticLeadingComment(
+          property,
+          ts__namespace.SyntaxKind.MultiLineCommentTrivia,
+          `* ${this.escapeComment(field.helpText)} `,
+          true
+        );
+      }
+      return property;
+    });
+    return this.factory.createInterfaceDeclaration(
+      void 0,
+      inputTypeName,
+      void 0,
+      void 0,
+      properties
+    );
+  }
+  createActionInterface(appName, actionType, typeActions) {
+    const typeName = `${appName}${this.capitalize(actionType)}Actions`;
+    const methods = typeActions.map((action) => {
+      const actionName = this.sanitizeActionName(action.key);
+      let methodSignature;
+      if (action.inputFields.length > 0) {
+        const inputTypeName = `${appName}${this.capitalize(action.action_type)}${this.capitalize(
+          this.sanitizeActionName(action.key)
+        )}Inputs`;
+        const inputsType = this.factory.createTypeLiteralNode([
+          this.factory.createPropertySignature(
+            void 0,
+            "inputs",
+            void 0,
+            this.factory.createTypeReferenceNode(inputTypeName)
+          )
+        ]);
+        const omitType = this.factory.createTypeReferenceNode("Omit", [
+          this.factory.createTypeReferenceNode("ActionExecutionOptions"),
+          this.factory.createLiteralTypeNode(
+            this.factory.createStringLiteral("inputs")
+          )
+        ]);
+        const optionsType = this.factory.createIntersectionTypeNode([
+          inputsType,
+          omitType
+        ]);
+        methodSignature = this.factory.createMethodSignature(
+          void 0,
+          actionName,
+          void 0,
+          void 0,
+          [
+            this.factory.createParameterDeclaration(
+              void 0,
+              void 0,
+              "options",
+              void 0,
+              optionsType
+            )
+          ],
+          this.factory.createTypeReferenceNode("Promise", [
+            this.factory.createTypeReferenceNode("ActionExecutionResult")
+          ])
+        );
+      } else {
+        const genericInputsType = this.factory.createTypeLiteralNode([
+          this.factory.createPropertySignature(
+            void 0,
+            "inputs",
+            this.factory.createToken(ts__namespace.SyntaxKind.QuestionToken),
+            this.factory.createTypeReferenceNode("Record", [
+              this.factory.createKeywordTypeNode(ts__namespace.SyntaxKind.StringKeyword),
+              this.factory.createKeywordTypeNode(ts__namespace.SyntaxKind.AnyKeyword)
+            ])
+          )
+        ]);
+        const intersectionType = this.factory.createIntersectionTypeNode([
+          genericInputsType,
+          this.factory.createTypeReferenceNode("ActionExecutionOptions")
+        ]);
+        methodSignature = this.factory.createMethodSignature(
+          void 0,
+          actionName,
+          void 0,
+          void 0,
+          [
+            this.factory.createParameterDeclaration(
+              void 0,
+              void 0,
+              "options",
+              this.factory.createToken(ts__namespace.SyntaxKind.QuestionToken),
+              intersectionType
+            )
+          ],
+          this.factory.createTypeReferenceNode("Promise", [
+            this.factory.createTypeReferenceNode("ActionExecutionResult")
+          ])
+        );
+      }
+      if (action.description) {
+        methodSignature = ts__namespace.addSyntheticLeadingComment(
+          methodSignature,
+          ts__namespace.SyntaxKind.MultiLineCommentTrivia,
+          `* ${this.escapeComment(action.description)} `,
+          true
+        );
+      }
+      return methodSignature;
+    });
+    return this.factory.createInterfaceDeclaration(
+      void 0,
+      typeName,
+      void 0,
+      void 0,
+      methods
+    );
+  }
+  createAppProxyInterface(appName, actionsByType) {
+    const properties = [
+      ...Object.keys(actionsByType).map(
+        (actionType) => this.factory.createPropertySignature(
+          void 0,
+          actionType,
+          void 0,
+          this.factory.createTypeReferenceNode(
+            `${appName}${this.capitalize(actionType)}Actions`
+          )
+        )
+      ),
+      // Always include fetch method for authenticated HTTP requests
+      this.createFetchMethodProperty()
+    ];
+    return this.factory.createInterfaceDeclaration(
+      void 0,
+      `${appName}AppProxy`,
+      void 0,
+      void 0,
+      properties
+    );
+  }
+  createFetchMethodProperty() {
+    let property = this.factory.createPropertySignature(
+      void 0,
+      "fetch",
+      void 0,
+      this.factory.createFunctionTypeNode(
+        void 0,
+        [
+          this.factory.createParameterDeclaration(
+            void 0,
+            void 0,
+            "url",
+            void 0,
+            this.factory.createUnionTypeNode([
+              this.factory.createTypeReferenceNode("string"),
+              this.factory.createTypeReferenceNode("URL")
+            ])
+          ),
+          this.factory.createParameterDeclaration(
+            void 0,
+            void 0,
+            "init",
+            this.factory.createToken(ts__namespace.SyntaxKind.QuestionToken),
+            this.factory.createTypeReferenceNode("ZapierFetchInitOptions")
+          )
+        ],
+        this.factory.createTypeReferenceNode("Promise", [
+          this.factory.createTypeReferenceNode("Response")
+        ])
+      )
+    );
+    property = ts__namespace.addSyntheticLeadingComment(
+      property,
+      ts__namespace.SyntaxKind.MultiLineCommentTrivia,
+      "* Make authenticated HTTP requests through Zapier's Relay service ",
+      true
+    );
+    return property;
+  }
+  createAppFactoryInterface(appName) {
+    const callSignature = this.factory.createCallSignature(
+      void 0,
+      [
+        this.factory.createParameterDeclaration(
+          void 0,
+          void 0,
+          "options",
+          void 0,
+          this.factory.createTypeLiteralNode([
+            this.factory.createPropertySignature(
+              void 0,
+              "authenticationId",
+              void 0,
+              this.factory.createKeywordTypeNode(ts__namespace.SyntaxKind.NumberKeyword)
+            )
+          ])
+        )
+      ],
+      this.factory.createTypeReferenceNode(`${appName}AppProxy`)
+    );
+    return this.factory.createInterfaceDeclaration(
+      void 0,
+      `${appName}AppFactory`,
+      void 0,
+      void 0,
+      [callSignature]
+    );
+  }
+  createAppWithFactoryType(appName) {
+    return this.factory.createTypeAliasDeclaration(
+      void 0,
+      `${appName}AppWithFactory`,
+      void 0,
+      this.factory.createIntersectionTypeNode([
+        this.factory.createTypeReferenceNode(`${appName}AppFactory`),
+        this.factory.createTypeReferenceNode(`${appName}AppProxy`)
+      ])
+    );
+  }
+  createModuleAugmentation(appKey, appName) {
+    return this.factory.createModuleDeclaration(
+      [this.factory.createToken(ts__namespace.SyntaxKind.DeclareKeyword)],
+      this.factory.createStringLiteral("@zapier/zapier-sdk"),
+      this.factory.createModuleBlock([
+        this.factory.createInterfaceDeclaration(
+          void 0,
+          "ZapierSdkApps",
+          void 0,
+          void 0,
+          [
+            this.factory.createPropertySignature(
+              void 0,
+              appKey,
+              void 0,
+              this.factory.createTypeReferenceNode(`${appName}AppWithFactory`)
+            )
+          ]
+        )
+      ])
+    );
+  }
+  mapFieldTypeToTypeNode(field) {
+    if (field.choices && field.choices.length > 0) {
+      const choiceValues = field.choices.filter(
+        (choice) => choice.value !== void 0 && choice.value !== null && choice.value !== ""
+      ).map(
+        (choice) => typeof choice.value === "string" ? this.factory.createLiteralTypeNode(
+          this.factory.createStringLiteral(choice.value)
+        ) : this.factory.createLiteralTypeNode(
+          this.factory.createNumericLiteral(String(choice.value))
+        )
+      );
+      if (choiceValues.length > 0) {
+        return this.factory.createUnionTypeNode(choiceValues);
+      }
+    }
+    switch (field.type?.toLowerCase()) {
+      case "string":
+      case "text":
+      case "email":
+      case "url":
+      case "password":
+      case "datetime":
+      case "date":
+      case "file":
+        return this.factory.createKeywordTypeNode(ts__namespace.SyntaxKind.StringKeyword);
+      case "integer":
+      case "number":
+        return this.factory.createKeywordTypeNode(ts__namespace.SyntaxKind.NumberKeyword);
+      case "boolean":
+        return this.factory.createKeywordTypeNode(ts__namespace.SyntaxKind.BooleanKeyword);
+      case "array":
+        return this.factory.createArrayTypeNode(
+          this.factory.createKeywordTypeNode(ts__namespace.SyntaxKind.AnyKeyword)
+        );
+      case "object":
+        return this.factory.createTypeReferenceNode("Record", [
+          this.factory.createKeywordTypeNode(ts__namespace.SyntaxKind.StringKeyword),
+          this.factory.createKeywordTypeNode(ts__namespace.SyntaxKind.AnyKeyword)
+        ]);
+      default:
+        return this.factory.createUnionTypeNode([
+          this.factory.createKeywordTypeNode(ts__namespace.SyntaxKind.StringKeyword),
+          this.factory.createKeywordTypeNode(ts__namespace.SyntaxKind.NumberKeyword),
+          this.factory.createKeywordTypeNode(ts__namespace.SyntaxKind.BooleanKeyword)
+        ]);
+    }
+  }
+  generateEmptyTypesFile(appKey, version) {
+    const appName = this.capitalize(appKey);
+    const versionComment = version ? ` * Generated for ${appKey}@${version}` : ` * Generated for ${appKey}`;
+    return `/* eslint-disable @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any */
+/**
+ * Auto-generated TypeScript types for Zapier ${appKey} actions
+${versionComment}
+ * Generated on: ${(/* @__PURE__ */ new Date()).toISOString()}
+ * 
+ * No actions found for this app.
+ */
+
+import type { ActionExecutionOptions, ActionExecutionResult, ZapierFetchInitOptions } from '@zapier/zapier-sdk'
+
+interface ${appName}AppProxy {
+  /** Make authenticated HTTP requests through Zapier's Relay service */
+  fetch: (url: string | URL, init?: ZapierFetchInitOptions) => Promise<Response>
+}
+
+interface ${appName}AppFactory {
+  (options: { authenticationId: number }): ${appName}AppProxy
+}
+
+type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy
+
+declare module "@zapier/zapier-sdk" {
+  interface ZapierSdkApps {
+    ${appKey}: ${appName}AppWithFactory
+  }
+}
+`;
+  }
+  capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1).replace(/[-_]/g, "");
+  }
+  sanitizeActionName(actionKey) {
+    let sanitized = actionKey.replace(/[^a-zA-Z0-9_$]/g, "_");
+    if (/^[0-9]/.test(sanitized)) {
+      sanitized = "_" + sanitized;
+    }
+    return sanitized;
+  }
+  sanitizeFieldName(fieldKey) {
+    let sanitized = fieldKey.replace(/[^a-zA-Z0-9_$]/g, "_");
+    if (/^[0-9]/.test(sanitized)) {
+      sanitized = "_" + sanitized;
+    }
+    return sanitized;
+  }
+  escapeComment(comment) {
+    return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
+  }
+};
+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, context }) => {
+  const add = zapierSdk.createFunction(async function add2(options) {
+    const {
+      appKeys,
+      authenticationIds,
+      configPath,
+      typesOutput = await detectTypesOutputDirectory()
+    } = options;
+    const resolvedTypesOutput = path.resolve(typesOutput);
+    await promises.mkdir(resolvedTypesOutput, { recursive: true });
+    console.log(`\u{1F4E6} Looking up ${appKeys.length} app(s)...`);
+    const appsIterator = sdk2.listApps({ appKeys }).items();
+    const apps = [];
+    for await (const app of appsIterator) {
+      apps.push(app);
+    }
+    if (apps.length === 0) {
+      console.warn("\u26A0\uFE0F No apps found");
+      return;
+    }
+    let authentications = [];
+    if (authenticationIds && authenticationIds.length > 0) {
+      console.log(
+        `\u{1F510} Looking up ${authenticationIds.length} authentication(s)...`
+      );
+      const authsIterator = sdk2.listAuthentications({ authenticationIds }).items();
+      for await (const auth of authsIterator) {
+        authentications.push(auth);
+      }
+      console.log(`\u{1F510} Found ${authentications.length} authentication(s)`);
+    }
+    for (const app of apps) {
+      const appSlugAndKey = app.slug ? `${app.slug} (${app.key})` : app.key;
+      console.log(`\u{1F4E6} Adding ${appSlugAndKey}...`);
+      try {
+        if (!app.version) {
+          console.warn(
+            `\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: 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) => {
+            return auth.app_key === app.key;
+          });
+          if (matchingAuth) {
+            authenticationId = matchingAuth.id;
+            console.log(
+              `\u{1F510} Using authentication ${authenticationId} (${matchingAuth.title}) for ${appSlugAndKey}`
+            );
+          } else {
+            console.warn(
+              `\u26A0\uFE0F No matching authentication found for ${appSlugAndKey}`
+            );
+          }
+        }
+        const typesPath = path.join(resolvedTypesOutput, `${manifestKey}.d.ts`);
+        try {
+          const generator = new AstTypeGenerator();
+          const typeDefinitions = await generator.generateTypes({
+            appKey: manifestKey,
+            authenticationId,
+            sdk: sdk2
+          });
+          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 ${appSlugAndKey}: ${error}`
+          );
+        }
+      } catch (error) {
+        console.warn(`\u26A0\uFE0F Failed to process ${appSlugAndKey}: ${error}`);
+      }
+    }
+    console.log(`\u2705 Added ${apps.length} app(s) to manifest`);
+  }, AddSchema);
+  return {
+    add,
     context: {
       meta: {
-        getConfigPath: {
+        add: {
           categories: ["utility"],
-          inputSchema: GetConfigPathSchema
+          inputSchema: AddSchema
         }
       }
     }
@@ -1699,9 +2216,9 @@ function createZapierCliSdk(options = {}) {
   let sdk2 = zapierSdk.createZapierSdkWithoutRegistry({
     debug: options.debug
   });
-  sdk2 = sdk2.addPlugin(generateTypesPlugin);
   sdk2 = sdk2.addPlugin(bundleCodePlugin);
-  sdk2 = sdk2.addPlugin(getConfigPathPlugin);
+  sdk2 = sdk2.addPlugin(getLoginConfigPathPlugin);
+  sdk2 = sdk2.addPlugin(addPlugin);
   sdk2 = sdk2.addPlugin(mcpPlugin);
   sdk2 = sdk2.addPlugin(loginPlugin);
   sdk2 = sdk2.addPlugin(logoutPlugin);
@@ -1711,7 +2228,7 @@ function createZapierCliSdk(options = {}) {
 
 // package.json
 var package_default = {
-  version: "0.8.4"};
+  version: "0.10.0"};
 
 // src/cli.ts
 var program = new commander.Command();