@zapier/zapier-sdk-cli 0.3.1 → 0.4.0

package/dist/cli.js

@@ -1,25 +1,1108 @@
 #!/usr/bin/env node
-import { Command } from "commander";
+
+// src/cli.ts
+import { Command as Command5 } from "commander";
 import { createZapierSdk } from "@zapier/zapier-sdk";
-import { generateCliCommands } from "./utils/cli-generator.js";
-import { createLoginCommand, createLogoutCommand, createWhoamiCommand, createConfigPathCommand, } from "./commands/index.js";
-const program = new Command();
-program
-    .name("zapier-sdk")
-    .description("CLI for Zapier SDK - Commands auto-generated from SDK schemas")
-    .version("1.0.0")
-    .option("--debug", "Enable debug logging");
-// Check for debug flag early
-const isDebugMode = process.env.DEBUG === "true" || process.argv.includes("--debug");
-// Create SDK instance - automatically handles token resolution
-const sdk = createZapierSdk({
-    debug: isDebugMode,
+
+// src/utils/cli-generator.ts
+import { z as z2 } from "zod";
+import { hasResolver as hasResolver2, isPositional } from "@zapier/zapier-sdk";
+
+// src/utils/parameter-resolver.ts
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { z } from "zod";
+import {
+  getResolver,
+  hasResolver,
+  getResolutionOrderForParams
+} from "@zapier/zapier-sdk";
+var SchemaParameterResolver = class {
+  async resolveParameters(schema, providedParams, sdk2) {
+    const parseResult = schema.safeParse(providedParams);
+    const allParams = this.extractParametersFromSchema(schema);
+    const resolvableParams = allParams.filter(
+      (param) => 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" || param.name === "authenticationId") {
+        return true;
+      }
+      return false;
+    });
+    const trulyOptional = missingResolvable.filter(
+      (param) => !functionallyRequired.includes(param)
+    );
+    if (parseResult.success && functionallyRequired.length === 0) {
+      return parseResult.data;
+    }
+    if (functionallyRequired.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 = getResolutionOrderForParams(requiredParamNames);
+      const orderedRequiredParams = requiredResolutionOrder.map(
+        (paramName) => functionallyRequired.find((p) => p.name === paramName)
+      ).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(chalk.yellow("\n\nOperation cancelled by user"));
+            process.exit(0);
+          }
+          console.error(chalk.red(`Failed to resolve ${param.name}:`), error);
+          throw error;
+        }
+      }
+    }
+    if (trulyOptional.length > 0) {
+      const optionalNames = trulyOptional.map((p) => p.name).join(", ");
+      const shouldResolveOptional = await inquirer.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 = 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(chalk.yellow("\n\nOperation cancelled by user"));
+              process.exit(0);
+            }
+            console.error(chalk.red(`Failed to resolve ${param.name}:`), error);
+            throw error;
+          }
+        }
+      }
+    }
+    const finalResult = schema.safeParse(resolvedParams);
+    if (!finalResult.success) {
+      console.error(
+        chalk.red("\u274C Parameter validation failed after resolution:")
+      );
+      throw finalResult.error;
+    }
+    return finalResult.data;
+  }
+  extractParametersFromSchema(schema) {
+    const parameters = [];
+    if (schema instanceof 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 z.ZodOptional) {
+      isRequired = false;
+      baseSchema = baseSchema._def.innerType;
+    }
+    if (baseSchema instanceof z.ZodDefault) {
+      isRequired = false;
+      baseSchema = baseSchema._def.innerType;
+    }
+    return this.createResolvableParameter([fieldName], baseSchema, isRequired);
+  }
+  createResolvableParameter(path, schema, isRequired) {
+    if (path.length === 0) return null;
+    const name = path[path.length - 1];
+    return {
+      name,
+      path,
+      schema,
+      description: schema.description,
+      isRequired
+    };
+  }
+  async resolveParameter(param, context) {
+    const resolver = getResolver(param.name);
+    if (!resolver) {
+      throw new Error(`No resolver found for parameter: ${param.name}`);
+    }
+    console.log(chalk.blue(`
+\u{1F50D} Resolving ${param.name}...`));
+    if (resolver.type === "static") {
+      const promptConfig = {
+        type: resolver.inputType === "password" ? "password" : "input",
+        name: param.name,
+        message: `Enter ${param.name}:`,
+        ...resolver.placeholder && { default: resolver.placeholder }
+      };
+      const answers = await inquirer.prompt([promptConfig]);
+      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}`);
+        }
+        const promptConfig = resolver.prompt(items, 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) {
+          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);
+          }
+        }
+        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);
+            }
+            throw error;
+          }
+          if (shouldConfigureOptional.configure) {
+            console.log(chalk.cyan(`
+Optional fields:`));
+            for (const field of optionalFields) {
+              await this.promptForField(field, inputs);
+            }
+          }
+        }
+        return inputs;
+      } catch (error) {
+        console.error(
+          chalk.red(`Failed to fetch fields for ${param.name}:`),
+          error instanceof Error ? error.message : error
+        );
+        throw error;
+      }
+    }
+    throw new Error(`Unknown resolver type for ${param.name}`);
+  }
+  getNestedValue(obj, path) {
+    return path.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) => {
+      if (!(key in current)) {
+        current[key] = {};
+      }
+      return current[key];
+    }, obj);
+    parent[lastKey] = value;
+  }
+  async promptForField(field, inputs) {
+    const fieldPrompt = {
+      type: field.type === "boolean" ? "confirm" : "input",
+      name: field.key,
+      message: `${field.label || field.key}${field.required ? " (required)" : " (optional)"}:`,
+      ...field.helpText && { prefix: chalk.gray(`\u2139 ${field.helpText}
+`) },
+      ...field.default && { default: field.default }
+    };
+    if (field.choices && field.choices.length > 0) {
+      fieldPrompt.type = "list";
+      fieldPrompt.choices = field.choices.map((choice) => ({
+        name: choice.label || choice.value,
+        value: choice.value
+      }));
+    }
+    try {
+      const answer = await inquirer.prompt([fieldPrompt]);
+      if (answer[field.key] !== void 0 && answer[field.key] !== "") {
+        inputs[field.key] = answer[field.key];
+      } else if (field.required) {
+        throw new Error(`Required field ${field.key} cannot be empty`);
+      }
+    } catch (error) {
+      if (this.isUserCancellation(error)) {
+        console.log(chalk.yellow("\n\nOperation cancelled by user"));
+        process.exit(0);
+      }
+      throw error;
+    }
+  }
+  isUserCancellation(error) {
+    return error?.name === "ExitPromptError" || error?.message?.includes("User force closed") || error?.isTTYError;
+  }
+};
+
+// 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";
+function getFormatMetadata(schema) {
+  return schema?._def?.formatMeta;
+}
+function getOutputSchema(schema) {
+  return schema?._def?.outputSchema;
+}
+function formatItemsFromSchema(inputSchema, items) {
+  const outputSchema = getOutputSchema(inputSchema);
+  if (!outputSchema) {
+    formatItemsGeneric(items);
+    return;
+  }
+  const formatMeta = getFormatMetadata(outputSchema);
+  if (!formatMeta) {
+    formatItemsGeneric(items);
+    return;
+  }
+  items.forEach((item, index) => {
+    formatSingleItem(item, index, formatMeta);
+  });
+}
+function formatSingleItem(item, index, formatMeta) {
+  const formatted = formatMeta.format(item);
+  let titleLine = `${chalk3.gray(`${index + 1}.`)} ${chalk3.cyan(formatted.title)}`;
+  if (formatted.subtitle) {
+    titleLine += ` ${chalk3.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.dim(value);
+    case "accent":
+      return chalk3.magenta(value);
+    case "warning":
+      return chalk3.red(value);
+    case "success":
+      return chalk3.green(value);
+    case "normal":
+    default:
+      return chalk3.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)}`);
+    if (item.description) {
+      console.log(`   ${chalk3.dim(item.description)}`);
+    }
+    console.log();
+  });
+}
+
+// src/utils/cli-generator.ts
+import chalk4 from "chalk";
+import util from "util";
+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(
+    util.inspect(data, { colors: true, depth: null, breakLength: 80 })
+  );
+}
+function analyzeZodSchema(schema) {
+  const parameters = [];
+  if (schema instanceof z2.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 z2.ZodOptional) {
+    required = false;
+    baseSchema = baseSchema._def.innerType;
+  }
+  if (baseSchema instanceof z2.ZodDefault) {
+    required = false;
+    defaultValue = baseSchema._def.defaultValue();
+    baseSchema = baseSchema._def.innerType;
+  }
+  let paramType = "string";
+  let choices;
+  if (baseSchema instanceof z2.ZodString) {
+    paramType = "string";
+  } else if (baseSchema instanceof z2.ZodNumber) {
+    paramType = "number";
+  } else if (baseSchema instanceof z2.ZodBoolean) {
+    paramType = "boolean";
+  } else if (baseSchema instanceof z2.ZodArray) {
+    paramType = "array";
+  } else if (baseSchema instanceof z2.ZodEnum) {
+    paramType = "string";
+    choices = baseSchema._def.values;
+  } else if (baseSchema instanceof z2.ZodRecord) {
+    paramType = "string";
+  }
+  return {
+    name,
+    type: paramType,
+    required,
+    description: schema.description,
+    default: defaultValue,
+    choices,
+    hasResolver: hasResolver2(name),
+    isPositional: isPositional(schema)
+  };
+}
+function toKebabCase(str) {
+  return str.replace(/([A-Z])/g, "-$1").toLowerCase();
+}
+function methodNameToCliCommand(methodName) {
+  return toKebabCase(methodName);
+}
+function generateCliCommands(program2, sdk2) {
+  if (!sdk2.__registry) {
+    console.error("SDK registry not available");
+    return;
+  }
+  sdk2.__registry.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);
+  });
+}
+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 === "limit" || p.name === "offset"
+      );
+      const hasUserSpecifiedLimit = "limit" in options && options.limit !== void 0;
+      const shouldUsePaging = isListCommand && hasPaginationParams && !hasUserSpecifiedLimit;
+      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 (shouldUsePaging && !shouldUseJson) {
+        await handlePaginatedList(sdkMethodName, resolvedParams, sdk2, 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) {
+          formatNonPaginatedResults(
+            result,
+            resolvedParams.limit,
+            hasUserSpecifiedLimit,
+            shouldUseJson,
+            schema,
+            sdkMethodName
+          );
+        } else if (hasOutputFile) {
+          console.log(
+            chalk4.green(`\u2705 ${cliCommandName} completed successfully!`)
+          );
+          console.log(
+            chalk4.gray(`Output written to: ${resolvedParams.output}`)
+          );
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('"code"')) {
+        try {
+          const validationErrors = JSON.parse(error.message);
+          console.error(chalk4.red("\u274C Validation Error:"));
+          validationErrors.forEach((err) => {
+            const field = err.path?.join(".") || "unknown";
+            console.error(chalk4.yellow(`  \u2022 ${field}: ${err.message}`));
+          });
+          console.error(
+            "\n" + chalk4.dim(`Use --help to see available options`)
+          );
+        } catch {
+          console.error(chalk4.red("Error:"), error.message);
+        }
+      } else {
+        console.error(
+          chalk4.red("Error:"),
+          error instanceof Error ? error.message : "Unknown error"
+        );
+      }
+      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 {
+        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 handlePaginatedList(sdkMethodName, baseParams, sdk2, schema) {
+  const limit = baseParams.limit || 20;
+  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)}
+`));
+    if (items.length === 0) {
+      console.log(chalk4.yellow(`No ${itemName} found.`));
+      return;
+    }
+    if (schema) {
+      formatItemsFromSchema(schema, items);
+    } else {
+      formatItemsGeneric2(items);
+    }
+    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) {
+  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(chalk4.yellow(`No ${itemName} found.`));
+    return;
+  }
+  console.log(chalk4.green(`
+\u2705 Found ${result.length} ${itemName}:
+`));
+  if (schema) {
+    formatItemsFromSchema(schema, result);
+  } else {
+    formatItemsGeneric2(result);
+  }
+  if (userSpecifiedLimit && requestedLimit) {
+    console.log(
+      chalk4.gray(
+        `
+\u{1F4C4} Showing up to ${requestedLimit} ${itemName} (--limit ${requestedLimit})`
+      )
+    );
+  } else {
+    console.log(chalk4.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)}`);
+    if (item.description) {
+      console.log(`   ${chalk4.dim(item.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/commands/login.ts
+import { Command } from "commander";
+
+// src/utils/auth/login.ts
+import open from "open";
+import crypto from "crypto";
+import express from "express";
+import pkceChallenge from "pkce-challenge";
+
+// 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";
+
+// src/utils/spinner.ts
+import ora from "ora";
+var spinPromise = async (promise, text) => {
+  const spinner = ora(text).start();
+  try {
+    const result = await promise;
+    spinner.succeed();
+    return result;
+  } catch (error) {
+    spinner.fail();
+    throw error;
+  }
+};
+
+// src/utils/log.ts
+import chalk5 from "chalk";
+var log = {
+  info: (message, ...args) => {
+    console.log(chalk5.blue("\u2139"), message, ...args);
+  },
+  error: (message, ...args) => {
+    console.error(chalk5.red("\u2716"), message, ...args);
+  },
+  success: (message, ...args) => {
+    console.log(chalk5.green("\u2713"), message, ...args);
+  },
+  warn: (message, ...args) => {
+    console.log(chalk5.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 resolve = () => {
+  };
+  let reject = () => {
+  };
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  return {
+    promise,
+    resolve,
+    reject
+  };
+};
+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) => {
+    let portIndex = 0;
+    const tryPort = (port) => {
+      const server = express().listen(port, () => {
+        server.close();
+        resolve(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.getRandomValues(array);
+  return Array.from(
+    array,
+    (dec) => ("0" + dec.toString(16)).substring(-2)
+  ).join("");
+};
+var login = async (timeoutMs = LOGIN_TIMEOUT_MS) => {
+  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();
+  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();
+  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(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((resolve) => {
+      const timeout = setTimeout(() => {
+        log_default.info("Server close timed out, forcing connection shutdown...");
+        connections.forEach((conn) => conn.destroy());
+        resolve();
+      }, 1e3);
+      server.close(() => {
+        clearTimeout(timeout);
+        resolve();
+      });
+    });
+  }
+  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"
+      }
+    }
+  );
+  updateLogin(data);
+  log_default.info("Token exchange completed successfully");
+  return data.access_token;
+};
+var login_default = login;
+
+// src/commands/login.ts
+import { getLoggedInUser } from "@zapier/zapier-sdk-cli-login";
+function createLoginCommand() {
+  return new Command("login").description("Log in to Zapier to access your account").option(
+    "--timeout <seconds>",
+    "Login timeout in seconds (default: 300)",
+    "300"
+  ).action(async (options) => {
+    try {
+      const timeoutSeconds = parseInt(options.timeout, 10);
+      if (isNaN(timeoutSeconds) || timeoutSeconds <= 0) {
+        throw new Error("Timeout must be a positive number");
+      }
+      await login_default(timeoutSeconds * 1e3);
+      const user = await getLoggedInUser();
+      console.log(`\u2705 Successfully logged in as ${user.email}`);
+      setTimeout(() => process.exit(0), 100);
+    } catch (error) {
+      console.error(
+        "\u274C Login failed:",
+        error instanceof Error ? error.message : "Unknown error"
+      );
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/logout.ts
+import { Command as Command2 } from "commander";
+import { logout as logout2 } from "@zapier/zapier-sdk-cli-login";
+function createLogoutCommand() {
+  return new Command2("logout").description("Log out of your Zapier account").action(async () => {
+    try {
+      logout2();
+      console.log("\u2705 Successfully logged out");
+    } catch (error) {
+      console.error(
+        "\u274C Logout failed:",
+        error instanceof Error ? error.message : "Unknown error"
+      );
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/whoami.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 () => {
+    try {
+      const user = await spinPromise(
+        getLoggedInUser2(),
+        "Checking login status..."
+      );
+      console.log(
+        `\u2705 Logged in as ${user.email} (Account ID: ${user.accountId})`
+      );
+    } catch {
+      console.log(
+        "\u274C Not logged in. Use 'zapier-sdk login' to authenticate."
+      );
+      process.exit(1);
+    }
+  });
+}
+
+// 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/cli.ts
+var program = new Command5();
+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({
+  debug: isDebugMode
 });
-// Add auth commands before generating SDK commands
 program.addCommand(createLoginCommand());
 program.addCommand(createLogoutCommand());
 program.addCommand(createWhoamiCommand());
 program.addCommand(createConfigPathCommand());
-// Generate CLI commands from SDK schemas
 generateCliCommands(program, sdk);
 program.parse();