@zapier/zapier-sdk-cli 0.6.3 → 0.6.5

package/dist/cli.cjs

@@ -0,0 +1,1715 @@
+#!/usr/bin/env node
+'use strict';
+
+var commander = require('commander');
+var zod = require('zod');
+var zapierSdk = require('@zapier/zapier-sdk');
+var inquirer = require('inquirer');
+var chalk3 = require('chalk');
+var util = require('util');
+var open = require('open');
+var crypto = require('crypto');
+var express = require('express');
+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 fs = require('fs');
+var path = require('path');
+var esbuild = require('esbuild');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var inquirer__default = /*#__PURE__*/_interopDefault(inquirer);
+var chalk3__default = /*#__PURE__*/_interopDefault(chalk3);
+var util__default = /*#__PURE__*/_interopDefault(util);
+var open__default = /*#__PURE__*/_interopDefault(open);
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var express__default = /*#__PURE__*/_interopDefault(express);
+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 SchemaParameterResolver = class {
+  async resolveParameters(schema, providedParams, sdk2) {
+    const parseResult = schema.safeParse(providedParams);
+    const allParams = this.extractParametersFromSchema(schema);
+    const resolvableParams = allParams.filter(
+      (param) => zapierSdk.hasResolver(param.name)
+    );
+    const missingResolvable = resolvableParams.filter((param) => {
+      const hasValue = this.getNestedValue(providedParams, param.path) !== void 0;
+      return !hasValue;
+    });
+    const functionallyRequired = missingResolvable.filter((param) => {
+      if (param.isRequired) return true;
+      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) && !alwaysPrompt.includes(param)
+    );
+    if (parseResult.success && functionallyRequired.length === 0 && alwaysPrompt.length === 0) {
+      return parseResult.data;
+    }
+    if (functionallyRequired.length === 0 && alwaysPrompt.length === 0) {
+      if (!parseResult.success) {
+        throw parseResult.error;
+      }
+      return parseResult.data;
+    }
+    const resolvedParams = { ...providedParams };
+    const context = {
+      sdk: sdk2,
+      currentParams: providedParams,
+      resolvedParams
+    };
+    if (functionallyRequired.length > 0) {
+      const requiredParamNames = functionallyRequired.map((p) => p.name);
+      const requiredResolutionOrder = zapierSdk.getResolutionOrderForParams(requiredParamNames);
+      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);
+          this.setNestedValue(resolvedParams, param.path, value);
+          context.resolvedParams = resolvedParams;
+        } catch (error) {
+          if (this.isUserCancellation(error)) {
+            console.log(chalk3__default.default.yellow("\n\nOperation cancelled by user"));
+            process.exit(0);
+          }
+          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 = zapierSdk.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(chalk3__default.default.yellow("\n\nOperation cancelled by user"));
+            process.exit(0);
+          }
+          throw error;
+        }
+      }
+    }
+    if (trulyOptional.length > 0) {
+      const optionalNames = trulyOptional.map((p) => p.name).join(", ");
+      const shouldResolveOptional = await inquirer__default.default.prompt([
+        {
+          type: "confirm",
+          name: "resolveOptional",
+          message: `Would you like to be prompted for optional parameters (${optionalNames})?`,
+          default: false
+        }
+      ]);
+      if (shouldResolveOptional.resolveOptional) {
+        const optionalParamNames = trulyOptional.map((p) => p.name);
+        const optionalResolutionOrder = zapierSdk.getResolutionOrderForParams(optionalParamNames);
+        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);
+            this.setNestedValue(resolvedParams, param.path, value);
+            context.resolvedParams = resolvedParams;
+          } catch (error) {
+            if (this.isUserCancellation(error)) {
+              console.log(chalk3__default.default.yellow("\n\nOperation cancelled by user"));
+              process.exit(0);
+            }
+            throw error;
+          }
+        }
+      }
+    }
+    const finalResult = schema.safeParse(resolvedParams);
+    if (!finalResult.success) {
+      console.error(
+        chalk3__default.default.red("\u274C Parameter validation failed after resolution:")
+      );
+      throw finalResult.error;
+    }
+    return finalResult.data;
+  }
+  extractParametersFromSchema(schema) {
+    const parameters = [];
+    if (schema instanceof zod.z.ZodObject) {
+      const shape = schema.shape;
+      for (const [key, fieldSchema] of Object.entries(shape)) {
+        const param = this.analyzeFieldSchema(key, fieldSchema);
+        if (param) {
+          parameters.push(param);
+        }
+      }
+    }
+    return parameters;
+  }
+  analyzeFieldSchema(fieldName, fieldSchema) {
+    let baseSchema = fieldSchema;
+    let isRequired = true;
+    if (baseSchema instanceof zod.z.ZodOptional) {
+      isRequired = false;
+      baseSchema = baseSchema._def.innerType;
+    }
+    if (baseSchema instanceof zod.z.ZodDefault) {
+      isRequired = false;
+      baseSchema = baseSchema._def.innerType;
+    }
+    return this.createResolvableParameter([fieldName], baseSchema, isRequired);
+  }
+  createResolvableParameter(path3, schema, isRequired) {
+    if (path3.length === 0) return null;
+    const name = path3[path3.length - 1];
+    return {
+      name,
+      path: path3,
+      schema,
+      description: schema.description,
+      isRequired
+    };
+  }
+  async resolveParameter(param, context) {
+    const resolver = zapierSdk.getResolver(param.name);
+    if (!resolver) {
+      throw new Error(`No resolver found for parameter: ${param.name}`);
+    }
+    console.log(chalk3__default.default.blue(`
+\u{1F50D} Resolving ${param.name}...`));
+    const typedResolver = resolver;
+    if (typedResolver.type === "static") {
+      const promptConfig = {
+        type: typedResolver.inputType === "password" ? "password" : "input",
+        name: param.name,
+        message: `Enter ${param.name}:`,
+        ...typedResolver.placeholder && {
+          default: typedResolver.placeholder
+        }
+      };
+      const answers = await inquirer__default.default.prompt([promptConfig]);
+      return answers[param.name];
+    } else if (typedResolver.type === "dynamic") {
+      try {
+        if (param.isRequired && param.name !== "authenticationId") {
+          console.log(chalk3__default.default.gray(`Fetching options for ${param.name}...`));
+        }
+        const items = await typedResolver.fetch(
+          context.sdk,
+          context.resolvedParams
+        );
+        const safeItems = items || [];
+        const promptConfig = typedResolver.prompt(
+          safeItems,
+          context.resolvedParams
+        );
+        const answers = await inquirer__default.default.prompt([promptConfig]);
+        return answers[param.name];
+      } catch (error) {
+        throw error;
+      }
+    } else if (typedResolver.type === "fields") {
+      return await this.resolveFieldsRecursively(
+        resolver,
+        context,
+        param
+      );
+    }
+    throw new Error(`Unknown resolver type for ${param.name}`);
+  }
+  async resolveFieldsRecursively(resolver, context, param) {
+    const typedResolver = resolver;
+    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(
+        chalk3__default.default.gray(
+          `Fetching input fields for ${param.name}${iteration > 1 ? ` (iteration ${iteration})` : ""}...`
+        )
+      );
+      const fields = await typedResolver.fetch(
+        updatedContext.sdk,
+        updatedContext.resolvedParams
+      );
+      if (!fields || fields.length === 0) {
+        if (iteration === 1) {
+          console.log(
+            chalk3__default.default.yellow(`No input fields required for this action.`)
+          );
+        }
+        break;
+      }
+      const newFields = fields.filter(
+        (field) => !(field.key && 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(
+          chalk3__default.default.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);
+        }
+      }
+      let shouldConfigureOptional = { configure: false };
+      if (newOptionalFields.length > 0) {
+        console.log(
+          chalk3__default.default.gray(
+            `
+There are ${newOptionalFields.length} ${iteration === 1 ? "" : "additional "}optional field(s) available.`
+          )
+        );
+        try {
+          shouldConfigureOptional = await inquirer__default.default.prompt([
+            {
+              type: "confirm",
+              name: "configure",
+              message: `Would you like to configure ${iteration === 1 ? "" : "these additional "}optional fields?`,
+              default: false
+            }
+          ]);
+        } catch (error) {
+          if (this.isUserCancellation(error)) {
+            console.log(chalk3__default.default.yellow("\n\nOperation cancelled by user"));
+            process.exit(0);
+          }
+          throw error;
+        }
+        if (shouldConfigureOptional.configure) {
+          console.log(chalk3__default.default.cyan(`
+Optional fields:`));
+          for (const field of newOptionalFields) {
+            await this.promptForField(field, inputs);
+            processedFieldKeys.add(field.key);
+          }
+        } else {
+          newOptionalFields.forEach(
+            (field) => processedFieldKeys.add(field.key)
+          );
+        }
+      }
+      if (newRequiredFields.length === 0 && (!newOptionalFields.length || !shouldConfigureOptional.configure)) {
+        break;
+      }
+    }
+    if (iteration >= maxIterations) {
+      console.log(
+        chalk3__default.default.yellow(
+          `
+\u26A0\uFE0F  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`
+        )
+      );
+    }
+    return inputs;
+  }
+  getNestedValue(obj, path3) {
+    return path3.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) => {
+      const currentObj = current;
+      if (!(key in currentObj)) {
+        currentObj[key] = {};
+      }
+      return currentObj[key];
+    }, obj);
+    parent[lastKey] = value;
+  }
+  async promptForField(field, inputs) {
+    const fieldObj = field;
+    const fieldPrompt = {
+      type: fieldObj.type === "boolean" ? "confirm" : "input",
+      name: fieldObj.key,
+      message: `${fieldObj.label || fieldObj.key}${fieldObj.required ? " (required)" : " (optional)"}:`
+    };
+    if (fieldObj.helpText) {
+      fieldPrompt.prefix = chalk3__default.default.gray(`\u2139 ${fieldObj.helpText}
+`);
+    }
+    if (fieldObj.default !== void 0) {
+      fieldPrompt.default = fieldObj.default;
+    }
+    if (fieldObj.choices && fieldObj.choices.length > 0) {
+      fieldPrompt.type = "list";
+      fieldPrompt.choices = fieldObj.choices.map(
+        (choice) => {
+          const choiceObj = choice;
+          return {
+            name: choiceObj.label || choiceObj.value,
+            value: choiceObj.value
+          };
+        }
+      );
+    }
+    try {
+      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) {
+        throw new Error(`Required field ${fieldObj.key} cannot be empty`);
+      }
+    } catch (error) {
+      if (this.isUserCancellation(error)) {
+        console.log(chalk3__default.default.yellow("\n\nOperation cancelled by user"));
+        process.exit(0);
+      }
+      throw error;
+    }
+  }
+  isUserCancellation(error) {
+    const errorObj = error;
+    return errorObj?.name === "ExitPromptError" || errorObj?.message?.includes("User force closed") || errorObj?.isTTYError === true;
+  }
+};
+function getFormatMetadata(schema) {
+  return schema?._def?.formatMeta;
+}
+function getOutputSchema(schema) {
+  return schema?._def?.outputSchema;
+}
+function formatItemsFromSchema(inputSchema, items, startingNumber = 0) {
+  const outputSchema = getOutputSchema(inputSchema);
+  if (!outputSchema) {
+    formatItemsGeneric(items, startingNumber);
+    return;
+  }
+  const formatMeta = getFormatMetadata(outputSchema);
+  if (!formatMeta) {
+    formatItemsGeneric(items, startingNumber);
+    return;
+  }
+  items.forEach((item, index) => {
+    formatSingleItem(item, startingNumber + index, formatMeta);
+  });
+}
+function formatSingleItem(item, itemNumber, formatMeta) {
+  const formatted = formatMeta.format(item);
+  let titleLine = `${chalk3__default.default.gray(`${itemNumber + 1}.`)} ${chalk3__default.default.cyan(formatted.title)}`;
+  if (formatted.subtitle) {
+    titleLine += ` ${chalk3__default.default.gray(formatted.subtitle)}`;
+  }
+  console.log(titleLine);
+  for (const detail of formatted.details) {
+    const styledText = applyStyle(detail.text, detail.style);
+    console.log(`   ${styledText}`);
+  }
+  console.log();
+}
+function applyStyle(value, style) {
+  switch (style) {
+    case "dim":
+      return chalk3__default.default.dim(value);
+    case "accent":
+      return chalk3__default.default.magenta(value);
+    case "warning":
+      return chalk3__default.default.red(value);
+    case "success":
+      return chalk3__default.default.green(value);
+    case "normal":
+    default:
+      return chalk3__default.default.blue(value);
+  }
+}
+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();
+  });
+}
+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) {
+  const parameters = [];
+  if (schema instanceof zod.z.ZodObject) {
+    const shape = schema.shape;
+    for (const [key, fieldSchema] of Object.entries(shape)) {
+      const param = analyzeZodField(key, fieldSchema);
+      if (param) {
+        parameters.push(param);
+      }
+    }
+  }
+  return parameters;
+}
+function analyzeZodField(name, schema) {
+  let baseSchema = schema;
+  let required = true;
+  let defaultValue = void 0;
+  if (baseSchema instanceof zod.z.ZodOptional) {
+    required = false;
+    baseSchema = baseSchema._def.innerType;
+  }
+  if (baseSchema instanceof zod.z.ZodDefault) {
+    required = false;
+    defaultValue = baseSchema._def.defaultValue();
+    baseSchema = baseSchema._def.innerType;
+  }
+  let paramType = "string";
+  let choices;
+  if (baseSchema instanceof zod.z.ZodString) {
+    paramType = "string";
+  } else if (baseSchema instanceof zod.z.ZodNumber) {
+    paramType = "number";
+  } else if (baseSchema instanceof zod.z.ZodBoolean) {
+    paramType = "boolean";
+  } else if (baseSchema instanceof zod.z.ZodArray) {
+    paramType = "array";
+  } else if (baseSchema instanceof zod.z.ZodEnum) {
+    paramType = "string";
+    choices = baseSchema._def.values;
+  } else if (baseSchema instanceof zod.z.ZodRecord) {
+    paramType = "string";
+  }
+  return {
+    name,
+    type: paramType,
+    required,
+    description: schema.description,
+    default: defaultValue,
+    choices,
+    hasResolver: zapierSdk.hasResolver(name),
+    isPositional: zapierSdk.isPositional(schema)
+  };
+}
+function toKebabCase(str) {
+  return str.replace(/([A-Z])/g, "-$1").toLowerCase();
+}
+function methodNameToCliCommand(methodName) {
+  return toKebabCase(methodName);
+}
+function generateCliCommands(program2, sdk2) {
+  if (typeof sdk2.getRegistry !== "function") {
+    console.error("SDK registry not available");
+    return;
+  }
+  const registry = sdk2.getRegistry();
+  registry.functions.forEach((fnInfo) => {
+    if (!fnInfo.inputSchema) {
+      console.warn(`Schema not found for ${fnInfo.name}`);
+      return;
+    }
+    const cliCommandName = methodNameToCliCommand(fnInfo.name);
+    const config = createCommandConfig(
+      cliCommandName,
+      fnInfo.name,
+      fnInfo.inputSchema,
+      sdk2
+    );
+    addCommand(program2, cliCommandName, config);
+  });
+  program2.configureHelp({
+    formatHelp: (cmd, helper) => {
+      const helpWidth = helper.helpWidth || 80;
+      let output = helper.commandUsage(cmd) + "\n";
+      if (cmd.description()) {
+        output += helper.wrap(cmd.description(), helpWidth, 0) + "\n";
+      }
+      const options = helper.visibleOptions(cmd);
+      if (options.length > 0) {
+        output += "\nOptions:\n";
+        const longestOptionLength = Math.max(
+          ...options.map((opt) => helper.optionTerm(opt).length)
+        );
+        options.forEach((option) => {
+          const term = helper.optionTerm(option);
+          const padding = " ".repeat(
+            Math.max(2, longestOptionLength - term.length + 4)
+          );
+          output += `  ${term}${padding}${helper.optionDescription(option)}
+`;
+        });
+      }
+      const commands = helper.visibleCommands(cmd);
+      if (commands.length > 0) {
+        output += "\nCommands:\n";
+        const categorizedCommands = /* @__PURE__ */ new Set();
+        registry.categories.forEach((category) => {
+          const categoryCommands = commands.filter(
+            (command) => category.functions.some((functionName) => {
+              const cliCommandName = methodNameToCliCommand(functionName);
+              return command.name() === cliCommandName;
+            })
+          );
+          if (categoryCommands.length > 0) {
+            output += `
+  ${category.titlePlural}:
+`;
+            categoryCommands.forEach((command) => {
+              output += `    ${helper.subcommandTerm(command)}
+`;
+              categorizedCommands.add(command.name());
+            });
+          }
+        });
+        const otherCommands = commands.filter(
+          (command) => !categorizedCommands.has(command.name())
+        );
+        if (otherCommands.length > 0) {
+          output += `
+  Other:
+`;
+          otherCommands.forEach((command) => {
+            output += `    ${helper.subcommandTerm(command)}
+`;
+          });
+        }
+      }
+      return output;
+    }
+  });
+}
+function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk2) {
+  const parameters = analyzeZodSchema(schema);
+  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 hasPaginationParams = parameters.some(
+        (p) => p.name === "maxItems" || p.name === "pageSize"
+      );
+      const hasUserSpecifiedMaxItems = "maxItems" in options && options.maxItems !== void 0;
+      const shouldUseJson = options.json;
+      const rawParams = convertCliArgsToSdkParams(
+        parameters,
+        args.slice(0, -1),
+        options
+      );
+      const resolver = new SchemaParameterResolver();
+      const resolvedParams = await resolver.resolveParameters(
+        schema,
+        rawParams,
+        sdk2
+      );
+      if (isListCommand && hasPaginationParams && !shouldUseJson && !hasUserSpecifiedMaxItems) {
+        const sdkObj = sdk2;
+        const sdkIterator = sdkObj[sdkMethodName](resolvedParams);
+        await handlePaginatedListWithAsyncIteration(
+          sdkMethodName,
+          sdkIterator,
+          schema
+        );
+      } else {
+        const hasOutputFile = resolvedParams.output;
+        if (hasOutputFile) {
+          const sdkObj2 = sdk2;
+          await sdkObj2[sdkMethodName](resolvedParams);
+          console.log(
+            chalk3__default.default.green(`\u2705 ${cliCommandName} completed successfully!`)
+          );
+          console.log(chalk3__default.default.gray(`Output written to: ${hasOutputFile}`));
+          return;
+        }
+        const sdkObj = sdk2;
+        const result = await sdkObj[sdkMethodName](resolvedParams);
+        const items = result?.data ? result.data : result;
+        if (shouldUseJson) {
+          console.log(JSON.stringify(items, null, 2));
+        } else if (isListCommand) {
+          formatNonPaginatedResults(
+            items,
+            resolvedParams.maxItems,
+            hasUserSpecifiedMaxItems,
+            shouldUseJson,
+            schema,
+            sdkMethodName
+          );
+        } else {
+          formatJsonOutput(items);
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('"code"')) {
+        try {
+          const validationErrors = JSON.parse(error.message);
+          console.error(chalk3__default.default.red("\u274C Validation Error:"));
+          validationErrors.forEach((err) => {
+            const errorObj = err;
+            const field = errorObj?.path?.join(".") || "unknown";
+            console.error(
+              chalk3__default.default.yellow(
+                `  \u2022 ${field}: ${errorObj?.message || "Unknown error"}`
+              )
+            );
+          });
+          console.error(
+            "\n" + chalk3__default.default.dim(`Use --help to see available options`)
+          );
+        } catch {
+          console.error(chalk3__default.default.red("Error:"), error.message);
+        }
+      } else if (error instanceof zapierSdk.ZapierError) {
+        const formattedMessage = zapierSdk.formatErrorMessage(error);
+        console.error(chalk3__default.default.red("\u274C Error:"), formattedMessage);
+      } else {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        console.error(chalk3__default.default.red("\u274C Error:"), errorMessage);
+      }
+      process.exit(1);
+    }
+  };
+  return {
+    description,
+    parameters,
+    handler
+  };
+}
+function addCommand(program2, commandName, config) {
+  const command = program2.command(commandName).description(config.description);
+  config.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 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
+        );
+      }
+    }
+  });
+  command.option("--json", "Output raw JSON instead of formatted results");
+  command.action(config.handler);
+}
+function convertCliArgsToSdkParams(parameters, positionalArgs, options) {
+  const sdkParams = {};
+  let argIndex = 0;
+  parameters.forEach((param) => {
+    if ((param.required || param.isPositional) && argIndex < positionalArgs.length) {
+      sdkParams[param.name] = convertValue(
+        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] = convertValue(value, param.type);
+    }
+  });
+  return sdkParams;
+}
+function convertValue(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;
+  }
+}
+async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, schema) {
+  const itemName = getItemNameFromMethod(sdkMethodName);
+  let totalShown = 0;
+  let pageCount = 0;
+  console.log(chalk3__default.default.blue(`\u{1F4CB} ${getListTitleFromMethod(sdkMethodName)}
+`));
+  try {
+    for await (const page of sdkResult) {
+      const items = page.data || page;
+      pageCount++;
+      if (!Array.isArray(items)) {
+        console.log(chalk3__default.default.yellow(`No ${itemName} found.`));
+        return;
+      }
+      if (items.length === 0 && pageCount === 1) {
+        console.log(chalk3__default.default.yellow(`No ${itemName} found.`));
+        return;
+      }
+      if (items.length === 0) {
+        break;
+      }
+      if (pageCount > 1) {
+        console.clear();
+        console.log(
+          chalk3__default.default.blue(`\u{1F4CB} ${getListTitleFromMethod(sdkMethodName)}
+`)
+        );
+      }
+      if (schema) {
+        formatItemsFromSchema(schema, items, totalShown);
+      } else {
+        formatItemsGeneric2(items, totalShown);
+      }
+      totalShown += items.length;
+      console.log(
+        chalk3__default.default.green(
+          `
+\u2705 Showing ${totalShown} ${itemName} (page ${pageCount})`
+        )
+      );
+      if (page.nextCursor) {
+        const { continueReading } = await inquirer__default.default.prompt([
+          {
+            type: "confirm",
+            name: "continueReading",
+            message: `Load next page?`,
+            default: true
+          }
+        ]);
+        if (!continueReading) {
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+    console.log(chalk3__default.default.gray(`
+\u{1F4C4} Finished browsing ${itemName}`));
+  } catch (error) {
+    const items = sdkResult?.data || sdkResult;
+    if (Array.isArray(items)) {
+      if (items.length === 0) {
+        console.log(chalk3__default.default.yellow(`No ${itemName} found.`));
+        return;
+      }
+      if (schema) {
+        formatItemsFromSchema(schema, items, 0);
+      } else {
+        formatItemsGeneric2(items, 0);
+      }
+      console.log(chalk3__default.default.green(`
+\u2705 Showing ${items.length} ${itemName}`));
+    } else {
+      throw error;
+    }
+  }
+}
+function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxItems, useRawJson, schema, methodName) {
+  if (!Array.isArray(result)) {
+    if (useRawJson) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      formatJsonOutput(result);
+    }
+    return;
+  }
+  if (useRawJson) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  const itemName = methodName ? getItemNameFromMethod(methodName) : "items";
+  if (result.length === 0) {
+    console.log(chalk3__default.default.yellow(`No ${itemName} found.`));
+    return;
+  }
+  console.log(chalk3__default.default.green(`
+\u2705 Found ${result.length} ${itemName}:
+`));
+  if (schema) {
+    formatItemsFromSchema(schema, result);
+  } else {
+    formatItemsGeneric2(result);
+  }
+  if (userSpecifiedMaxItems && requestedMaxItems) {
+    console.log(
+      chalk3__default.default.gray(
+        `
+\u{1F4C4} Showing up to ${requestedMaxItems} ${itemName} (--max-items ${requestedMaxItems})`
+      )
+    );
+  } else {
+    console.log(chalk3__default.default.gray(`
+\u{1F4C4} All available ${itemName} shown`));
+  }
+}
+function formatItemsGeneric2(items, startingNumber = 0) {
+  items.forEach((item, index) => {
+    const itemObj = item;
+    const name = itemObj?.name || itemObj?.key || itemObj?.id || "Item";
+    console.log(
+      `${chalk3__default.default.gray(`${startingNumber + index + 1}.`)} ${chalk3__default.default.cyan(String(name))}`
+    );
+    if (itemObj?.description) {
+      console.log(`   ${chalk3__default.default.dim(String(itemObj.description))}`);
+    }
+    console.log();
+  });
+}
+function getItemNameFromMethod(methodName) {
+  const listMatch = methodName.match(/^list(.+)$/);
+  if (listMatch) {
+    return listMatch[1].toLowerCase();
+  }
+  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}`;
+}
+
+// src/utils/constants.ts
+var ZAPIER_BASE = "https://zapier.com";
+var LOGIN_CLIENT_ID = "K5eEnRE9TTmSFATdkkWhKF8NOKwoiOnYAyIqJjae";
+var LOGIN_PORTS = [49505, 50575, 52804, 55981, 61010, 63851];
+var LOGIN_TIMEOUT_MS = 3e5;
+var AUTH_MODE_HEADER = "X-Auth";
+var spinPromise = async (promise, text) => {
+  const spinner = ora__default.default(text).start();
+  try {
+    const result = await promise;
+    spinner.succeed();
+    return result;
+  } catch (error) {
+    spinner.fail();
+    throw error;
+  }
+};
+var log = {
+  info: (message, ...args) => {
+    console.log(chalk3__default.default.blue("\u2139"), message, ...args);
+  },
+  error: (message, ...args) => {
+    console.error(chalk3__default.default.red("\u2716"), message, ...args);
+  },
+  success: (message, ...args) => {
+    console.log(chalk3__default.default.green("\u2713"), message, ...args);
+  },
+  warn: (message, ...args) => {
+    console.log(chalk3__default.default.yellow("\u26A0"), message, ...args);
+  }
+};
+var log_default = log;
+
+// src/utils/api/client.ts
+var createApiClient = () => {
+  const post = async (url, data, options = {}) => {
+    const { headers = {} } = options;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Connection: "close",
+        ...headers
+      },
+      body: new URLSearchParams(data)
+    });
+    if (!response.ok) {
+      throw new Error(`${response.status} ${response.statusText}`);
+    }
+    const responseData = await response.json();
+    return {
+      data: responseData,
+      status: response.status
+    };
+  };
+  return {
+    post
+  };
+};
+var api = createApiClient();
+var client_default = api;
+
+// src/utils/getCallablePromise.ts
+var getCallablePromise = () => {
+  let resolve2 = () => {
+  };
+  let reject = () => {
+  };
+  const promise = new Promise((_resolve, _reject) => {
+    resolve2 = _resolve;
+    reject = _reject;
+  });
+  return {
+    promise,
+    resolve: resolve2,
+    reject
+  };
+};
+var getCallablePromise_default = getCallablePromise;
+var findAvailablePort = () => {
+  return new Promise((resolve2, reject) => {
+    let portIndex = 0;
+    const tryPort = (port) => {
+      const server = express__default.default().listen(port, () => {
+        server.close();
+        resolve2(port);
+      });
+      server.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+          if (portIndex < LOGIN_PORTS.length) {
+            tryPort(LOGIN_PORTS[portIndex++]);
+          } else {
+            reject(
+              new Error(
+                `All configured OAuth callback ports are busy: ${LOGIN_PORTS.join(", ")}. Please try again later or close applications using these ports.`
+              )
+            );
+          }
+        } else {
+          reject(err);
+        }
+      });
+    };
+    if (LOGIN_PORTS.length > 0) {
+      tryPort(LOGIN_PORTS[portIndex++]);
+    } else {
+      reject(new Error("No OAuth callback ports configured"));
+    }
+  });
+};
+var generateRandomString = () => {
+  const array = new Uint32Array(28);
+  crypto__default.default.getRandomValues(array);
+  return Array.from(
+    array,
+    (dec) => ("0" + dec.toString(16)).substring(-2)
+  ).join("");
+};
+var login = async (timeoutMs = LOGIN_TIMEOUT_MS) => {
+  zapierSdkCliLogin.logout();
+  const availablePort = await findAvailablePort();
+  const redirectUri = `http://localhost:${availablePort}/oauth`;
+  log_default.info(`Using port ${availablePort} for OAuth callback`);
+  const { promise: promisedCode, resolve: setCode } = getCallablePromise_default();
+  const app = express__default.default();
+  app.get("/oauth", (req, res) => {
+    setCode(String(req.query.code));
+    res.setHeader("Connection", "close");
+    res.end("You can now close this tab and return to the CLI.");
+  });
+  const server = app.listen(availablePort);
+  const connections = /* @__PURE__ */ new Set();
+  server.on("connection", (conn) => {
+    connections.add(conn);
+    conn.on("close", () => connections.delete(conn));
+  });
+  const cleanup = () => {
+    server.close();
+    log_default.info("\n\u274C Login cancelled by user");
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  const { code_verifier: codeVerifier, code_challenge: codeChallenge } = await pkceChallenge__default.default();
+  const authUrl = `${ZAPIER_BASE}/oauth/authorize/?${new URLSearchParams({
+    response_type: "code",
+    client_id: LOGIN_CLIENT_ID,
+    redirect_uri: redirectUri,
+    scope: "internal offline_access",
+    state: generateRandomString(),
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256"
+  }).toString()}`;
+  log_default.info("Opening your browser to log in.");
+  log_default.info("If it doesn't open, visit:", authUrl);
+  open__default.default(authUrl);
+  try {
+    await spinPromise(
+      Promise.race([
+        promisedCode,
+        new Promise(
+          (_resolve, reject) => setTimeout(() => {
+            reject(
+              new Error(
+                `Login timed out after ${Math.round(timeoutMs / 1e3)} seconds.`
+              )
+            );
+          }, timeoutMs)
+        )
+      ]),
+      "Waiting for you to login and authorize"
+    );
+  } finally {
+    process.off("SIGINT", cleanup);
+    process.off("SIGTERM", cleanup);
+    await new Promise((resolve2) => {
+      const timeout = setTimeout(() => {
+        log_default.info("Server close timed out, forcing connection shutdown...");
+        connections.forEach((conn) => conn.destroy());
+        resolve2();
+      }, 1e3);
+      server.close(() => {
+        clearTimeout(timeout);
+        resolve2();
+      });
+    });
+  }
+  log_default.info("Exchanging authorization code for tokens...");
+  const { data } = await client_default.post(
+    `${ZAPIER_BASE}/oauth/token/`,
+    {
+      grant_type: "authorization_code",
+      code: await promisedCode,
+      redirect_uri: redirectUri,
+      client_id: LOGIN_CLIENT_ID,
+      code_verifier: codeVerifier
+    },
+    {
+      headers: {
+        [AUTH_MODE_HEADER]: "no",
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    }
+  );
+  zapierSdkCliLogin.updateLogin(data);
+  log_default.info("Token exchange completed successfully");
+  return data.access_token;
+};
+var login_default = login;
+var LoginSchema = zod.z.object({
+  timeout: zod.z.string().optional().describe("Login timeout in seconds (default: 300)")
+}).describe("Log in to Zapier to access your account");
+
+// src/plugins/login/index.ts
+var loginWithSdk = zapierSdk.createFunction(async function loginWithSdk2(options) {
+  const timeoutSeconds = options.timeout ? parseInt(options.timeout, 10) : 300;
+  if (isNaN(timeoutSeconds) || timeoutSeconds <= 0) {
+    throw new Error("Timeout must be a positive number");
+  }
+  await login_default(timeoutSeconds * 1e3);
+  const user = await zapierSdkCliLogin.getLoggedInUser();
+  console.log(`\u2705 Successfully logged in as ${user.email}`);
+  setTimeout(() => process.exit(0), 100);
+}, LoginSchema);
+var loginPlugin = () => ({
+  login: loginWithSdk,
+  context: {
+    meta: {
+      login: {
+        categories: ["account"],
+        inputSchema: LoginSchema
+      }
+    }
+  }
+});
+var LogoutSchema = zod.z.object({}).describe("Log out of your Zapier account");
+
+// src/plugins/logout/index.ts
+var logoutWithSdk = zapierSdk.createFunction(async function logoutWithSdk2(_options) {
+  zapierSdkCliLogin.logout();
+  console.log("\u2705 Successfully logged out");
+}, LogoutSchema);
+var logoutPlugin = () => ({
+  logout: logoutWithSdk,
+  context: {
+    meta: {
+      logout: {
+        categories: ["account"],
+        inputSchema: LogoutSchema
+      }
+    }
+  }
+});
+var McpSchema = zod.z.object({
+  port: zod.z.string().optional().describe("Port to listen on (for future HTTP transport)")
+}).describe("Start MCP server for Zapier SDK");
+
+// src/plugins/mcp/index.ts
+var mcpPlugin = ({ context }) => {
+  const mcpWithSdk = zapierSdk.createFunction(async function mcpWithSdk2(options) {
+    const mcpOptions = {
+      ...options,
+      debug: context.options.debug
+    };
+    return await zapierSdkMcp.startMcpServerAsProcess(mcpOptions);
+  }, McpSchema);
+  return {
+    mcp: mcpWithSdk,
+    context: {
+      meta: {
+        mcp: {
+          categories: ["utility"],
+          inputSchema: McpSchema
+        }
+      }
+    }
+  };
+};
+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(
+    "Output file path (defaults to input with .js extension)"
+  ),
+  string: zod.z.boolean().optional().describe("Return bundled code as string instead of writing to file"),
+  minify: zod.z.boolean().optional().describe("Minify the bundled output"),
+  target: zod.z.string().optional().describe("ECMAScript target version"),
+  cjs: zod.z.boolean().optional().describe("Output CommonJS format instead of ESM")
+}).describe("Bundle TypeScript code into executable JavaScript");
+var bundleCodePlugin = () => {
+  const bundleCodeWithSdk = zapierSdk.createFunction(async function bundleCodeWithSdk2(options) {
+    return await bundleCode(options);
+  }, BundleCodeSchema);
+  return {
+    bundleCode: bundleCodeWithSdk,
+    context: {
+      meta: {
+        bundleCode: {
+          categories: ["utility"],
+          inputSchema: BundleCodeSchema
+        }
+      }
+    }
+  };
+};
+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 = path__namespace.resolve(process.cwd(), input);
+  try {
+    const result = esbuild.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) {
+      fs__namespace.mkdirSync(path__namespace.dirname(output), { recursive: true });
+      fs__namespace.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
+    );
+  }
+}
+var GetConfigPathSchema = zod.z.object({}).describe("Show the path to the configuration file");
+var getConfigPathPlugin = () => {
+  const getConfigPathWithSdk = zapierSdk.createFunction(
+    async function getConfigPathWithSdk2(_options) {
+      return zapierSdkCliLogin.getConfigPath();
+    },
+    GetConfigPathSchema
+  );
+  return {
+    getConfigPath: getConfigPathWithSdk,
+    context: {
+      meta: {
+        getConfigPath: {
+          categories: ["utility"],
+          inputSchema: GetConfigPathSchema
+        }
+      }
+    }
+  };
+};
+
+// src/sdk.ts
+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(mcpPlugin);
+  sdk2 = sdk2.addPlugin(loginPlugin);
+  sdk2 = sdk2.addPlugin(logoutPlugin);
+  const finalSdk = sdk2.addPlugin(zapierSdk.registryPlugin);
+  return finalSdk;
+}
+
+// package.json
+var package_default = {
+  version: "0.6.5"};
+
+// src/cli.ts
+var program = new commander.Command();
+program.name("zapier-sdk").description("CLI for Zapier SDK").version(package_default.version, "-v, --version", "display version number").option("--debug", "Enable debug logging");
+var isDebugMode = process.env.DEBUG === "true" || process.argv.includes("--debug");
+var sdk = createZapierCliSdk({
+  debug: isDebugMode
+});
+generateCliCommands(program, sdk);
+program.parse();