@zapier/zapier-sdk-cli 0.4.1 → 0.4.2

package/dist/cli.js

@@ -1,12 +1,17 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { Command as Command5 } from "commander";
-import { createZapierSdk } from "@zapier/zapier-sdk";
+import { Command as Command7 } from "commander";
+import { createZapierSdk as createZapierSdk2 } from "@zapier/zapier-sdk";
 
 // src/utils/cli-generator.ts
 import { z as z2 } from "zod";
-import { hasResolver as hasResolver2, isPositional } from "@zapier/zapier-sdk";
+import {
+  hasResolver as hasResolver2,
+  isPositional,
+  formatErrorMessage,
+  ZapierError
+} from "@zapier/zapier-sdk";
 
 // src/utils/parameter-resolver.ts
 import inquirer from "inquirer";
@@ -30,18 +35,25 @@ var SchemaParameterResolver = class {
     });
     const functionallyRequired = missingResolvable.filter((param) => {
       if (param.isRequired) return true;
-      if (param.name === "inputs" || param.name === "authenticationId") {
+      if (param.name === "inputs") {
+        return true;
+      }
+      return false;
+    });
+    const alwaysPrompt = missingResolvable.filter((param) => {
+      if (functionallyRequired.includes(param)) return false;
+      if (param.name === "authenticationId") {
         return true;
       }
       return false;
     });
     const trulyOptional = missingResolvable.filter(
-      (param) => !functionallyRequired.includes(param)
+      (param) => !functionallyRequired.includes(param) && !alwaysPrompt.includes(param)
     );
-    if (parseResult.success && functionallyRequired.length === 0) {
+    if (parseResult.success && functionallyRequired.length === 0 && alwaysPrompt.length === 0) {
       return parseResult.data;
     }
-    if (functionallyRequired.length === 0) {
+    if (functionallyRequired.length === 0 && alwaysPrompt.length === 0) {
       if (!parseResult.success) {
         throw parseResult.error;
       }
@@ -56,9 +68,16 @@ var SchemaParameterResolver = class {
     if (functionallyRequired.length > 0) {
       const requiredParamNames = functionallyRequired.map((p) => p.name);
       const requiredResolutionOrder = getResolutionOrderForParams(requiredParamNames);
-      const orderedRequiredParams = requiredResolutionOrder.map(
-        (paramName) => functionallyRequired.find((p) => p.name === paramName)
-      ).filter((param) => param !== void 0);
+      const orderedRequiredParams = requiredResolutionOrder.map((paramName) => {
+        let param = functionallyRequired.find((p) => p.name === paramName);
+        if (!param) {
+          param = alwaysPrompt.find((p) => p.name === paramName);
+        }
+        if (!param) {
+          param = trulyOptional.find((p) => p.name === paramName);
+        }
+        return param;
+      }).filter((param) => param !== void 0);
       for (const param of orderedRequiredParams) {
         try {
           const value = await this.resolveParameter(param, context);
@@ -69,7 +88,37 @@ var SchemaParameterResolver = class {
             console.log(chalk.yellow("\n\nOperation cancelled by user"));
             process.exit(0);
           }
-          console.error(chalk.red(`Failed to resolve ${param.name}:`), error);
+          throw error;
+        }
+      }
+      const resolvedParamNames = new Set(
+        orderedRequiredParams.map((p) => p.name)
+      );
+      alwaysPrompt.splice(
+        0,
+        alwaysPrompt.length,
+        ...alwaysPrompt.filter((p) => !resolvedParamNames.has(p.name))
+      );
+      trulyOptional.splice(
+        0,
+        trulyOptional.length,
+        ...trulyOptional.filter((p) => !resolvedParamNames.has(p.name))
+      );
+    }
+    if (alwaysPrompt.length > 0) {
+      const alwaysPromptNames = alwaysPrompt.map((p) => p.name);
+      const alwaysPromptResolutionOrder = getResolutionOrderForParams(alwaysPromptNames);
+      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);
+          this.setNestedValue(resolvedParams, param.path, value);
+          context.resolvedParams = resolvedParams;
+        } catch (error) {
+          if (this.isUserCancellation(error)) {
+            console.log(chalk.yellow("\n\nOperation cancelled by user"));
+            process.exit(0);
+          }
           throw error;
         }
       }
@@ -98,7 +147,6 @@ var SchemaParameterResolver = class {
               console.log(chalk.yellow("\n\nOperation cancelled by user"));
               process.exit(0);
             }
-            console.error(chalk.red(`Failed to resolve ${param.name}:`), error);
             throw error;
           }
         }
@@ -139,12 +187,12 @@ var SchemaParameterResolver = class {
     }
     return this.createResolvableParameter([fieldName], baseSchema, isRequired);
   }
