@zapier/zapier-sdk-cli 0.16.1 → 0.16.4

package/src/utils/parameter-resolver.ts

@@ -1,1075 +0,0 @@
-import inquirer from "inquirer";
-import chalk from "chalk";
-import { z } from "zod";
-import type { ZapierSdk, ActionTypeProperty } from "@zapier/zapier-sdk";
-import { ZapierCliUserCancellationError } from "./errors";
-
-// ============================================================================
-// Types
-// ============================================================================
-
-interface ResolvableParameter {
-  name: string;
-  path: string[];
-  schema: z.ZodType;
-  description?: string;
-  isRequired: boolean;
-}
-
-interface ResolverContext {
-  sdk: ZapierSdk;
-  currentParams: Record<string, unknown>;
-  resolvedParams: Record<string, unknown>;
-  functionName?: string;
-}
-
-interface FieldMetadata {
-  key: string;
-  title: string;
-  description?: string;
-  isRequired: boolean;
-  defaultValue?: unknown;
-  valueType: string;
-  hasDropdown: boolean;
-  isMultiSelect: boolean;
-}
-
-// ============================================================================
-// Local Resolution Helper Functions
-// ============================================================================
-
-/**
- * Resolve dependency chain for a parameter using local resolvers
- * Returns parameters in the order they need to be resolved
- */
-function getLocalResolutionOrder(
-  paramName: string,
-  resolvers: Record<string, any>,
-  resolved: Set<string> = new Set(),
-): string[] {
-  const resolver = resolvers[paramName];
-  if (!resolver || resolver.type === "static") {
-    return [paramName];
-  }
-
-  const order: string[] = [];
-
-  if ("depends" in resolver && resolver.depends) {
-    for (const dependency of resolver.depends) {
-      if (!resolved.has(dependency)) {
-        order.push(...getLocalResolutionOrder(dependency, resolvers, resolved));
-        resolved.add(dependency);
-      }
-    }
-  }
-
-  if (!resolved.has(paramName)) {
-    order.push(paramName);
-    resolved.add(paramName);
-  }
-
-  return order;
-}
-
-/**
- * Get resolution order for multiple parameters using local resolvers
- */
-function getLocalResolutionOrderForParams(
-  paramNames: string[],
-  resolvers: Record<string, any>,
-): string[] {
-  const resolved = new Set<string>();
-  const order: string[] = [];
-
-  for (const paramName of paramNames) {
-    const paramOrder = getLocalResolutionOrder(paramName, resolvers, resolved);
-    for (const param of paramOrder) {
-      if (!order.includes(param)) {
-        order.push(param);
-      }
-    }
-  }
-
-  return order;
-}
-
-// ============================================================================
-// Schema Parameter Resolver
-// ============================================================================
-
-export class SchemaParameterResolver {
-  async resolveParameters(
-    schema: z.ZodSchema,
-    providedParams: unknown,
-    sdk: ZapierSdk,
-    functionName?: string,
-  ): Promise<unknown> {
-    // 1. Try to parse with current parameters
-    const parseResult = schema.safeParse(providedParams);
-
-    // Get all schema parameters to check which ones have resolvers
-    const allParams = this.extractParametersFromSchema(schema);
-    const resolvableParams = allParams.filter((param) =>
-      this.hasResolver(param.name, sdk, functionName),
-    );
-
-    // Get all missing parameters that have resolvers
-    const missingResolvable = resolvableParams.filter((param) => {
-      const hasValue =
-        this.getNestedValue(providedParams, param.path) !== undefined;
-      return !hasValue;
-    });
-
-    // Determine parameter resolution categories:
-    // - functionally required: must be provided (inputs)
-    // - always prompt: should be prompted for but can be skipped (authenticationId)
-    // - truly optional: only ask if user wants to be prompted
-    const functionallyRequired = missingResolvable.filter((param) => {
-      // Schema-required parameters are always functionally required
-      if (param.isRequired) return true;
-
-      // Only inputs is functionally required for run-action
-      if (param.name === "inputs") {
-        return true;
-      }
-
-      return false;
-    });
-
-    // Parameters that should always be prompted for directly, but can be skipped
-    const alwaysPrompt = missingResolvable.filter((param) => {
-      if (functionallyRequired.includes(param)) return false;
-
-      // authenticationId should always be prompted for (since it's usually needed)
-      // but can be skipped with "Continue without authentication"
-      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) {
-      // No functionally required parameters missing, but check if we can parse
-      if (!parseResult.success) {
-        throw parseResult.error;
-      }
-      return parseResult.data;
-    }
-
-    // 2. Resolve functionally required parameters first
-    const resolvedParams = { ...(providedParams as Record<string, unknown>) };
-    const context: ResolverContext = {
-      sdk,
-      currentParams: providedParams as Record<string, unknown>,
-      resolvedParams,
-      functionName,
-    };
-
-    // Get local resolvers for this function
-    const localResolvers = this.getLocalResolvers(sdk, functionName);
-
-    if (functionallyRequired.length > 0) {
-      const requiredParamNames = functionallyRequired.map((p) => p.name);
-      const requiredResolutionOrder = getLocalResolutionOrderForParams(
-        requiredParamNames,
-        localResolvers,
-      );
-
-      // Find all parameters that need to be resolved (including dependencies)
-      // from the available resolvable parameters
-      const orderedRequiredParams = requiredResolutionOrder
-        .map((paramName) => {
-          // First try to find in functionally required
-          let param = functionallyRequired.find((p) => p.name === paramName);
-          // If not found, try always prompt (for dependencies like authenticationId)
-          if (!param) {
-            param = alwaysPrompt.find((p) => p.name === paramName);
-          }
-          // If not found, try truly optional (for other dependencies)
-          if (!param) {
-            param = trulyOptional.find((p) => p.name === paramName);
-          }
-          return param;
-        })
-        .filter((param): param is ResolvableParameter => param !== undefined);
-
-      for (const param of orderedRequiredParams) {
-        try {
-          const value = await this.resolveParameter(
-            param,
-            context,
-            functionName,
-          );
-          this.setNestedValue(resolvedParams, param.path, value);
-
-          // Update context with newly resolved value
-          context.resolvedParams = resolvedParams;
-        } catch (error) {
-          if (this.isUserCancellation(error)) {
-            console.log(chalk.yellow("\n\nOperation cancelled by user"));
-            throw new ZapierCliUserCancellationError();
-          }
-          throw error;
-        }
-      }
-
-      // Remove resolved dependencies from other categories to avoid double-prompting
-      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)),
-      );
-    }
-
-    // 3. Resolve parameters that should always be prompted for (but can be skipped)
-    if (alwaysPrompt.length > 0) {
-      const alwaysPromptNames = alwaysPrompt.map((p) => p.name);
-      const alwaysPromptResolutionOrder = getLocalResolutionOrderForParams(
-        alwaysPromptNames,
-        localResolvers,
-      );
-
-      const orderedAlwaysPromptParams = alwaysPromptResolutionOrder
-        .map((paramName) => alwaysPrompt.find((p) => p.name === paramName))
-        .filter((param): param is ResolvableParameter => param !== undefined);
-
-      for (const param of orderedAlwaysPromptParams) {
-        try {
-          const value = await this.resolveParameter(
-            param,
-            context,
-            functionName,
-          );
-          this.setNestedValue(resolvedParams, param.path, value);
-
-          // Update context with newly resolved value
-          context.resolvedParams = resolvedParams;
-        } catch (error) {
-          if (this.isUserCancellation(error)) {
-            console.log(chalk.yellow("\n\nOperation cancelled by user"));
-            throw new ZapierCliUserCancellationError();
-          }
-          throw error;
-        }
-      }
-    }
-
-    // 4. Ask user if they want to resolve truly optional parameters
-    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) {
-        // Resolve optional parameters using their resolvers
-        const optionalParamNames = trulyOptional.map((p) => p.name);
-        const optionalResolutionOrder = getLocalResolutionOrderForParams(
-          optionalParamNames,
-          localResolvers,
-        );
-
-        const orderedOptionalParams = optionalResolutionOrder
-          .map((paramName) => trulyOptional.find((p) => p.name === paramName))
-          .filter((param): param is ResolvableParameter => param !== undefined);
-
-        for (const param of orderedOptionalParams) {
-          try {
-            const value = await this.resolveParameter(
-              param,
-              context,
-              functionName,
-            );
-            this.setNestedValue(resolvedParams, param.path, value);
-
-            // Update context with newly resolved value
-            context.resolvedParams = resolvedParams;
-          } catch (error) {
-            if (this.isUserCancellation(error)) {
-              console.log(chalk.yellow("\n\nOperation cancelled by user"));
-              throw new ZapierCliUserCancellationError();
-            }
-            throw error;
-          }
-        }
-      }
-    }
-
-    // 3. Validate final parameters
-    const finalResult = schema.safeParse(resolvedParams);
-
-    if (!finalResult.success) {
-      console.error(
-        chalk.red("❌ Parameter validation failed after resolution:"),
-      );
-      throw finalResult.error;
-    }
-
-    return finalResult.data;
-  }
-
-  private extractParametersFromSchema(
-    schema: z.ZodSchema,
-  ): ResolvableParameter[] {
-    const parameters: ResolvableParameter[] = [];
-
-    // Only handle ZodObject at the top level
-    if (schema instanceof z.ZodObject) {
-      const shape = schema.shape;
-      for (const [key, fieldSchema] of Object.entries<z.ZodSchema>(shape)) {
-        const param = this.analyzeFieldSchema(key, fieldSchema);
-        if (param) {
-          parameters.push(param);
-        }
-      }
-    }
-
-    return parameters;
-  }
-
-  private analyzeFieldSchema(
-    fieldName: string,
-    fieldSchema: z.ZodSchema,
-  ): ResolvableParameter | null {
-    let baseSchema = fieldSchema;
-    let isRequired = true;
-
-    // Check if field is optional or has default
-    if (baseSchema instanceof z.ZodOptional) {
-      isRequired = false;
-      baseSchema = baseSchema._zod.def.innerType as z.ZodSchema;
-    }
-
-    if (baseSchema instanceof z.ZodDefault) {
-      isRequired = false;
-      baseSchema = baseSchema._zod.def.innerType as z.ZodSchema;
-    }
-
-    return this.createResolvableParameter([fieldName], baseSchema, isRequired);
-  }
-
-  private createResolvableParameter(
-    path: string[],
-    schema: z.ZodSchema,
-    isRequired: boolean,
-  ): ResolvableParameter | null {
-    if (path.length === 0) return null;
-
-    const name = path[path.length - 1];
-
-    return {
-      name,
-      path,
-      schema,
-      description: schema.description,
-      isRequired,
-    };
-  }
-
-  private async resolveParameter(
-    param: ResolvableParameter,
-    context: ResolverContext,
-    functionName?: string,
-  ): Promise<unknown> {
-    const resolver = this.getResolver(param.name, context.sdk, functionName);
-    if (!resolver) {
-      throw new Error(`No resolver found for parameter: ${param.name}`);
-    }
-
-    console.log(chalk.blue(`\n🔍 Resolving ${param.name}...`));
-
-    const typedResolver = resolver as {
-      type: string;
-      inputType?: string;
-      placeholder?: string;
-      fetch?: Function;
-      prompt?: Function;
-    };
-
-    if (typedResolver.type === "static") {
-      // Static resolver - just prompt for input
-      const promptConfig = {
-        type: typedResolver.inputType === "password" ? "password" : "input",
-        name: param.name,
-        message: `Enter ${param.name}:`,
-        ...(typedResolver.placeholder && {
-          default: typedResolver.placeholder,
-        }),
-      };
-
-      const answers = await inquirer.prompt([promptConfig as any]);
-      return answers[param.name];
-    } else if (typedResolver.type === "dynamic") {
-      // Dynamic resolver - fetch options and prompt for selection
-      try {
-        // Only show "Fetching..." for required parameters that typically have many options
-        if (param.isRequired && param.name !== "authenticationId") {
-          console.log(chalk.gray(`Fetching options for ${param.name}...`));
-        }
-        const items = await typedResolver.fetch!(
-          context.sdk,
-          context.resolvedParams,
-        );
-
-        // Let the resolver's prompt handle empty lists (e.g., authenticationId can show "skip authentication")
-        const safeItems = items || [];
-        const promptConfig = typedResolver.prompt!(
-          safeItems,
-          context.resolvedParams,
-        );
-        const answers = await inquirer.prompt([promptConfig as any]);
-        return answers[param.name];
-      } catch (error) {
-        // Let the main CLI error handler display user-friendly errors
-        throw error;
-      }
-    } else if (typedResolver.type === "fields") {
-      // Fields resolver - fetch field definitions and prompt for each input with recursive field resolution
-      return await this.resolveFieldsRecursively(
-        resolver as unknown,
-        context,
-        param,
-      );
-    }
-
-    throw new Error(`Unknown resolver type for ${param.name}`);
-  }
-
-  private async resolveFieldsRecursively(
-    resolver: unknown,
-    context: ResolverContext,
-    param: ResolvableParameter,
-  ): Promise<Record<string, unknown>> {
-    const typedResolver = resolver as { fetch: Function };
-    const inputs: Record<string, unknown> = {};
-    let processedFieldKeys = new Set<string>();
-    let iteration = 0;
-    const maxIterations = 10; // Prevent infinite loops
-
-    while (iteration < maxIterations) {
-      iteration++;
-
-      // Update context with current inputs so they're passed to listInputFields
-      const updatedContext = {
-        ...context,
-        resolvedParams: {
-          ...context.resolvedParams,
-          inputs,
-        },
-      };
-
-      console.log(
-        chalk.gray(
-          `Fetching input fields for ${param.name}${iteration > 1 ? ` (iteration ${iteration})` : ""}...`,
-        ),
-      );
-
-      const rootFieldItems = await typedResolver.fetch(
-        updatedContext.sdk,
-        updatedContext.resolvedParams,
-      );
-
-      if (!rootFieldItems || rootFieldItems.length === 0) {
-        if (iteration === 1) {
-          console.log(
-            chalk.yellow(`No input fields required for this action.`),
-          );
-        }
-        break;
-      }
-
-      // Process fields recursively, maintaining fieldset structure
-      const fieldStats = await this.processFieldItems(
-        rootFieldItems,
-        inputs,
-        processedFieldKeys,
-        [],
-        iteration,
-        updatedContext,
-      );
-
-      // If no new fields were processed, we're done
-      if (fieldStats.newRequired === 0 && fieldStats.newOptional === 0) {
-        break;
-      }
-
-      // If we only processed optional fields and skipped them, no need to re-fetch
-      if (fieldStats.newRequired === 0 && fieldStats.optionalSkipped) {
-        break;
-      }
-    }
-
-    if (iteration >= maxIterations) {
-      console.log(
-        chalk.yellow(
-          `\n⚠️  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`,
-        ),
-      );
-    }
-
-    return inputs;
-  }
-
-  /**
-   * Recursively processes fieldsets and their fields, maintaining natural structure
-   * and creating nested inputs as needed (e.g., fieldset "foo" becomes inputs.foo = [{}])
-   */
-  private async processFieldItems(
-    items: unknown[],
-    targetInputs: Record<string, unknown>,
-    processedFieldKeys: Set<string>,
-    fieldsetPath: string[] = [],
-    iteration: number = 1,
-    context?: ResolverContext,
-  ): Promise<{
-    newRequired: number;
-    newOptional: number;
-    optionalSkipped: boolean;
-  }> {
-    let newRequiredCount = 0;
-    let newOptionalCount = 0;
-    let optionalSkipped = false;
-
-    for (const item of items) {
-      const typedItem = item as {
-        type?: string;
-        key?: string;
-        title?: string;
-        fields?: unknown[];
-        is_required?: boolean;
-      };
-
-      if (typedItem.type === "fieldset" && typedItem.fields && typedItem.key) {
-        // Show fieldset context to user
-        const fieldsetTitle = typedItem.title || typedItem.key;
-        const pathDisplay =
-          fieldsetPath.length > 0 ? ` (in ${fieldsetPath.join(" > ")})` : "";
-        console.log(
-          chalk.cyan(
-            `\n📁 Processing fieldset: ${fieldsetTitle}${pathDisplay}`,
-          ),
-        );
-
-        // Create fieldset array in target inputs if it doesn't exist
-        if (!targetInputs[typedItem.key]) {
-          targetInputs[typedItem.key] = [{}];
-        }
-
-        // Process fields within this fieldset recursively
-        const fieldsetTarget = (
-          targetInputs[typedItem.key] as Record<string, unknown>[]
-        )[0];
-        const nestedPath = [...fieldsetPath, fieldsetTitle];
-
-        const nestedStats = await this.processFieldItems(
-          typedItem.fields,
-          fieldsetTarget,
-          processedFieldKeys,
-          nestedPath,
-          iteration,
-          context,
-        );
-
-        newRequiredCount += nestedStats.newRequired;
-        newOptionalCount += nestedStats.newOptional;
-        if (nestedStats.optionalSkipped) {
-          optionalSkipped = true;
-        }
-      } else if (typedItem.type === "input_field" && typedItem.key) {
-        // Skip if already processed
-        if (processedFieldKeys.has(typedItem.key)) {
-          continue;
-        }
-
-        const isRequired = typedItem.is_required || false;
-
-        if (isRequired) {
-          // Process required field immediately
-          newRequiredCount++;
-          if (newRequiredCount === 1 && fieldsetPath.length === 0) {
-            // Only show this message once at root level
-            console.log(
-              chalk.blue(
-                `\n📝 Please provide values for the following ${iteration === 1 ? "" : "additional "}input fields:`,
-              ),
-            );
-          }
-
-          await this.promptForField(typedItem, targetInputs, context);
-          processedFieldKeys.add(typedItem.key);
-        } else {
-          // Collect optional fields for batch processing
-          newOptionalCount++;
-        }
-      }
-      // Skip info fields - they're for display only
-    }
-
-    // Handle optional fields after processing all required fields
-    if (newOptionalCount > 0) {
-      const optionalFields = items.filter((item: unknown) => {
-        const typedItem = item as {
-          type?: string;
-          key?: string;
-          is_required?: boolean;
-        };
-        return (
-          typedItem.type === "input_field" &&
-          typedItem.key &&
-          !typedItem.is_required &&
-          !processedFieldKeys.has(typedItem.key)
-        );
-      });
-
-      if (optionalFields.length > 0) {
-        const pathContext =
-          fieldsetPath.length > 0 ? ` in ${fieldsetPath.join(" > ")}` : "";
-        console.log(
-          chalk.gray(
-            `\nThere are ${optionalFields.length} ${iteration === 1 ? "" : "additional "}optional field(s) available${pathContext}.`,
-          ),
-        );
-
-        try {
-          const shouldConfigureOptional = await inquirer.prompt([
-            {
-              type: "confirm",
-              name: "configure",
-              message: `Would you like to configure ${iteration === 1 ? "" : "these additional "}optional fields${pathContext}?`,
-              default: false,
-            },
-          ]);
-
-          if (shouldConfigureOptional.configure) {
-            console.log(chalk.cyan(`\nOptional fields${pathContext}:`));
-            for (const field of optionalFields) {
-              await this.promptForField(field, targetInputs, context);
-              const typedField = field as { key: string };
-              processedFieldKeys.add(typedField.key);
-            }
-          } else {
-            optionalSkipped = true;
-            // Mark these fields as processed even if skipped to avoid re-asking
-            optionalFields.forEach((field: unknown) => {
-              const typedField = field as { key: string };
-              processedFieldKeys.add(typedField.key);
-            });
-          }
-        } catch (error) {
-          if (this.isUserCancellation(error)) {
-            console.log(chalk.yellow("\n\nOperation cancelled by user"));
-            throw new ZapierCliUserCancellationError();
-          }
-          throw error;
-        }
-      }
-    }
-
-    return {
-      newRequired: newRequiredCount,
-      newOptional: newOptionalCount,
-      optionalSkipped,
-    };
-  }
-
-  private getNestedValue(obj: unknown, path: string[]): unknown {
-    return path.reduce(
-      (current, key) => (current as Record<string, unknown>)?.[key],
-      obj,
-    );
-  }
-
-  private setNestedValue(obj: unknown, path: string[], value: unknown): void {
-    const lastKey = path[path.length - 1];
-    const parent = path.slice(0, -1).reduce((current, key) => {
-      const currentObj = current as Record<string, unknown>;
-      if (!(key in currentObj)) {
-        currentObj[key] = {};
-      }
-      return currentObj[key];
-    }, obj) as Record<string, unknown>;
-    parent[lastKey] = value;
-  }
-
-  /**
-   * Extract and normalize field metadata from raw field object
-   */
-  private extractFieldMetadata(field: unknown): FieldMetadata {
-    const fieldObj = field as {
-      type?: string;
-      key: string;
-      title?: string;
-      label?: string;
-      is_required?: boolean;
-      description?: string;
-      helpText?: string;
-      default_value?: unknown;
-      default?: unknown;
-      value_type?: string;
-      format?: string;
-      items?: { type: string };
-    };
-
-    const valueType = fieldObj.value_type || "string";
-
-    return {
-      key: fieldObj.key,
-      title: fieldObj.title || fieldObj.label || fieldObj.key,
-      description: fieldObj.description || fieldObj.helpText,
-      isRequired: fieldObj.is_required || false,
-      defaultValue: fieldObj.default_value ?? fieldObj.default,
-      valueType,
-      hasDropdown: fieldObj.format === "SELECT",
-      isMultiSelect: Boolean(
-        valueType === "array" ||
-          (fieldObj.items && fieldObj.items.type !== undefined),
-      ),
-    };
-  }
-
-  /**
-   * Fetch a page of choices for a dropdown field
-   */
-  private async fetchChoices(
-    fieldMeta: FieldMetadata,
-    inputs: Record<string, unknown>,
-    context: ResolverContext,
-    cursor?: string,
-  ): Promise<{
-    choices: Array<{ label: string; value: unknown }>;
-    nextCursor?: string;
-  }> {
-    try {
-      console.log(
-        chalk.gray(
-          cursor
-            ? `  Fetching more choices...`
-            : `  Fetching choices for ${fieldMeta.title}...`,
-        ),
-      );
-
-      const page = await context.sdk.listInputFieldChoices({
-        appKey: context.resolvedParams.appKey as string,
-        actionKey: context.resolvedParams.actionKey as string,
-        actionType: context.resolvedParams.actionType as ActionTypeProperty,
-        authenticationId: context.resolvedParams.authenticationId as
-          | number
-          | null,
-        inputFieldKey: fieldMeta.key,
-        inputs,
-        ...(cursor && { cursor }),
-      });
-
-      const choices = page.data.map((choice) => ({
-        label: choice.label || choice.key || String(choice.value),
-        value: choice.value ?? choice.key,
-      }));
-
-      if (choices.length === 0 && !cursor) {
-        console.log(
-          chalk.yellow(`  No choices available for ${fieldMeta.title}`),
-        );
-      }
-
-      return {
-        choices,
-        nextCursor: page.nextCursor,
-      };
-    } catch (error) {
-      console.warn(
-        chalk.yellow(`  ⚠️  Failed to fetch choices for ${fieldMeta.title}:`),
-        error,
-      );
-      return { choices: [] };
-    }
-  }
-
-  /**
-   * Prompt user with choices (handles both single and multi-select with pagination)
-   */
-  private async promptWithChoices({
-    fieldMeta,
-    choices: initialChoices,
-    nextCursor: initialCursor,
-    inputs,
-    context,
-  }: {
-    fieldMeta: FieldMetadata;
-    choices: Array<{ label: string; value: unknown }>;
-    nextCursor?: string;
-    inputs: Record<string, unknown>;
-    context?: ResolverContext;
-  }): Promise<unknown> {
-    const choices = [...initialChoices];
-    let nextCursor = initialCursor;
-    const LOAD_MORE_SENTINEL = Symbol("LOAD_MORE");
-
-    // Progressive loading loop
-    while (true) {
-      const promptChoices = choices.map((choice) => ({
-        name: choice.label,
-        value: choice.value,
-      }));
-
-      // Add "(Load more...)" option if there are more pages
-      if (nextCursor) {
-        promptChoices.push({
-          name: chalk.dim("(Load more...)"),
-          value: LOAD_MORE_SENTINEL,
-        });
-      }
-
-      // Add skip option for optional fields (single-select only)
-      if (!fieldMeta.isRequired && !fieldMeta.isMultiSelect) {
-        promptChoices.push({ name: "(Skip)", value: undefined });
-      }
-
-      const promptConfig = {
-        type: fieldMeta.isMultiSelect ? "checkbox" : "list",
-        name: fieldMeta.key,
-        message: `${fieldMeta.title}${fieldMeta.isRequired ? " (required)" : " (optional)"}:`,
-        choices: promptChoices,
-        ...(fieldMeta.isMultiSelect && {
-          validate: (input: unknown[]) => {
-            if (fieldMeta.isRequired && (!input || input.length === 0)) {
-              return "At least one selection is required";
-            }
-            return true;
-          },
-        }),
-      };
-
-      const answer = await inquirer.prompt([promptConfig as any]);
-      let selectedValue = answer[fieldMeta.key];
-
-      // Check if user selected "Load more..."
-      const wantsMore = fieldMeta.isMultiSelect
-        ? Array.isArray(selectedValue) &&
-          selectedValue.includes(LOAD_MORE_SENTINEL)
-        : selectedValue === LOAD_MORE_SENTINEL;
-
-      if (wantsMore && nextCursor && context) {
-        // Remove sentinel from multi-select
-        if (fieldMeta.isMultiSelect && Array.isArray(selectedValue)) {
-          selectedValue = selectedValue.filter((v) => v !== LOAD_MORE_SENTINEL);
-        }
-
-        // Fetch next page
-        const result = await this.fetchChoices(
-          fieldMeta,
-          inputs,
-          context,
-          nextCursor,
-        );
-        choices.push(...result.choices);
-        nextCursor = result.nextCursor;
-
-        // Re-prompt with updated choices
-        continue;
-      }
-
-      return selectedValue;
-    }
-  }
-
-  /**
-   * Prompt user for free-form input (text or boolean)
-   */
-  private async promptFreeForm(fieldMeta: FieldMetadata): Promise<unknown> {
-    const promptConfig: Record<string, unknown> = {
-      name: fieldMeta.key,
-      message: `${fieldMeta.title}${fieldMeta.isRequired ? " (required)" : " (optional)"}:`,
-    };
-
-    if (fieldMeta.valueType === "boolean") {
-      promptConfig.type = "confirm";
-      promptConfig.default =
-        fieldMeta.defaultValue !== undefined
-          ? Boolean(fieldMeta.defaultValue)
-          : undefined;
-    } else {
-      promptConfig.type = "input";
-      promptConfig.default = fieldMeta.defaultValue;
-      promptConfig.validate = (input: string) => {
-        if (fieldMeta.isRequired && !input) {
-          return "This field is required";
-        }
-        return true;
-      };
-    }
-
-    // Add help text if available
-    if (fieldMeta.description) {
-      promptConfig.prefix = chalk.gray(`ℹ  ${fieldMeta.description}\n`);
-    }
-
-    try {
-      const answer = await inquirer.prompt([promptConfig as any]);
-      return answer[fieldMeta.key];
-    } catch (error) {
-      if (this.isUserCancellation(error)) {
-        console.log(chalk.yellow("\n\nOperation cancelled by user"));
-        throw new ZapierCliUserCancellationError();
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Store field value in inputs object with validation
-   */
-  private storeFieldValue(
-    inputs: Record<string, unknown>,
-    key: string,
-    value: unknown,
-    isRequired: boolean,
-  ): void {
-    try {
-      if (value !== undefined && value !== "") {
-        inputs[key] = value;
-      } else if (isRequired) {
-        throw new Error(`Required field ${key} cannot be empty`);
-      }
-    } catch (error) {
-      if (this.isUserCancellation(error)) {
-        console.log(chalk.yellow("\n\nOperation cancelled by user"));
-        throw new ZapierCliUserCancellationError();
-      }
-      throw error;
-    }
-  }
-
-  private async promptForField(
-    field: unknown,
-    inputs: Record<string, unknown>,
-    context?: ResolverContext,
-  ): Promise<void> {
-    const fieldMeta = this.extractFieldMetadata(field);
-
-    // Fetch choices if field has dropdown
-    let choices: Array<{ label: string; value: unknown }> = [];
-    let nextCursor: string | undefined;
-    if (fieldMeta.hasDropdown && context) {
-      const result = await this.fetchChoices(fieldMeta, inputs, context);
-      choices = result.choices;
-      nextCursor = result.nextCursor;
-    }
-
-    // Prompt user based on field type
-    let selectedValue: unknown;
-    if (choices.length > 0) {
-      selectedValue = await this.promptWithChoices({
-        fieldMeta,
-        choices,
-        nextCursor,
-        inputs,
-        context,
-      });
-    } else {
-      selectedValue = await this.promptFreeForm(fieldMeta);
-    }
-
-    // Store result
-    this.storeFieldValue(
-      inputs,
-      fieldMeta.key,
-      selectedValue,
-      fieldMeta.isRequired,
-    );
-  }
-
-  private isUserCancellation(error: unknown): boolean {
-    const errorObj = error as {
-      name?: string;
-      message?: string;
-      isTTYError?: boolean;
-    };
-    return (
-      errorObj?.name === "ExitPromptError" ||
-      errorObj?.message?.includes("User force closed") ||
-      errorObj?.isTTYError === true
-    );
-  }
-
-  private hasResolver(
-    paramName: string,
-    sdk: ZapierSdk,
-    functionName?: string,
-  ): boolean {
-    // Check plugin-specific resolvers first
-    if (functionName && typeof sdk.getRegistry === "function") {
-      const registry = sdk.getRegistry({ package: "cli" });
-      const functionInfo = registry.functions.find(
-        (f) => f.name === functionName,
-      );
-      if (functionInfo && functionInfo.resolvers?.[paramName]) {
-        return true;
-      }
-    }
-
-    // No global registry fallback
-    return false;
-  }
-
-  private getResolver(
-    paramName: string,
-    sdk: ZapierSdk,
-    functionName?: string,
-  ): any {
-    // Check plugin-specific resolvers first
-    if (functionName && typeof sdk.getRegistry === "function") {
-      const registry = sdk.getRegistry({ package: "cli" });
-      const functionInfo = registry.functions.find(
-        (f) => f.name === functionName,
-      );
-      if (functionInfo && functionInfo.resolvers?.[paramName]) {
-        return functionInfo.resolvers[paramName];
-      }
-    }
-
-    // No global registry fallback
-    return null;
-  }
-
-  private getLocalResolvers(
-    sdk: ZapierSdk,
-    functionName?: string,
-  ): Record<string, any> {
-    if (!functionName || typeof sdk.getRegistry !== "function") {
-      return {};
-    }
-
-    const registry = sdk.getRegistry();
-    const functionInfo = registry.functions.find(
-      (f) => f.name === functionName,
-    );
-    return functionInfo?.resolvers || {};
-  }
-}