-  createResolvableParameter(path, schema, isRequired) {
-    if (path.length === 0) return null;
-    const name = path[path.length - 1];
+  createResolvableParameter(path3, schema, isRequired) {
+    if (path3.length === 0) return null;
+    const name = path3[path3.length - 1];
     return {
       name,
-      path,
+      path: path3,
       schema,
       description: schema.description,
       isRequired
@@ -168,97 +216,138 @@ var SchemaParameterResolver = class {
       return answers[param.name];
     } else if (resolver.type === "dynamic") {
       try {
-        console.log(chalk.gray(`Fetching options for ${param.name}...`));
-        const items = await resolver.fetch(context.sdk, context.resolvedParams);
-        if (!items || items.length === 0) {
-          throw new Error(`No options available for ${param.name}`);
+        if (param.isRequired && param.name !== "authenticationId") {
+          console.log(chalk.gray(`Fetching options for ${param.name}...`));
         }
-        const promptConfig = resolver.prompt(items, context.resolvedParams);
+        const items = await resolver.fetch(context.sdk, context.resolvedParams);
+        const safeItems = items || [];
+        const promptConfig = resolver.prompt(safeItems, context.resolvedParams);
         const answers = await inquirer.prompt([promptConfig]);
         return answers[param.name];
       } catch (error) {
-        console.error(
-          chalk.red(`Failed to fetch options for ${param.name}:`),
-          error instanceof Error ? error.message : error
-        );
         throw error;
       }
     } else if (resolver.type === "fields") {
-      try {
-        console.log(chalk.gray(`Fetching input fields for ${param.name}...`));
-        const fields = await resolver.fetch(
-          context.sdk,
-          context.resolvedParams
-        );
-        if (!fields || fields.length === 0) {
+      return await this.resolveFieldsRecursively(
+        resolver,
+        context,
+        param
+      );
+    }
+    throw new Error(`Unknown resolver type for ${param.name}`);
+  }
+  async resolveFieldsRecursively(resolver, context, param) {
+    const inputs = {};
+    let processedFieldKeys = /* @__PURE__ */ new Set();
+    let iteration = 0;
+    const maxIterations = 5;
+    while (iteration < maxIterations) {
+      iteration++;
+      const updatedContext = {
+        ...context,
+        resolvedParams: {
+          ...context.resolvedParams,
+          inputs
+        }
+      };
+      console.log(
+        chalk.gray(
+          `Fetching input fields for ${param.name}${iteration > 1 ? ` (iteration ${iteration})` : ""}...`
+        )
+      );
+      const fields = await resolver.fetch(
+        updatedContext.sdk,
+        updatedContext.resolvedParams
+      );
+      if (!fields || fields.length === 0) {
+        if (iteration === 1) {
           console.log(
             chalk.yellow(`No input fields required for this action.`)
           );
-          return {};
         }
-        const inputs = {};
-        const requiredFields = fields.filter((field) => field.required);
-        const optionalFields = fields.filter((field) => !field.required);
-        if (requiredFields.length > 0) {
-          console.log(
-            chalk.blue(
-              `
-\u{1F4DD} Please provide values for the following input fields:`
-            )
-          );
-          for (const field of requiredFields) {
-            await this.promptForField(field, inputs);
-          }
+        break;
+      }
+      const newFields = fields.filter(
+        (field) => !processedFieldKeys.has(field.key)
+      );
+      if (newFields.length === 0) {
+        break;
+      }
+      const newRequiredFields = newFields.filter(
+        (field) => field.required
+      );
+      const newOptionalFields = newFields.filter(
+        (field) => !field.required
+      );
+      if (newRequiredFields.length > 0) {
+        console.log(
+          chalk.blue(
+            `
+\u{1F4DD} Please provide values for the following ${iteration === 1 ? "" : "additional "}input fields:`
+          )
+        );
+        for (const field of newRequiredFields) {
+          await this.promptForField(field, inputs);
+          processedFieldKeys.add(field.key);
         }
-        if (optionalFields.length > 0) {
-          console.log(
-            chalk.gray(
-              `
-There are ${optionalFields.length} optional field(s) available.`
-            )
-          );
-          let shouldConfigureOptional;
-          try {
-            shouldConfigureOptional = await inquirer.prompt([
-              {
-                type: "confirm",
-                name: "configure",
-                message: "Would you like to configure optional fields?",
-                default: false
-              }
-            ]);
-          } catch (error) {
-            if (this.isUserCancellation(error)) {
-              console.log(chalk.yellow("\n\nOperation cancelled by user"));
-              process.exit(0);
+      }
+      let shouldConfigureOptional = { configure: false };
+      if (newOptionalFields.length > 0) {
+        console.log(
+          chalk.gray(
+            `
+There are ${newOptionalFields.length} ${iteration === 1 ? "" : "additional "}optional field(s) available.`
+          )
+        );
+        try {
+          shouldConfigureOptional = await inquirer.prompt([
+            {
+              type: "confirm",
+              name: "configure",
+              message: `Would you like to configure ${iteration === 1 ? "" : "these additional "}optional fields?`,
+              default: false
             }
-            throw error;
+          ]);
+        } catch (error) {
+          if (this.isUserCancellation(error)) {
+            console.log(chalk.yellow("\n\nOperation cancelled by user"));
+            process.exit(0);
           }
-          if (shouldConfigureOptional.configure) {
-            console.log(chalk.cyan(`
+          throw error;
+        }
+        if (shouldConfigureOptional.configure) {
+          console.log(chalk.cyan(`
 Optional fields:`));
-            for (const field of optionalFields) {
-              await this.promptForField(field, inputs);
-            }
+          for (const field of newOptionalFields) {
+            await this.promptForField(field, inputs);
+            processedFieldKeys.add(field.key);
           }
+        } else {
+          newOptionalFields.forEach(
+            (field) => processedFieldKeys.add(field.key)
+          );
         }
-        return inputs;
-      } catch (error) {
-        console.error(
-          chalk.red(`Failed to fetch fields for ${param.name}:`),
-          error instanceof Error ? error.message : error
-        );
-        throw error;
+      }
+      if (newRequiredFields.length === 0 && (!newOptionalFields.length || !shouldConfigureOptional.configure)) {
+        break;
       }
     }
-    throw new Error(`Unknown resolver type for ${param.name}`);
+    if (iteration >= maxIterations) {
+      console.log(
+        chalk.yellow(
+          `
+\u26A0\uFE0F  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`
+        )
+      );
+    }
+    return inputs;
   }
-  getNestedValue(obj, path) {
-    return path.reduce((current, key) => current?.[key], obj);
+  getNestedValue(obj, path3) {
+    return path3.reduce((current, key) => current?.[key], obj);
   }
-  setNestedValue(obj, path, value) {
-    const lastKey = path[path.length - 1];
-    const parent = path.slice(0, -1).reduce((current, key) => {
+  setNestedValue(obj, path3, value) {
+    const lastKey = path3[path3.length - 1];
+    const parent = path3.slice(0, -1).reduce((current, key) => {
       if (!(key in current)) {
         current[key] = {};
       }
@@ -302,86 +391,8 @@ Optional fields:`));
   }
 };
 
-// src/utils/pager.ts
-import inquirer2 from "inquirer";
-import chalk2 from "chalk";
-var Pager = class {
-  constructor(options = {}) {
-    this.allItems = [];
-    this.currentOffset = 0;
-    this.pageSize = options.pageSize || 20;
-    this.showPrompt = options.showPrompt !== false;
-    this.itemName = options.itemName || "items";
-  }
-  /**
-   * Fetch and display paginated results with interactive loading
-   */
-  async paginate(fetchFunction, baseParams, displayFunction) {
-    let hasMore = true;
-    let totalAvailable;
-    while (hasMore) {
-      const params = {
-        ...baseParams,
-        limit: this.pageSize,
-        offset: this.currentOffset
-      };
-      try {
-        const items = await fetchFunction(params);
-        if (items.length === 0) {
-          displayFunction(this.allItems, this.allItems.length, totalAvailable);
-          hasMore = false;
-          break;
-        }
-        const pagination = items.__pagination;
-        if (pagination && pagination.count) {
-          totalAvailable = pagination.count;
-          hasMore = pagination.hasNext;
-        } else {
-          hasMore = items.length >= this.pageSize;
-        }
-        this.allItems.push(...items);
-        this.currentOffset += items.length;
-        displayFunction(this.allItems, this.allItems.length, totalAvailable);
-        if (!this.showPrompt) {
-          continue;
-        }
-        const totalInfo = totalAvailable ? ` of ${totalAvailable.toLocaleString()}` : "";
-        const message = `Load more ${this.itemName}? (${this.allItems.length}${totalInfo} shown so far)`;
-        const { loadMore } = await inquirer2.prompt([
-          {
-            type: "confirm",
-            name: "loadMore",
-            message,
-            default: true
-          }
-        ]);
-        if (!loadMore) {
-          hasMore = false;
-        }
-      } catch (error) {
-        throw error;
-      }
-    }
-    return {
-      items: this.allItems,
-      hasMore: this.currentOffset > 0 && hasMore,
-      totalShown: this.allItems.length
-    };
-  }
-  /**
-   * Reset the pager state
-   */
-  reset() {
-    this.allItems = [];
-    this.currentOffset = 0;
-  }
-};
-function createPager(options = {}) {
-  return new Pager(options);
-}
-
 // src/utils/schema-formatter.ts
-import chalk3 from "chalk";
+import chalk2 from "chalk";
 function getFormatMetadata(schema) {
   return schema?._def?.formatMeta;
 }
@@ -405,9 +416,9 @@ function formatItemsFromSchema(inputSchema, items) {
 }
 function formatSingleItem(item, index, formatMeta) {
   const formatted = formatMeta.format(item);
-  let titleLine = `${chalk3.gray(`${index + 1}.`)} ${chalk3.cyan(formatted.title)}`;
+  let titleLine = `${chalk2.gray(`${index + 1}.`)} ${chalk2.cyan(formatted.title)}`;
   if (formatted.subtitle) {
-    titleLine += ` ${chalk3.gray(formatted.subtitle)}`;
+    titleLine += ` ${chalk2.gray(formatted.subtitle)}`;
   }
   console.log(titleLine);
   for (const detail of formatted.details) {
@@ -419,35 +430,36 @@ function formatSingleItem(item, index, formatMeta) {
 function applyStyle(value, style) {
   switch (style) {
     case "dim":
-      return chalk3.dim(value);
+      return chalk2.dim(value);
     case "accent":
-      return chalk3.magenta(value);
+      return chalk2.magenta(value);
     case "warning":
-      return chalk3.red(value);
+      return chalk2.red(value);
     case "success":
-      return chalk3.green(value);
+      return chalk2.green(value);
     case "normal":
     default:
-      return chalk3.blue(value);
+      return chalk2.blue(value);
   }
 }
 function formatItemsGeneric(items) {
   items.forEach((item, index) => {
-    const name = item.name || item.key || item.id || "Item";
-    console.log(`${chalk3.gray(`${index + 1}.`)} ${chalk3.cyan(name)}`);
+    const name = item.title || item.name || item.key || item.id || "Item";
+    console.log(`${chalk2.gray(`${index + 1}.`)} ${chalk2.cyan(name)}`);
     if (item.description) {
-      console.log(`   ${chalk3.dim(item.description)}`);
+      console.log(`   ${chalk2.dim(item.description)}`);
     }
     console.log();
   });
 }
 
 // src/utils/cli-generator.ts
-import chalk4 from "chalk";
+import chalk3 from "chalk";
 import util from "util";
+import inquirer2 from "inquirer";
 function formatJsonOutput(data) {
   if (data && typeof data === "object" && !Array.isArray(data) && (data.success !== void 0 || data.id || data.status)) {
-    console.log(chalk4.green("\u2705 Action completed successfully!\n"));
+    console.log(chalk3.green("\u2705 Action completed successfully!\n"));
   }
   console.log(
     util.inspect(data, { colors: true, depth: null, breakLength: 80 })
@@ -541,10 +553,9 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk2) {
       const options = commandObj.opts();
       const isListCommand = cliCommandName.startsWith("list-");
       const hasPaginationParams = parameters.some(
-        (p) => p.name === "limit" || p.name === "offset"
+        (p) => p.name === "maxItems" || p.name === "pageSize"
       );
-      const hasUserSpecifiedLimit = "limit" in options && options.limit !== void 0;
-      const shouldUsePaging = isListCommand && hasPaginationParams && !hasUserSpecifiedLimit;
+      const hasUserSpecifiedMaxItems = "maxItems" in options && options.maxItems !== void 0;
       const shouldUseJson = options.json;
       const rawParams = convertCliArgsToSdkParams(
         parameters,
@@ -557,55 +568,61 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk2) {
         rawParams,
         sdk2
       );
-      if (shouldUsePaging && !shouldUseJson) {
-        await handlePaginatedList(sdkMethodName, resolvedParams, sdk2, schema);
+      const hasOutputFile = resolvedParams.output;
+      if (hasOutputFile) {
+        await sdk2[sdkMethodName](resolvedParams);
+        console.log(
+          chalk3.green(`\u2705 ${cliCommandName} completed successfully!`)
+        );
+        console.log(chalk3.gray(`Output written to: ${resolvedParams.output}`));
+        return;
+      }
+      if (isListCommand && hasPaginationParams && !shouldUseJson && !hasUserSpecifiedMaxItems) {
+        const sdkIterator = sdk2[sdkMethodName](resolvedParams);
+        await handlePaginatedListWithAsyncIteration(
+          sdkMethodName,
+          sdkIterator,
+          schema
+        );
       } else {
         const result = await sdk2[sdkMethodName](resolvedParams);
-        const hasOutputFile = resolvedParams.output;
-        if (!hasOutputFile && (shouldUseJson || !isListCommand)) {
-          if (shouldUseJson) {
-            console.log(JSON.stringify(result, null, 2));
-          } else {
-            formatJsonOutput(result);
-          }
-        } else if (!hasOutputFile) {
+        const items = result?.data ? result.data : result;
+        if (shouldUseJson) {
+          console.log(JSON.stringify(items, null, 2));
+        } else if (isListCommand) {
           formatNonPaginatedResults(
-            result,
-            resolvedParams.limit,
-            hasUserSpecifiedLimit,
+            items,
+            resolvedParams.maxItems,
+            hasUserSpecifiedMaxItems,
             shouldUseJson,
             schema,
             sdkMethodName
           );
-        } else if (hasOutputFile) {
-          console.log(
-            chalk4.green(`\u2705 ${cliCommandName} completed successfully!`)
-          );
-          console.log(
-            chalk4.gray(`Output written to: ${resolvedParams.output}`)
-          );
+        } else {
+          formatJsonOutput(items);
         }
       }
     } catch (error) {
       if (error instanceof Error && error.message.includes('"code"')) {
         try {
           const validationErrors = JSON.parse(error.message);
-          console.error(chalk4.red("\u274C Validation Error:"));
+          console.error(chalk3.red("\u274C Validation Error:"));
           validationErrors.forEach((err) => {
             const field = err.path?.join(".") || "unknown";
-            console.error(chalk4.yellow(`  \u2022 ${field}: ${err.message}`));
+            console.error(chalk3.yellow(`  \u2022 ${field}: ${err.message}`));
           });
           console.error(
-            "\n" + chalk4.dim(`Use --help to see available options`)
+            "\n" + chalk3.dim(`Use --help to see available options`)
           );
         } catch {
-          console.error(chalk4.red("Error:"), error.message);
+          console.error(chalk3.red("Error:"), error.message);
         }
+      } else if (error instanceof ZapierError) {
+        const formattedMessage = formatErrorMessage(error);
+        console.error(chalk3.red("\u274C Error:"), formattedMessage);
       } else {
-        console.error(
-          chalk4.red("Error:"),
-          error instanceof Error ? error.message : "Unknown error"
-        );
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        console.error(chalk3.red("\u274C Error:"), errorMessage);
       }
       process.exit(1);
     }
@@ -639,6 +656,9 @@ function addCommand(program2, commandName, config) {
       const flags = [`--${kebabName}`];
       if (param.type === "boolean") {
         command.option(flags.join(", "), param.description);
+      } else if (param.type === "array") {
+        const flagSignature = flags.join(", ") + ` <values...>`;
+        command.option(flagSignature, param.description, param.default);
       } else {
         const flagSignature = flags.join(", ") + ` <${param.type}>`;
         command.option(flagSignature, param.description, param.default);
@@ -689,45 +709,84 @@ function convertValue(value, type) {
       return value;
   }
 }
-async function handlePaginatedList(sdkMethodName, baseParams, sdk2, schema) {
-  const limit = baseParams.limit || 20;
+async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, schema) {
   const itemName = getItemNameFromMethod(sdkMethodName);
-  console.log(chalk4.blue(`\u{1F4CB} Fetching ${itemName}...`));
-  const pager = createPager({
-    pageSize: Math.min(limit, 20),
-    itemName
-  });
-  const displayFunction = (items, totalShown, totalAvailable) => {
-    if (items.length > 0) {
-      console.clear();
-    }
-    console.log(chalk4.blue(`\u{1F4CB} ${getListTitleFromMethod(sdkMethodName)}
+  let totalShown = 0;
+  let pageCount = 0;
+  console.log(chalk3.blue(`\u{1F4CB} ${getListTitleFromMethod(sdkMethodName)}
 `));
-    if (items.length === 0) {
-      console.log(chalk4.yellow(`No ${itemName} found.`));
-      return;
+  try {
+    for await (const page of sdkResult) {
+      const items = page.data || page;
+      pageCount++;
+      if (!Array.isArray(items)) {
+        console.log(chalk3.yellow(`No ${itemName} found.`));
+        return;
+      }
+      if (items.length === 0 && pageCount === 1) {
+        console.log(chalk3.yellow(`No ${itemName} found.`));
+        return;
+      }
+      if (items.length === 0) {
+        break;
+      }
+      if (pageCount > 1) {
+        console.clear();
+        console.log(
+          chalk3.blue(`\u{1F4CB} ${getListTitleFromMethod(sdkMethodName)}
+`)
+        );
+      }
+      if (schema) {
+        formatItemsFromSchema(schema, items);
+      } else {
+        formatItemsGeneric2(items);
+      }
+      totalShown += items.length;
+      console.log(
+        chalk3.green(
+          `
+\u2705 Showing ${totalShown} ${itemName} (page ${pageCount})`
+        )
+      );
+      if (page.nextCursor) {
+        const { continueReading } = await inquirer2.prompt([
+          {
+            type: "confirm",
+            name: "continueReading",
+            message: `Load next page?`,
+            default: true
+          }
+        ]);
+        if (!continueReading) {
+          break;
+        }
+      } else {
+        break;
+      }
     }
-    if (schema) {
-      formatItemsFromSchema(schema, items);
+    console.log(chalk3.gray(`
+\u{1F4C4} Finished browsing ${itemName}`));
+  } catch (error) {
+    const items = sdkResult?.data || sdkResult;
+    if (Array.isArray(items)) {
+      if (items.length === 0) {
+        console.log(chalk3.yellow(`No ${itemName} found.`));
+        return;
+      }
+      if (schema) {
+        formatItemsFromSchema(schema, items);
+      } else {
+        formatItemsGeneric2(items);
+      }
+      console.log(chalk3.green(`
+\u2705 Showing ${items.length} ${itemName}`));
     } else {
-      formatItemsGeneric2(items);
+      throw error;
     }
-    const totalInfo = totalAvailable ? ` of ${totalAvailable.toLocaleString()} total` : "";
-    console.log(
-      chalk4.green(`
-\u2705 Showing ${totalShown}${totalInfo} ${itemName}`)
-    );
-  };
-  await pager.paginate(
-    (params) => sdk2[sdkMethodName]({
-      ...baseParams,
-      ...params
-    }),
-    {},
-    displayFunction
-  );
+  }
 }
-function formatNonPaginatedResults(result, requestedLimit, userSpecifiedLimit, useRawJson, schema, methodName) {
+function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxItems, useRawJson, schema, methodName) {
   if (!Array.isArray(result)) {
     if (useRawJson) {
       console.log(JSON.stringify(result, null, 2));
@@ -742,10 +801,10 @@ function formatNonPaginatedResults(result, requestedLimit, userSpecifiedLimit, u
   }
   const itemName = methodName ? getItemNameFromMethod(methodName) : "items";
   if (result.length === 0) {
-    console.log(chalk4.yellow(`No ${itemName} found.`));
+    console.log(chalk3.yellow(`No ${itemName} found.`));
     return;
   }
-  console.log(chalk4.green(`
+  console.log(chalk3.green(`
 \u2705 Found ${result.length} ${itemName}:
 `));
   if (schema) {
@@ -753,24 +812,24 @@ function formatNonPaginatedResults(result, requestedLimit, userSpecifiedLimit, u
   } else {
     formatItemsGeneric2(result);
   }
-  if (userSpecifiedLimit && requestedLimit) {
+  if (userSpecifiedMaxItems && requestedMaxItems) {
     console.log(
-      chalk4.gray(
+      chalk3.gray(
         `
-\u{1F4C4} Showing up to ${requestedLimit} ${itemName} (--limit ${requestedLimit})`
+\u{1F4C4} Showing up to ${requestedMaxItems} ${itemName} (--max-items ${requestedMaxItems})`
       )
     );
   } else {
-    console.log(chalk4.gray(`
+    console.log(chalk3.gray(`
 \u{1F4C4} All available ${itemName} shown`));
   }
 }
 function formatItemsGeneric2(items) {
   items.forEach((item, index) => {
-    const name = item.name || item.key || item.id || "Item";
-    console.log(`${chalk4.gray(`${index + 1}.`)} ${chalk4.cyan(name)}`);
+    const name = item.title || item.name || item.key || item.id || "Item";
+    console.log(`${chalk3.gray(`${index + 1}.`)} ${chalk3.cyan(name)}`);
     if (item.description) {
-      console.log(`   ${chalk4.dim(item.description)}`);
+      console.log(`   ${chalk3.dim(item.description)}`);
     }
     console.log();
   });
@@ -820,19 +879,19 @@ var spinPromise = async (promise, text) => {
 };
 
 // src/utils/log.ts
-import chalk5 from "chalk";
+import chalk4 from "chalk";
 var log = {
   info: (message, ...args) => {
-    console.log(chalk5.blue("\u2139"), message, ...args);
+    console.log(chalk4.blue("\u2139"), message, ...args);
   },
   error: (message, ...args) => {
-    console.error(chalk5.red("\u2716"), message, ...args);
+    console.error(chalk4.red("\u2716"), message, ...args);
   },
   success: (message, ...args) => {
-    console.log(chalk5.green("\u2713"), message, ...args);
+    console.log(chalk4.green("\u2713"), message, ...args);
   },
   warn: (message, ...args) => {
-    console.log(chalk5.yellow("\u26A0"), message, ...args);
+    console.log(chalk4.yellow("\u26A0"), message, ...args);
   }
 };
 var log_default = log;
@@ -868,17 +927,17 @@ var client_default = api;
 
 // src/utils/getCallablePromise.ts
 var getCallablePromise = () => {
-  let resolve = () => {
+  let resolve2 = () => {
   };
   let reject = () => {
   };
   const promise = new Promise((_resolve, _reject) => {
-    resolve = _resolve;
+    resolve2 = _resolve;
     reject = _reject;
   });
   return {
     promise,
-    resolve,
+    resolve: resolve2,
     reject
   };
 };
@@ -887,12 +946,12 @@ var getCallablePromise_default = getCallablePromise;
 // src/utils/auth/login.ts
 import { updateLogin, logout } from "@zapier/zapier-sdk-cli-login";
 var findAvailablePort = () => {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let portIndex = 0;
     const tryPort = (port) => {
       const server = express().listen(port, () => {
         server.close();
-        resolve(port);
+        resolve2(port);
       });
       server.on("error", (err) => {
         if (err.code === "EADDRINUSE") {
@@ -982,15 +1041,15 @@ var login = async (timeoutMs = LOGIN_TIMEOUT_MS) => {
   } finally {
     process.off("SIGINT", cleanup);
     process.off("SIGTERM", cleanup);
-    await new Promise((resolve) => {
+    await new Promise((resolve2) => {
       const timeout = setTimeout(() => {
         log_default.info("Server close timed out, forcing connection shutdown...");
         connections.forEach((conn) => conn.destroy());
-        resolve();
+        resolve2();
       }, 1e3);
       server.close(() => {
         clearTimeout(timeout);
-        resolve();
+        resolve2();
       });
     });
   }
@@ -1062,47 +1121,665 @@ function createLogoutCommand() {
   });
 }
 
-// src/commands/whoami.ts
+// src/commands/configPath.ts
 import { Command as Command3 } from "commander";
-import { getLoggedInUser as getLoggedInUser2 } from "@zapier/zapier-sdk-cli-login";
-function createWhoamiCommand() {
-  return new Command3("whoami").description("Show current login status and user information").action(async () => {
+import { getConfigPath } from "@zapier/zapier-sdk-cli-login";
+function createConfigPathCommand() {
+  return new Command3("get-config-path").description("Show the path to the configuration file").action(async () => {
+    console.log(`Configuration file: ${getConfigPath()}`);
+  });
+}
+
+// src/commands/generate-types/cli.ts
+import { Command as Command4 } from "commander";
+import { createZapierSdk } from "@zapier/zapier-sdk";
+
+// src/commands/generate-types/schemas.ts
+import { z as z3 } from "zod";
+import {
+  AppKeyPropertySchema,
+  AuthenticationIdPropertySchema,
+  OutputPropertySchema,
+  DebugPropertySchema
+} from "@zapier/zapier-sdk";
+var GenerateTypesSchema = z3.object({
+  appKey: AppKeyPropertySchema.describe("App key to generate SDK code for"),
+  authenticationId: AuthenticationIdPropertySchema.optional(),
+  output: OutputPropertySchema.optional().describe(
+    "Output file path (defaults to generated/<appKey>.ts)"
+  ),
+  debug: DebugPropertySchema.describe(
+    "Enable debug logging during generation"
+  )
+}).describe("Generate TypeScript SDK code for a specific app");
+
+// src/commands/generate-types/index.ts
+import * as fs from "fs";
+import * as path from "path";
+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.mkdirSync(path.dirname(output), { recursive: true });
+      fs.writeFileSync(output, typeDefinitions2, "utf8");
+    }
+    return typeDefinitions2;
+  }
+  const actionsWithFields = [];
+  if (authenticationId) {
+    for (const action of actions) {
+      try {
+        const fieldsResult = await sdk2.listInputFields({
+          appKey: action.app_key,
+          actionKey: action.key,
+          actionType: action.action_type,
+          authenticationId
+        });
+        const fields = fieldsResult.data;
+        actionsWithFields.push({ ...action, inputFields: fields });
+      } catch {
+        actionsWithFields.push({ ...action, inputFields: [] });
+      }
+    }
+  } else {
+    actions.forEach((action) => {
+      actionsWithFields.push({ ...action, inputFields: [] });
+    });
+  }
+  const typeDefinitions = generateTypeDefinitions(
+    app,
+    actionsWithFields,
+    version
+  );
+  if (output) {
+    fs.mkdirSync(path.dirname(output), { recursive: true });
+    fs.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";
+  }
+}
+
+// src/commands/generate-types/cli.ts
+import chalk5 from "chalk";
+
+// src/utils/cli-generator-utils.ts
+import { z as z4 } from "zod";
+import { hasResolver as hasResolver3, isPositional as isPositional2 } from "@zapier/zapier-sdk";
+function analyzeZodSchema2(schema) {
+  const parameters = [];
+  if (schema instanceof z4.ZodObject) {
+    const shape = schema.shape;
+    for (const [key, fieldSchema] of Object.entries(shape)) {
+      const param = analyzeZodField2(key, fieldSchema);
+      if (param) {
+        parameters.push(param);
+      }
+    }
+  }
+  return parameters;
+}
+function analyzeZodField2(name, schema) {
+  let baseSchema = schema;
+  let required = true;
+  let defaultValue = void 0;
+  if (baseSchema instanceof z4.ZodOptional) {
+    required = false;
+    baseSchema = baseSchema._def.innerType;
+  }
+  if (baseSchema instanceof z4.ZodDefault) {
+    required = false;
+    defaultValue = baseSchema._def.defaultValue();
+    baseSchema = baseSchema._def.innerType;
+  }
+  let paramType = "string";
+  let choices;
+  if (baseSchema instanceof z4.ZodString) {
+    paramType = "string";
+  } else if (baseSchema instanceof z4.ZodNumber) {
+    paramType = "number";
+  } else if (baseSchema instanceof z4.ZodBoolean) {
+    paramType = "boolean";
+  } else if (baseSchema instanceof z4.ZodArray) {
+    paramType = "array";
+  } else if (baseSchema instanceof z4.ZodEnum) {
+    paramType = "string";
+    choices = baseSchema._def.values;
+  } else if (baseSchema instanceof z4.ZodRecord) {
+    paramType = "string";
+  }
+  return {
+    name,
+    type: paramType,
+    required,
+    description: schema.description,
+    default: defaultValue,
+    choices,
+    hasResolver: hasResolver3(name),
+    isPositional: isPositional2(schema)
+  };
+}
+function convertCliArgsToSdkParams2(parameters, positionalArgs, options) {
+  const sdkParams = {};
+  let argIndex = 0;
+  parameters.forEach((param) => {
+    if ((param.required || param.isPositional) && argIndex < positionalArgs.length) {
+      sdkParams[param.name] = convertValue2(
+        positionalArgs[argIndex],
+        param.type
+      );
+      argIndex++;
+    }
+  });
+  Object.entries(options).forEach(([key, value]) => {
+    const camelKey = key.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+    const param = parameters.find((p) => p.name === camelKey);
+    if (param && value !== void 0) {
+      sdkParams[camelKey] = convertValue2(value, param.type);
+    }
+  });
+  return sdkParams;
+}
+function convertValue2(value, type) {
+  switch (type) {
+    case "number":
+      return Number(value);
+    case "boolean":
+      return Boolean(value);
+    case "array":
+      return Array.isArray(value) ? value : [value];
+    case "string":
+    default:
+      if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
+        try {
+          return JSON.parse(value);
+        } catch {
+          return value;
+        }
+      }
+      return value;
+  }
+}
+
+// src/commands/generate-types/cli.ts
+function createGenerateTypesCommand() {
+  const parameters = analyzeZodSchema2(GenerateTypesSchema);
+  const description = GenerateTypesSchema.description || "Generate TypeScript SDK types for a specific app";
+  const command = new Command4("generate-types").description(description);
+  parameters.forEach((param) => {
+    const kebabName = param.name.replace(/([A-Z])/g, "-$1").toLowerCase();
+    if (param.hasResolver && param.required) {
+      command.argument(
+        `[${kebabName}]`,
+        param.description || `${kebabName} parameter`
+      );
+    } else if (param.required) {
+      command.argument(
+        `<${kebabName}>`,
+        param.description || `${kebabName} parameter`
+      );
+    } else if (param.isPositional) {
+      command.argument(
+        `[${kebabName}]`,
+        param.description || `${kebabName} parameter`
+      );
+    } else {
+      const flags = [`--${kebabName}`];
+      if (param.type === "boolean") {
+        command.option(flags.join(", "), param.description);
+      } else {
+        const flagSignature = flags.join(", ") + ` <${param.type}>`;
+        command.option(flagSignature, param.description, param.default);
+      }
+    }
+  });
+  command.option("--json", "Output raw JSON instead of formatted results");
+  command.action(async (...args) => {
     try {
-      const user = await spinPromise(
-        getLoggedInUser2(),
-        "Checking login status..."
+      const commandObj = args[args.length - 1];
+      const options = commandObj.opts();
+      const rawParams = convertCliArgsToSdkParams2(
+        parameters,
+        args.slice(0, -1),
+        options
       );
-      console.log(
-        `\u2705 Logged in as ${user.email} (Account ID: ${user.accountId})`
+      const sdk2 = createZapierSdk();
+      const resolver = new SchemaParameterResolver();
+      const resolvedParams = await resolver.resolveParameters(
+        GenerateTypesSchema,
+        rawParams,
+        sdk2
       );
-    } catch {
       console.log(
-        "\u274C Not logged in. Use 'zapier-sdk login' to authenticate."
+        chalk5.blue(
+          `\u{1F527} Generating TypeScript types for ${resolvedParams.appKey}...`
+        )
+      );
+      const result = await generateTypes({ ...resolvedParams, sdk: sdk2 });
+      if (options.json) {
+        console.log(JSON.stringify({ result }, null, 2));
+      } else {
+        const output = resolvedParams.output || `./types/${resolvedParams.appKey}.d.ts`;
+        console.log(chalk5.green("\u2705 TypeScript types generated successfully!"));
+        console.log(chalk5.gray(`Output written to: ${output}`));
+      }
+    } catch (error) {
+      console.error(
+        chalk5.red("Error:"),
+        error instanceof Error ? error.message : "Unknown error"
       );
       process.exit(1);
     }
   });
+  return command;
 }
 
-// src/commands/configPath.ts
-import { Command as Command4 } from "commander";
-import { getConfigPath } from "@zapier/zapier-sdk-cli-login";
-function createConfigPathCommand() {
-  return new Command4("get-config-path").description("Show the path to the configuration file").action(async () => {
-    console.log(`Configuration file: ${getConfigPath()}`);
+// src/commands/bundle-code/cli.ts
+import { Command as Command5 } from "commander";
+
+// src/commands/bundle-code/schemas.ts
+import { z as z5 } from "zod";
+import { OutputPropertySchema as OutputPropertySchema2 } from "@zapier/zapier-sdk";
+var BundleCodeSchema = z5.object({
+  input: z5.string().min(1).describe("Input TypeScript file path to bundle"),
+  output: OutputPropertySchema2.optional().describe(
+    "Output file path (defaults to input with .js extension)"
+  ),
+  string: z5.boolean().default(false).describe("Return bundled code as string instead of writing to file"),
+  minify: z5.boolean().default(false).describe("Minify the bundled output"),
+  target: z5.string().default("es2017").describe("ECMAScript target version"),
+  cjs: z5.boolean().default(false).describe("Output CommonJS format instead of ESM")
+}).describe("Bundle TypeScript code into executable JavaScript");
+
+// src/commands/bundle-code/index.ts
+import { buildSync } from "esbuild";
+import * as fs2 from "fs";
+import * as path2 from "path";
+var ZapierBundleError = class extends Error {
+  constructor(message, details, originalError) {
+    super(message);
+    this.code = "ZAPIER_BUNDLE_ERROR";
+    this.name = "ZapierBundleError";
+    this.details = details;
+    this.originalError = originalError;
+  }
+};
+async function bundleCode(options) {
+  const {
+    input,
+    output,
+    target = "es2020",
+    cjs = false,
+    minify = false,
+    string: returnString = false
+  } = options;
+  const resolvedInput = path2.resolve(process.cwd(), input);
+  try {
+    const result = buildSync({
+      entryPoints: [resolvedInput],
+      bundle: true,
+      platform: "node",
+      target,
+      format: cjs ? "cjs" : "esm",
+      minify,
+      write: false,
+      external: [],
+      // Bundle everything
+      banner: {
+        js: "#!/usr/bin/env node"
+      }
+    });
+    if (result.errors.length > 0) {
+      const errorMessages = result.errors.map((e) => e.text);
+      throw new ZapierBundleError(
+        `Bundle failed: ${errorMessages.join(", ")}`,
+        errorMessages
+      );
+    }
+    const bundledCode = result.outputFiles?.[0]?.text;
+    if (!bundledCode) {
+      throw new ZapierBundleError("No output generated");
+    }
+    let finalOutput = bundledCode;
+    if (returnString) {
+      finalOutput = JSON.stringify(bundledCode);
+    }
+    if (output) {
+      fs2.mkdirSync(path2.dirname(output), { recursive: true });
+      fs2.writeFileSync(output, finalOutput, "utf8");
+    }
+    return finalOutput;
+  } catch (error) {
+    if (error instanceof ZapierBundleError) {
+      throw error;
+    }
+    throw new ZapierBundleError(
+      `Bundle failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+      void 0,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+
+// src/commands/bundle-code/cli.ts
+import chalk6 from "chalk";
+function createBundleCodeCommand() {
+  const parameters = analyzeZodSchema2(BundleCodeSchema);
+  const description = BundleCodeSchema.description || "Bundle TypeScript code into executable JavaScript";
+  const command = new Command5("bundle-code").description(description);
+  parameters.forEach((param) => {
+    const kebabName = param.name.replace(/([A-Z])/g, "-$1").toLowerCase();
+    if (param.hasResolver && param.required) {
+      command.argument(
+        `[${kebabName}]`,
+        param.description || `${kebabName} parameter`
+      );
+    } else if (param.required) {
+      command.argument(
+        `<${kebabName}>`,
+        param.description || `${kebabName} parameter`
+      );
+    } else if (param.isPositional) {
+      command.argument(
+        `[${kebabName}]`,
+        param.description || `${kebabName} parameter`
+      );
+    } else {
+      const flags = [`--${kebabName}`];
+      if (param.type === "boolean") {
+        command.option(flags.join(", "), param.description);
+      } else {
+        const flagSignature = flags.join(", ") + ` <${param.type}>`;
+        command.option(flagSignature, param.description, param.default);
+      }
+    }
   });
+  command.option("--json", "Output raw JSON instead of formatted results");
+  command.action(async (...args) => {
+    try {
+      const commandObj = args[args.length - 1];
+      const options = commandObj.opts();
+      const rawParams = convertCliArgsToSdkParams2(
+        parameters,
+        args.slice(0, -1),
+        options
+      );
+      if (!rawParams.input) {
+        throw new Error("Input file path is required");
+      }
+      console.log(chalk6.blue(`\u{1F4E6} Bundling ${rawParams.input}...`));
+      const result = await bundleCode(rawParams);
+      if (options.json) {
+        console.log(JSON.stringify({ result }, null, 2));
+      } else if (rawParams.output && !rawParams.string) {
+        console.log(chalk6.green("\u2705 Bundle created successfully!"));
+        console.log(chalk6.gray(`Output written to: ${rawParams.output}`));
+      } else if (rawParams.string) {
+        console.log(chalk6.green("\u2705 Bundle generated as string!"));
+        console.log("\n" + result);
+      } else {
+        console.log(chalk6.green("\u2705 Bundle completed!"));
+        console.log("\n" + result);
+      }
+    } catch (error) {
+      console.error(
+        chalk6.red("Error:"),
+        error instanceof Error ? error.message : "Unknown error"
+      );
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/mcp.ts
+import { Command as Command6 } from "commander";
+import { startMcpServerAsProcess } from "@zapier/zapier-sdk-mcp";
+function createMcpCommand() {
+  const command = new Command6("mcp");
+  command.description("Start MCP server for Zapier SDK").option("--debug", "Enable debug logging").option("--port <port>", "Port to listen on (for future HTTP transport)").action(startMcpServerAsProcess);
+  return command;
 }
 
 // src/cli.ts
-var program = new Command5();
+var program = new Command7();
 program.name("zapier-sdk").description("CLI for Zapier SDK - Commands auto-generated from SDK schemas").version("1.0.0").option("--debug", "Enable debug logging");
 var isDebugMode = process.env.DEBUG === "true" || process.argv.includes("--debug");
-var sdk = createZapierSdk({
+var sdk = createZapierSdk2({
   debug: isDebugMode
 });
 program.addCommand(createLoginCommand());
 program.addCommand(createLogoutCommand());
-program.addCommand(createWhoamiCommand());
-program.addCommand(createConfigPathCommand());
 generateCliCommands(program, sdk);
+program.addCommand(createGenerateTypesCommand());
+program.addCommand(createBundleCodeCommand());
+program.addCommand(createConfigPathCommand());
+program.addCommand(createMcpCommand());
 program.parse();