@zapier/zapier-sdk-cli 0.66.2 → 0.66.3

package/dist/cli.mjs

@@ -1,1515 +1,44 @@
 #!/usr/bin/env node
 import { Command, CommanderError, Option } from 'commander';
-import { getConnectionPlugin, defineMethod, apiPluginRef, resolveCredentialsPluginRef, eventEmissionPluginRef, sdkOptionsPluginRef, declareOptionalProperty, OutputPropertySchema, ZapierBundleError, DEFAULT_CONFIG_PATH, declareMethod, ZapierValidationError, ZapierUnknownError, manifestPluginRef, defineResolver, defineMethodOverride, zapierCoreOptions, injectCliLogin, definePlugin, omitExports, zapierSdkPlugin, BaseSdkOptionsSchema, disposeSdk, isPermanentHttpError, invalidateCachedToken, batch, toSnakeCase, ZapierError, ZapierReleaseTriggerMessageSignal, createSdk as createSdk$1, CORE_OPTIONS_ID as CORE_OPTIONS_ID$1, SDK_OPTIONS_ID as SDK_OPTIONS_ID$1, addPlugin as addPlugin$1, getOrCreateApiClient, isCredentialsObject, ZapierAuthenticationError, ZapierAbortDrainSignal, buildApplicationLifecycleEvent, AuthMechanism, DEPRECATION_NOTICE_EVENT, runWithCallerContext, isPositional, createController, CoreCancelledSignal, resolvePlugin, runWithTelemetryContext, buildCapabilityMessage, formatErrorMessage, getOsInfo, getPlatformVersions, getAgent, getTtyContext, getCiPlatform, isCi, getReleaseId, getCurrentTimestamp, generateEventId, ZapierApprovalError } from '@zapier/zapier-sdk';
+import { getConnectionPlugin, defineMethod, apiPluginRef, resolveCredentialsPluginRef, eventEmissionPluginRef, sdkOptionsPluginRef, declareOptionalProperty, OutputPropertySchema, ZapierBundleError, DEFAULT_CONFIG_PATH, declareMethod, ZapierValidationError, ZapierUnknownError, manifestPluginRef, defineResolver, defineMethodOverride, zapierCoreOptions, injectCliLogin, definePlugin, omitExports, zapierSdkPlugin, BaseSdkOptionsSchema, disposeSdk, isPermanentHttpError, invalidateCachedToken, batch, toSnakeCase, ZapierError, ZapierReleaseTriggerMessageSignal, createSdk as createSdk$1, CORE_OPTIONS_ID as CORE_OPTIONS_ID$1, SDK_OPTIONS_ID as SDK_OPTIONS_ID$1, addPlugin as addPlugin$1, getOrCreateApiClient, isCredentialsObject, ZapierAuthenticationError, ZapierAbortDrainSignal, buildApplicationLifecycleEvent, AuthMechanism, DEPRECATION_NOTICE_EVENT, runWithCallerContext, isPositional, createController, CoreCancelledSignal, resolvePlugin, formatErrorMessage, getOsInfo, getPlatformVersions, getAgent, getTtyContext, getCiPlatform, isCi, getReleaseId, getCurrentTimestamp, generateEventId, ZapierApprovalError } from '@zapier/zapier-sdk';
 import { z } from 'zod';
 import inquirer from 'inquirer';
-import search from '@inquirer/search';
-import chalk from 'chalk';
-import ora from 'ora';
-import { makeTheme, createPrompt, useState, usePrefix, useMemo, useEffect, useKeypress, isEnterKey, isTabKey, isUpKey, isDownKey, usePagination, Separator } from '@inquirer/core';
-import util, { stripVTControlCharacters } from 'util';
-import wrapAnsi3 from 'wrap-ansi';
-import * as jwt from 'jsonwebtoken';
-import { deletePassword, getKeyring, setPassword, getPassword } from 'cross-keychain';
-import Conf from 'conf';
-import * as fs from 'fs';
-import { promises, createWriteStream, existsSync, readdirSync, rmSync, mkdirSync, writeFileSync, copyFileSync, readFileSync } from 'fs';
-import crypto, { createHash } from 'crypto';
-import * as path from 'path';
-import { resolve, join, dirname, basename, relative, extname } from 'path';
-import * as lockfile from 'proper-lockfile';
-import { hostname } from 'os';
-import express from 'express';
-import { createInterface } from 'readline/promises';
-import open from 'open';
-import pkceChallenge from 'pkce-challenge';
-import { startMcpServer } from '@zapier/zapier-sdk-mcp';
-import { buildSync } from 'esbuild';
-import { mkdir, writeFile, access } from 'fs/promises';
-import * as ts from 'typescript';
-import isInstalledGlobally from 'is-installed-globally';
-import { execSync, spawn } from 'child_process';
-import Handlebars from 'handlebars';
-import { fileURLToPath } from 'url';
-import { triggerInboxResolver, DrainTriggerInboxSchema, WatchTriggerInboxSchema, injectCliLogin as injectCliLogin$1, definePlugin as definePlugin$1, omitExports as omitExports$1, zapierExperimentalSdkPlugin, createSdk, CORE_OPTIONS_ID, SDK_OPTIONS_ID, addPlugin } from '@zapier/zapier-sdk/experimental';
-import packageJsonLib, { VersionNotFoundError } from 'package-json';
-import semver from 'semver';
-import * as readline from 'readline';
-
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var ZapierCliError = class extends ZapierError {
-};
-var ZapierCliUserCancellationError = class extends ZapierCliError {
-  constructor(message = "Operation cancelled by user") {
-    super(message);
-    this.name = "ZapierCliUserCancellationError";
-    this.code = "ZAPIER_CLI_USER_CANCELLATION";
-    this.exitCode = 0;
-  }
-};
-var ZapierCliExitError = class extends ZapierCliError {
-  constructor(message, exitCode = 1) {
-    super(message);
-    this.name = "ZapierCliExitError";
-    this.code = "ZAPIER_CLI_EXIT";
-    this.exitCode = exitCode;
-  }
-};
-var ZapierCliValidationError = class _ZapierCliValidationError extends ZapierCliError {
-  constructor(message, options = {}) {
-    super(message);
-    this.exitCode = 1;
-    this.name = options.name ?? "ZapierCliValidationError";
-    this.code = options.code ?? "ZAPIER_CLI_VALIDATION_ERROR";
-  }
-  withMessage(message) {
-    return new _ZapierCliValidationError(message, {
-      name: this.name,
-      code: this.code
-    });
-  }
-};
-var ZapierCliMissingParametersError = class extends ZapierCliError {
-  constructor(params) {
-    super(
-      `Missing required parameters: ${params.map((p) => p.name).join(", ")}`
-    );
-    this.name = "ZapierCliMissingParametersError";
-    this.code = "ZAPIER_CLI_MISSING_PARAMETERS";
-    this.exitCode = 1;
-    this.params = params;
-  }
-};
-
-// src/utils/parameter-resolver.ts
-function formatZodError(error) {
-  return error.issues.map((issue) => {
-    const field = issue.path.length > 0 ? issue.path.join(".") : "input";
-    return `${field}: ${issue.message}`;
-  }).join(", ");
-}
-function getLocalResolutionOrder(paramName, resolvers, resolved = /* @__PURE__ */ new Set()) {
-  const resolver = resolvers[paramName];
-  if (!resolver || resolver.type === "static" || resolver.type === "constant") {
-    return [paramName];
-  }
-  const order = [];
-  if ("depends" in resolver && resolver.depends) {
-    for (const dependency of resolver.depends) {
-      if (!resolved.has(dependency)) {
-        order.push(...getLocalResolutionOrder(dependency, resolvers, resolved));
-        resolved.add(dependency);
-      }
-    }
-  }
-  if (!resolved.has(paramName)) {
-    order.push(paramName);
-    resolved.add(paramName);
-  }
-  return order;
-}
-function getLocalResolutionOrderForParams(paramNames, resolvers) {
-  const resolved = /* @__PURE__ */ new Set();
-  const order = [];
-  for (const paramName of paramNames) {
-    const paramOrder = getLocalResolutionOrder(paramName, resolvers, resolved);
-    for (const param of paramOrder) {
-      if (!order.includes(param)) {
-        order.push(param);
-      }
-    }
-  }
-  return order;
-}
-function unwrapSchema(schema) {
-  let current = schema;
-  while (current instanceof z.ZodOptional || current instanceof z.ZodDefault || current instanceof z.ZodNullable) {
-    current = current._zod.def.innerType;
-  }
-  return current;
-}
-function coerceToSchemaType(value, schema) {
-  if (typeof value !== "string") return value;
-  const base = unwrapSchema(schema);
-  if (base instanceof z.ZodNumber) {
-    const n = Number(value);
-    return Number.isNaN(n) ? value : n;
-  }
-  if (base instanceof z.ZodBoolean) {
-    if (value === "true") return true;
-    if (value === "false") return false;
-  }
-  return value;
-}
-function renderChoiceLabel(choice) {
-  const baseName = choice.label ?? choice.name ?? "";
-  const alreadyNamed = choice.name === baseName;
-  let effectiveHint = choice.hint;
-  if (effectiveHint === void 0 && (typeof choice.value === "string" || typeof choice.value === "number")) {
-    effectiveHint = String(choice.value);
-  }
-  if (!effectiveHint || Array.isArray(effectiveHint) && effectiveHint.length === 0) {
-    return alreadyNamed ? choice : { ...choice, name: baseName };
-  }
-  const hintText = Array.isArray(effectiveHint) ? effectiveHint.join(", ") : effectiveHint;
-  if (hintText === baseName) {
-    return alreadyNamed ? choice : { ...choice, name: baseName };
-  }
-  return { ...choice, name: `${baseName} ${chalk.dim(`(${hintText})`)}` };
-}
-var SchemaParameterResolver = class {
-  constructor() {
-    this.debug = false;
-    this.spinner = null;
-  }
-  debugLog(message) {
-    if (this.debug) {
-      this.stopSpinner();
-      console.error(chalk.gray(`[Zapier CLI] ${message}`));
-    }
-  }
-  startSpinner() {
-    if (!this.debug && !this.spinner) {
-      this.spinner = ora({ text: "", spinner: "dots" }).start();
-    }
-  }
-  stopSpinner() {
-    if (this.spinner) {
-      this.spinner.stop();
-      this.spinner = null;
-    }
-  }
-  async resolveParameters(schema, providedParams, sdk, functionName, options) {
-    return runWithTelemetryContext(async () => {
-      this.debug = options?.debug ?? false;
-      const interactiveMode = (options?.interactiveMode ?? true) && !!process.stdin.isTTY;
-      const parseResult = schema.safeParse(providedParams);
-      const allParams = this.extractParametersFromSchema(schema);
-      const resolvableParams = allParams.filter(
-        (param) => this.hasResolver(param.name, sdk, functionName)
-      );
-      const missingResolvable = resolvableParams.filter((param) => {
-        const hasValue = this.getNestedValue(providedParams, param.path) !== void 0;
-        return !hasValue;
-      });
-      const required = missingResolvable.filter((param) => param.isRequired);
-      const optional = missingResolvable.filter((param) => !param.isRequired);
-      if (parseResult.success && required.length === 0 && optional.length === 0) {
-        return parseResult.data;
-      }
-      if (required.length === 0 && optional.length === 0) {
-        if (!parseResult.success) {
-          throw new ZapierCliValidationError(formatZodError(parseResult.error));
-        }
-        return parseResult.data;
-      }
-      const resolverConstants = this.getResolverConstants(sdk, functionName);
-      const resolvedParams = {
-        ...resolverConstants,
-        ...providedParams
-      };
-      const context = {
-        sdk,
-        currentParams: providedParams,
-        resolvedParams,
-        functionName
-      };
-      const localResolvers = this.getLocalResolvers(sdk, functionName);
-      if (required.length > 0) {
-        const requiredParamNames = required.map((p) => p.name);
-        const requiredResolutionOrder = getLocalResolutionOrderForParams(
-          requiredParamNames,
-          localResolvers
-        );
-        const orderedRequiredParams = requiredResolutionOrder.map((paramName) => {
-          let param = required.find((p) => p.name === paramName);
-          if (!param) {
-            param = optional.find((p) => p.name === paramName);
-          }
-          return param;
-        }).filter((param) => param !== void 0);
-        if (!interactiveMode) {
-          await this.resolveRequiredParamsNonInteractive(
-            orderedRequiredParams,
-            context,
-            resolvedParams,
-            functionName
-          );
-        } else {
-          for (const param of orderedRequiredParams) {
-            try {
-              const value = await this.resolveParameter(
-                param,
-                context,
-                functionName,
-                { isOptional: !param.isRequired }
-              );
-              if (param.isRequired || value !== void 0) {
-                this.setNestedValue(resolvedParams, param.path, value);
-                context.resolvedParams = resolvedParams;
-              }
-            } catch (error) {
-              if (this.isUserCancellation(error)) {
-                console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                throw new ZapierCliUserCancellationError();
-              }
-              throw error;
-            }
-          }
-        }
-        const resolvedParamNames = new Set(
-          orderedRequiredParams.map((p) => p.name)
-        );
-        optional.splice(
-          0,
-          optional.length,
-          ...optional.filter((p) => !resolvedParamNames.has(p.name))
-        );
-      }
-      if (interactiveMode && optional.length > 0) {
-        const optionalParamNames = optional.map((p) => p.name);
-        const optionalResolutionOrder = getLocalResolutionOrderForParams(
-          optionalParamNames,
-          localResolvers
-        );
-        const orderedOptionalParams = optionalResolutionOrder.map((paramName) => optional.find((p) => p.name === paramName)).filter((param) => param !== void 0);
-        for (const param of orderedOptionalParams) {
-          try {
-            const value = await this.resolveParameter(
-              param,
-              context,
-              functionName,
-              { isOptional: true }
-            );
-            if (value !== void 0) {
-              this.setNestedValue(resolvedParams, param.path, value);
-              context.resolvedParams = resolvedParams;
-            }
-          } catch (error) {
-            if (this.isUserCancellation(error)) {
-              console.log(chalk.yellow("\n\nOperation cancelled by user"));
-              throw new ZapierCliUserCancellationError();
-            }
-            throw error;
-          }
-        }
-      }
-      const finalResult = schema.safeParse(resolvedParams);
-      if (!finalResult.success) {
-        throw new ZapierCliValidationError(
-          `Parameter validation failed: ${formatZodError(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._zod.def.innerType;
-    }
-    if (baseSchema instanceof z.ZodDefault) {
-      isRequired = false;
-      baseSchema = baseSchema._zod.def.innerType;
-    }
-    return this.createResolvableParameter([fieldName], baseSchema, isRequired);
-  }
-  createResolvableParameter(path2, schema, isRequired) {
-    if (path2.length === 0) return null;
-    const name = path2[path2.length - 1];
-    return {
-      name,
-      path: path2,
-      schema,
-      description: schema.description,
-      isRequired
-    };
-  }
-  /**
-   * Calls `tryResolveWithoutPrompt` on a dynamic resolver.
-   * Returns the resolution result object, or null if unresolvable / throws.
-   * Note: { resolvedValue: undefined } is a valid result (e.g. connection when app has no auth);
-   * only a null return from the resolver itself means "could not auto-resolve".
-   */
-  async tryAutoResolve(dynamicResolver, context) {
-    if (!dynamicResolver.tryResolveWithoutPrompt) return null;
-    try {
-      return await dynamicResolver.tryResolveWithoutPrompt(
-        context.sdk,
-        context.resolvedParams
-      );
-    } catch (err) {
-      console.warn(
-        `Auto-resolver threw unexpectedly; treating as unresolved. Error: ${err instanceof Error ? err.message : String(err)}`
-      );
-      return null;
-    }
-  }
-  /**
-   * Non-interactive resolution: auto-resolves what it can via tryAutoResolve,
-   * throws ZapierCliMissingParametersError for anything that requires user input.
-   */
-  async resolveRequiredParamsNonInteractive(params, context, resolvedParams, functionName) {
-    const missingParams = [];
-    for (const param of params) {
-      const resolver = this.getResolver(param.name, context.sdk, functionName);
-      let autoResolved = null;
-      if (resolver?.type === "constant") {
-        autoResolved = {
-          resolvedValue: resolver.value
-        };
-      } else if (resolver?.type === "dynamic") {
-        autoResolved = await this.tryAutoResolve(
-          resolver,
-          context
-        );
-      }
-      if (autoResolved != null) {
-        this.setNestedValue(
-          resolvedParams,
-          param.path,
-          autoResolved.resolvedValue
-        );
-        context.resolvedParams = resolvedParams;
-      } else {
-        missingParams.push({
-          name: param.name,
-          // Required params render as positional CLI args (<name>); so do explicitly positional optional params.
-          isPositional: param.isRequired || isPositional(param.schema)
-        });
-      }
-    }
-    if (missingParams.length > 0) {
-      throw new ZapierCliMissingParametersError(missingParams);
-    }
-  }
-  /**
-   * Wrap a PromptConfig.validate so internal sentinels (Symbols) bypass
-   * it. The resolver's validator is intended for actual user values; our
-   * Skip / Custom / Load-more sentinels are internal control-flow and
-   * should pass through. Returns `undefined` when the resolver didn't
-   * supply a validator (so `await search({ ...rest })` doesn't get a
-   * pass-through identity function).
-   */
-  wrapPromptValidate(validate) {
-    if (!validate) return void 0;
-    return (value) => typeof value === "symbol" ? true : validate(value);
-  }
-  /**
-   * Apply a PromptConfig.filter to a selected value, but only when the
-   * value is a real data choice (not an internal sentinel). @inquirer/search
-   * has no built-in filter hook, so the search-backed paths call this
-   * explicitly before returning.
-   */
-  applyPromptFilter(filter, value) {
-    if (!filter || typeof value === "symbol") return value;
-    return filter(value);
-  }
-  /**
-   * If the resolver's PromptConfig sets a `default` value, move the
-   * matching choice to the front so it's the first selectable item in
-   * the rendered source. @inquirer/search has no built-in `default`
-   * option; first-selectable is what Enter picks, so reordering achieves
-   * the same semantics inquirer.prompt's list had natively.
-   *
-   * Returns the original array if no default is set or the default
-   * doesn't match any current choice.
-   */
-  reorderForDefault(matches, defaultValue) {
-    if (defaultValue === void 0) return matches;
-    const idx = matches.findIndex((c) => c.value === defaultValue);
-    if (idx <= 0) return matches;
-    return [matches[idx], ...matches.slice(0, idx), ...matches.slice(idx + 1)];
-  }
-  /**
-   * Build the disabled "if you had X capability, more results would show"
-   * hints for any unmet capabilities the resolver declared. Returns the
-   * raw hint strings — callers wrap them into choice objects with whatever
-   * sentinel value they prefer (disabled choices' values are inert).
-   */
-  async computeCapabilityHints(resolver, context) {
-    if (!resolver.requireCapabilities) return [];
-    const capContext = context.sdk.context;
-    if (!capContext.hasCapability) return [];
-    const messages = [];
-    for (const cap of resolver.requireCapabilities) {
-      const enabled = await capContext.hasCapability(cap);
-      if (!enabled) messages.push(buildCapabilityMessage(cap));
-    }
-    return messages;
-  }
-  /**
-   * Unpack a DynamicResolver.fetch result into the three shapes the caller
-   * cares about: a flat items array, an optional AsyncIterator for further
-   * pagination, and a hasMore flag. Centralizing keeps the AsyncIterable /
-   * `{data, nextCursor}` / `TItem[]` discrimination in one place — both
-   * the main dropdown loop and the search-mode flow consume it.
-   *
-   * The function is `async` for the AsyncIterable branch only (we eagerly
-   * consume the first page so callers don't have to discriminate). The
-   * other two branches return synchronously; an explicit Promise.resolve
-   * is unnecessary because async automatically wraps.
-   *
-   * Note: callers in search mode intentionally drop `pageIterator` /
-   * `hasMore` because each search() invocation re-prompts from scratch;
-   * pagination only matters when the prompt is the dropdown itself.
-   */
-  async unpackFetchResult(fetchResult, promptLabel) {
-    if (fetchResult != null && typeof fetchResult === "object" && Symbol.asyncIterator in fetchResult) {
-      const pageIterator = fetchResult[Symbol.asyncIterator]();
-      const first = await pageIterator.next();
-      if (!first.done && first.value) {
-        return {
-          items: Array.isArray(first.value.data) ? first.value.data : [],
-          pageIterator,
-          hasMore: first.value.nextCursor != null
-        };
-      }
-      return { items: [], pageIterator, hasMore: false };
-    }
-    if (fetchResult != null && typeof fetchResult === "object" && "data" in fetchResult) {
-      const page = fetchResult;
-      const hasMore = page.nextCursor != null;
-      if (hasMore) {
-        this.debugLog(
-          `Resolver for ${promptLabel} has more pages but no iterator. Return the paginated result's .pages() instead of an awaited page to enable "Load more..." support.`
-        );
-      }
-      return {
-        items: Array.isArray(page.data) ? page.data : [],
-        pageIterator: null,
-        hasMore
-      };
-    }
-    return {
-      items: Array.isArray(fetchResult) ? fetchResult : [],
-      pageIterator: null,
-      hasMore: false
-    };
-  }
-  /**
-   * Search-mode dynamic resolver: prompts the user for free-form text, passes
-   * it to fetch via `search`, and either short-circuits on a primitive return
-   * (exact match) or renders the results as a search-filterable dropdown.
-   * Empty results still render the dropdown so the user can fall through to
-   * "(Use 'foo' as-is)" or "(Try a different search)" rather than being
-   * stuck.
-   *
-   * Known limitation: pagination beyond the first page is dropped. Each
-   * search() invocation re-prompts from scratch and the user is expected
-   * to refine their query if too many results came back. If a future
-   * high-cardinality search resolver needs Load-more here, the
-   * `pageIterator` / `hasMore` from `unpackFetchResult` is what to wire in.
-   */
-  async resolveDynamicWithSearchInput({
-    resolver,
-    context,
-    promptLabel,
-    isOptional
-  }) {
-    const parenParts = [];
-    if (isOptional) parenParts.push("optional");
-    if (resolver.placeholder) parenParts.push(resolver.placeholder);
-    const parens = parenParts.length > 0 ? ` (${parenParts.join(", ")})` : "";
-    const message = `Enter or search ${promptLabel}${parens}:`;
-    const SKIP_SENTINEL = Symbol("SKIP");
-    const USE_AS_IS_SENTINEL = Symbol("USE_AS_IS");
-    const TRY_AGAIN_SENTINEL = Symbol("TRY_AGAIN");
-    let lastNote;
-    while (true) {
-      this.stopSpinner();
-      if (lastNote) {
-        console.log(chalk.yellow(lastNote));
-        lastNote = void 0;
-      }
-      const answers = await inquirer.prompt([
-        { type: "input", name: "search", message }
-      ]);
-      const rawInput = answers.search;
-      const searchInput = typeof rawInput === "string" ? rawInput.trim() : "";
-      if (!searchInput) {
-        if (isOptional) return void 0;
-        lastNote = `${promptLabel} is required.`;
-        continue;
-      }
-      const searchParams = {
-        ...context.resolvedParams,
-        search: searchInput
-      };
-      this.startSpinner();
-      this.debugLog(`Searching ${promptLabel} for "${searchInput}"`);
-      let fetchResult;
-      try {
-        fetchResult = await resolver.fetch(context.sdk, searchParams);
-      } finally {
-        this.stopSpinner();
-      }
-      if (typeof fetchResult === "string" || typeof fetchResult === "number") {
-        return fetchResult;
-      }
-      const { items } = await this.unpackFetchResult(fetchResult, promptLabel);
-      const choicesConfig = resolver.prompt(items, searchParams);
-      const dataChoices = (choicesConfig.choices ?? []).map(renderChoiceLabel);
-      const capabilityHintMessages = await this.computeCapabilityHints(
-        resolver,
-        context
-      );
-      const selected = await search({
-        message: choicesConfig.message,
-        validate: this.wrapPromptValidate(choicesConfig.validate),
-        // @inquirer/search passes an AbortSignal as the second arg for
-        // cancelling async sources. All three of our source callbacks are
-        // pure-local (filter an already-fetched array), so we intentionally
-        // ignore the signal. A future server-side filter implementation
-        // would need to honor it.
-        source: (term) => {
-          const trimmed = (term ?? "").trim();
-          const lower = trimmed.toLowerCase();
-          const matches = trimmed ? dataChoices.filter((c) => c.name.toLowerCase().includes(lower)) : dataChoices;
-          const orderedMatches = trimmed ? matches : this.reorderForDefault(matches, choicesConfig.default);
-          const skipChoice = isOptional ? [{ name: chalk.dim("(Skip)"), value: SKIP_SENTINEL }] : [];
-          const useAsIsChoice = {
-            name: chalk.dim(`(Use ${JSON.stringify(searchInput)} as-is)`),
-            value: USE_AS_IS_SENTINEL
-          };
-          const tryAgainChoice = {
-            name: chalk.dim("(Try a different search)"),
-            value: TRY_AGAIN_SENTINEL
-          };
-          const out2 = [];
-          if (orderedMatches.length === 0) {
-            out2.push(useAsIsChoice);
-            out2.push(tryAgainChoice);
-            out2.push(...skipChoice);
-          } else {
-            out2.push(...orderedMatches);
-            out2.push(...skipChoice);
-            out2.push(useAsIsChoice);
-            out2.push(tryAgainChoice);
-          }
-          for (const message2 of capabilityHintMessages) {
-            out2.push({
-              name: chalk.dim(message2),
-              value: SKIP_SENTINEL,
-              disabled: true
-            });
-          }
-          return out2;
-        }
-      });
-      if (selected === SKIP_SENTINEL) return void 0;
-      if (selected === USE_AS_IS_SENTINEL) {
-        const validationResult = choicesConfig.validate?.(searchInput);
-        if (validationResult === false) {
-          lastNote = `${promptLabel}: invalid value.`;
-          continue;
-        }
-        if (typeof validationResult === "string") {
-          lastNote = validationResult;
-          continue;
-        }
-        return this.applyPromptFilter(choicesConfig.filter, searchInput);
-      }
-      if (selected === TRY_AGAIN_SENTINEL) continue;
-      return this.applyPromptFilter(choicesConfig.filter, selected);
-    }
-  }
-  async resolveParameter(param, context, functionName, options) {
-    const resolver = this.getResolver(
-      param.name,
-      context.sdk,
-      functionName
-    );
-    if (!resolver) {
-      throw new Error(`No resolver found for parameter: ${param.name}`);
-    }
-    return this.resolveWithResolver(resolver, param, context, {
-      isOptional: options?.isOptional
-    });
-  }
-  /**
-   * Run a resolver to obtain a value for one parameter, prompting the
-   * user when necessary. Routes to one of several prompt backends and
-   * has to keep the `PromptConfig` contract honest across each one.
-   *
-   * `PromptConfig` field × prompt-backend handling:
-   *
-   *  | field    | list (search()) | checkbox/confirm (inquirer.prompt) | search-mode dropdown (search()) |
-   *  | -------- | --------------- | ---------------------------------- | ------------------------------- |
-   *  | type     | required        | required                           | required                        |
-   *  | name     | (set internally)| forwarded                          | (set internally)                |
-   *  | message  | forwarded       | forwarded                          | forwarded                       |
-   *  | choices  | filtered in src | passed to inquirer                 | filtered in src                 |
-   *  | default  | reorder matches | passed (also internal cursor jump) | reorder matches                 |
-   *  | validate | wrapped         | passed (inquirer native)           | wrapped + manual for (Use as-is)|
-   *  | filter   | manual once     | inquirer native (do NOT double)    | manual once                     |
-   *
-   * Escape-hatch sentinels (Skip / Custom value / Use as-is / Load more
-   * / Try again) bypass the resolver's validate/filter because they
-   * aren't real user values — they're CLI control-flow.
-   */
-  async resolveWithResolver(resolver, param, context, options = {}) {
-    const { arrayIndex, isOptional } = options;
-    const inArrayContext = arrayIndex != null;
-    const promptLabel = inArrayContext ? `${param.name}[${arrayIndex}]` : param.name;
-    const promptName = inArrayContext ? "value" : param.name;
-    this.debugLog(`Resolving ${promptLabel}${isOptional ? " (optional)" : ""}`);
-    if (resolver.type === "constant") {
-      const constantResolver = resolver;
-      this.stopSpinner();
-      return constantResolver.value;
-    } else if (resolver.type === "static") {
-      const staticResolver = resolver;
-      const promptConfig = {
-        type: staticResolver.inputType === "password" ? "password" : "input",
-        name: promptName,
-        message: `Enter ${promptLabel}${isOptional ? " (optional)" : ""}:`,
-        ...staticResolver.placeholder && {
-          default: staticResolver.placeholder
-        }
-      };
-      this.stopSpinner();
-      const answers = await inquirer.prompt([promptConfig]);
-      const value = answers[promptName];
-      if (isOptional && (value === void 0 || value === "" || value === staticResolver.placeholder)) {
-        return void 0;
-      }
-      return coerceToSchemaType(value, param.schema);
-    } else if (resolver.type === "dynamic") {
-      const dynamicResolver = resolver;
-      this.startSpinner();
-      const autoResolution = await this.tryAutoResolve(
-        dynamicResolver,
-        context
-      );
-      if (autoResolution != null) {
-        this.stopSpinner();
-        return autoResolution.resolvedValue;
-      }
-      if (dynamicResolver.inputType === "search") {
-        this.stopSpinner();
-        return await this.resolveDynamicWithSearchInput({
-          resolver: dynamicResolver,
-          context,
-          promptLabel,
-          isOptional: isOptional ?? false
-        });
-      }
-      this.debugLog(`Fetching options for ${promptLabel}`);
-      let fetchResult;
-      try {
-        fetchResult = await dynamicResolver.fetch(
-          context.sdk,
-          context.resolvedParams
-        );
-      } finally {
-        this.stopSpinner();
-      }
-      if (typeof fetchResult === "string" || typeof fetchResult === "number") {
-        console.error(
-          chalk.yellow(
-            `Resolver for ${promptLabel} returned a primitive value but is not in search mode. Set inputType: "search" on the resolver if you want exact-match short-circuit. Falling back to manual entry.`
-          )
-        );
-        const fallbackAnswers = await inquirer.prompt([
-          {
-            type: "input",
-            name: promptName,
-            message: `Enter ${promptLabel}${isOptional ? " (optional)" : ""}:`
-          }
-        ]);
-        const fallbackValue = fallbackAnswers[promptName];
-        if (isOptional && (fallbackValue === void 0 || fallbackValue === "")) {
-          return void 0;
-        }
-        return fallbackValue;
-      }
-      const unpacked = await this.unpackFetchResult(fetchResult, promptLabel);
-      let pageIterator = unpacked.pageIterator;
-      let items = unpacked.items;
-      let hasMore = unpacked.hasMore;
-      const LOAD_MORE_SENTINEL = Symbol("LOAD_MORE");
-      const SKIP_SENTINEL = Symbol("SKIP");
-      const CUSTOM_VALUE_SENTINEL = Symbol("CUSTOM_VALUE");
-      let newItemsStartIndex = -1;
-      while (true) {
-        const promptConfig = dynamicResolver.prompt(
-          items,
-          context.resolvedParams
-        );
-        promptConfig.name = promptName;
-        const renderedChoices = promptConfig.choices ? promptConfig.choices.map(renderChoiceLabel) : [];
-        if (promptConfig.choices) {
-          promptConfig.choices = renderedChoices;
-        }
-        const hasSelectableChoice = promptConfig.choices?.some(
-          (c) => !c.disabled
-        );
-        if (!hasSelectableChoice && !hasMore) {
-          throw new ZapierCliValidationError(
-            `No ${promptLabel} available to select.`
-          );
-        }
-        const capabilityHints = [];
-        if (!hasMore) {
-          const hintMessages = await this.computeCapabilityHints(
-            dynamicResolver,
-            context
-          );
-          for (const message of hintMessages) {
-            capabilityHints.push({
-              name: chalk.dim(message),
-              value: SKIP_SENTINEL,
-              disabled: true
-            });
-          }
-        }
-        let selected;
-        if (promptConfig.type === "list") {
-          const dataChoices = renderedChoices;
-          selected = await search({
-            message: promptConfig.message,
-            validate: this.wrapPromptValidate(promptConfig.validate),
-            source: (term) => {
-              const trimmed = (term ?? "").trim();
-              const lower = trimmed.toLowerCase();
-              const matches = trimmed ? dataChoices.filter(
-                (c) => c.name.toLowerCase().includes(lower)
-              ) : dataChoices;
-              const out2 = [];
-              const skipChoice = isOptional ? [
-                {
-                  name: chalk.dim("(Skip)"),
-                  value: SKIP_SENTINEL
-                }
-              ] : [];
-              const customValueChoice = {
-                name: chalk.dim("(Enter custom value)"),
-                value: CUSTOM_VALUE_SENTINEL
-              };
-              const orderedMatches = trimmed ? matches : this.reorderForDefault(matches, promptConfig.default);
-              const matchesFirst = trimmed || promptConfig.default !== void 0;
-              const loadMoreChoice = hasMore && pageIterator ? {
-                name: chalk.dim("(Load more...)"),
-                value: LOAD_MORE_SENTINEL
-              } : null;
-              if (matchesFirst && orderedMatches.length > 0) {
-                out2.push(...orderedMatches);
-                out2.push(...skipChoice);
-                out2.push(customValueChoice);
-                if (loadMoreChoice) out2.push(loadMoreChoice);
-              } else if (matchesFirst) {
-                out2.push(customValueChoice);
-                if (loadMoreChoice) out2.push(loadMoreChoice);
-                out2.push(...skipChoice);
-              } else {
-                out2.push(...skipChoice);
-                out2.push(customValueChoice);
-                out2.push(...orderedMatches);
-                if (loadMoreChoice) out2.push(loadMoreChoice);
-              }
-              if (capabilityHints.length > 0 && (!trimmed || matches.length > 0)) {
-                out2.push(...capabilityHints);
-              }
-              return out2;
-            }
-          });
-        } else {
-          if (isOptional && promptConfig.choices) {
-            promptConfig.choices.unshift({
-              name: chalk.dim("(Skip)"),
-              value: SKIP_SENTINEL
-            });
-          }
-          if (hasMore && pageIterator && promptConfig.choices) {
-            promptConfig.choices.push({
-              name: chalk.dim("(Load more...)"),
-              value: LOAD_MORE_SENTINEL
-            });
-          }
-          if (capabilityHints.length > 0 && promptConfig.choices) {
-            promptConfig.choices.push(...capabilityHints);
-          }
-          if (newItemsStartIndex >= 0 && promptConfig.choices) {
-            const injectedBefore = isOptional ? 1 : 0;
-            const adjustedIndex = newItemsStartIndex + injectedBefore;
-            if (promptConfig.choices[adjustedIndex]) {
-              promptConfig.default = promptConfig.choices[adjustedIndex].value;
-            }
-            newItemsStartIndex = -1;
-          }
-          const answers = await inquirer.prompt([promptConfig]);
-          selected = answers[promptName];
-        }
-        if (selected === SKIP_SENTINEL) {
-          return void 0;
-        }
-        if (selected === CUSTOM_VALUE_SENTINEL) {
-          const customAnswer = await inquirer.prompt([
-            {
-              type: "input",
-              name: promptName,
-              message: `Enter ${promptLabel}${isOptional ? " (optional)" : ""}:`
-            }
-          ]);
-          const value = customAnswer[promptName];
-          if (isOptional && (value === void 0 || value === "")) {
-            return void 0;
-          }
-          return value;
-        }
-        const wantsMore = Array.isArray(selected) ? selected.includes(LOAD_MORE_SENTINEL) : selected === LOAD_MORE_SENTINEL;
-        if (wantsMore && pageIterator) {
-          if (Array.isArray(selected)) {
-            selected = selected.filter(
-              (v) => v !== LOAD_MORE_SENTINEL
-            );
-          }
-          const prevLength = items.length;
-          this.startSpinner();
-          this.debugLog("Fetching more options...");
-          const next = await pageIterator.next();
-          this.stopSpinner();
-          if (!next.done && next.value) {
-            items = [...items, ...next.value.data];
-            hasMore = next.value.nextCursor != null;
-            newItemsStartIndex = prevLength;
-          } else {
-            hasMore = false;
-          }
-          continue;
-        }
-        return promptConfig.type === "list" ? this.applyPromptFilter(promptConfig.filter, selected) : selected;
-      }
-    } else if (resolver.type === "fields") {
-      if (isOptional && !inArrayContext) {
-        this.stopSpinner();
-        const { confirm } = await inquirer.prompt([
-          {
-            type: "confirm",
-            name: "confirm",
-            message: `Add ${promptLabel}?`,
-            default: false
-          }
-        ]);
-        if (!confirm) {
-          return void 0;
-        }
-      }
-      return await this.resolveFieldsRecursively(
-        resolver,
-        context,
-        param,
-        { inArrayContext }
-      );
-    } else if (resolver.type === "array") {
-      return await this.resolveArrayRecursively(
-        resolver,
-        context,
-        param
-      );
-    }
-    throw new Error(`Unknown resolver type for ${promptLabel}`);
-  }
-  async resolveFieldsRecursively(resolver, context, param, options = {}) {
-    const inputs = {};
-    let processedFieldKeys = /* @__PURE__ */ new Set();
-    let iteration = 0;
-    const maxIterations = 10;
-    while (iteration < maxIterations) {
-      iteration++;
-      const updatedContext = {
-        ...context,
-        resolvedParams: {
-          ...context.resolvedParams,
-          inputs
-        }
-      };
-      this.debugLog(
-        `Fetching input fields for ${param.name}${iteration > 1 ? ` (iteration ${iteration})` : ""}`
-      );
-      this.startSpinner();
-      const rootFieldItems = await resolver.fetch(
-        updatedContext.sdk,
-        updatedContext.resolvedParams
-      );
-      this.stopSpinner();
-      if (!rootFieldItems || rootFieldItems.length === 0) {
-        if (iteration === 1) {
-          console.log(
-            chalk.yellow(`No input fields required for this action.`)
-          );
-        }
-        break;
-      }
-      const fieldStats = await this.processFieldItems(
-        rootFieldItems,
-        inputs,
-        processedFieldKeys,
-        [],
-        iteration,
-        updatedContext,
-        { inArrayContext: options.inArrayContext }
-      );
-      if (fieldStats.newRequired === 0 && fieldStats.newOptional === 0) {
-        break;
-      }
-      if (fieldStats.newRequired === 0 && fieldStats.optionalSkipped) {
-        break;
-      }
-    }
-    if (iteration >= maxIterations) {
-      console.log(
-        chalk.yellow(
-          `
-\u26A0\uFE0F  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`
-        )
-      );
-    }
-    if (resolver.transform) {
-      return resolver.transform(inputs);
-    }
-    return inputs;
-  }
-  /**
-   * Resolves an array parameter by repeatedly prompting for items until user says no
-   */
-  async resolveArrayRecursively(resolver, context, param) {
-    const items = [];
-    const minItems = resolver.minItems ?? 0;
-    const maxItems = resolver.maxItems ?? Infinity;
-    while (items.length < maxItems) {
-      const currentIndex = items.length;
-      if (currentIndex >= minItems) {
-        this.stopSpinner();
-        const confirmAnswer = await inquirer.prompt([
-          {
-            type: "confirm",
-            name: "addItem",
-            message: `Add ${param.name}[${currentIndex}]?`,
-            default: false
-          }
-        ]);
-        if (!confirmAnswer.addItem) {
-          break;
-        }
-      }
-      const innerResolver = await resolver.fetch(
-        context.sdk,
-        context.resolvedParams
-      );
-      const itemValue = await this.resolveWithResolver(
-        innerResolver,
-        param,
-        context,
-        { arrayIndex: currentIndex }
-      );
-      items.push(itemValue);
-      context.resolvedParams = {
-        ...context.resolvedParams,
-        [param.name]: items
-      };
-    }
-    if (items.length >= maxItems) {
-      console.log(chalk.gray(`Maximum of ${maxItems} items reached.`));
-    }
-    return items;
-  }
-  /**
-   * Recursively processes fieldsets and their fields, maintaining natural structure
-   * and creating nested inputs as needed (e.g., fieldset "foo" becomes inputs.foo = [{}])
-   */
-  async processFieldItems(items, targetInputs, processedFieldKeys, fieldsetPath = [], iteration = 1, context, options = {}) {
-    let newRequiredCount = 0;
-    let newOptionalCount = 0;
-    let optionalSkipped = false;
-    for (const item of items) {
-      const typedItem = item;
-      if (typedItem.type === "fieldset" && typedItem.fields && typedItem.key) {
-        const fieldsetTitle = typedItem.title || typedItem.key;
-        const pathDisplay = fieldsetPath.length > 0 ? ` (in ${fieldsetPath.join(" > ")})` : "";
-        console.log(
-          chalk.cyan(
-            `
-\u{1F4C1} Processing fieldset: ${fieldsetTitle}${pathDisplay}`
-          )
-        );
-        if (!targetInputs[typedItem.key]) {
-          targetInputs[typedItem.key] = [{}];
-        }
-        const fieldsetTarget = targetInputs[typedItem.key][0];
-        const nestedPath = [...fieldsetPath, fieldsetTitle];
-        const nestedStats = await this.processFieldItems(
-          typedItem.fields,
-          fieldsetTarget,
-          processedFieldKeys,
-          nestedPath,
-          iteration,
-          context,
-          options
-        );
-        newRequiredCount += nestedStats.newRequired;
-        newOptionalCount += nestedStats.newOptional;
-        if (nestedStats.optionalSkipped) {
-          optionalSkipped = true;
-        }
-      } else if (typedItem.type === "input_field" && typedItem.key) {
-        if (processedFieldKeys.has(typedItem.key)) {
-          continue;
-        }
-        const isRequired = typedItem.is_required || false;
-        if (isRequired) {
-          newRequiredCount++;
-          if (typedItem.resolver && context) {
-            const param = {
-              name: typedItem.key,
-              path: [typedItem.key],
-              schema: z.unknown(),
-              isRequired: true
-            };
-            targetInputs[typedItem.key] = await this.resolveWithResolver(
-              typedItem.resolver,
-              param,
-              context,
-              { isOptional: false }
-            );
-          } else {
-            await this.promptForField(typedItem, targetInputs, context);
-          }
-          processedFieldKeys.add(typedItem.key);
-        } else {
-          newOptionalCount++;
-        }
-      }
-    }
-    if (newOptionalCount > 0) {
-      const optionalFields = items.filter((item) => {
-        const typedItem = item;
-        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(" > ")}` : "";
-        if (options.inArrayContext) {
-          for (const field of optionalFields) {
-            await this.promptForField(field, targetInputs, context);
-            const typedField = field;
-            processedFieldKeys.add(typedField.key);
-          }
-        } else {
-          console.log(
-            chalk.gray(
-              `
-There 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(`
-Optional fields${pathContext}:`));
-              for (const field of optionalFields) {
-                await this.promptForField(field, targetInputs, context);
-                const typedField = field;
-                processedFieldKeys.add(typedField.key);
-              }
-            } else {
-              optionalSkipped = true;
-              optionalFields.forEach((field) => {
-                const typedField = field;
-                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
-    };
-  }
-  getNestedValue(obj, path2) {
-    return path2.reduce(
-      (current, key) => current?.[key],
-      obj
-    );
-  }
-  setNestedValue(obj, path2, value) {
-    const lastKey = path2[path2.length - 1];
-    const parent = path2.slice(0, -1).reduce((current, key) => {
-      const currentObj = current;
-      if (!(key in currentObj)) {
-        currentObj[key] = {};
-      }
-      return currentObj[key];
-    }, obj);
-    parent[lastKey] = value;
-  }
-  /**
-   * Extract and normalize field metadata from raw field object
-   */
-  extractFieldMetadata(field) {
-    const fieldObj = field;
-    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" || Boolean(fieldObj.choices),
-      isMultiSelect: Boolean(
-        valueType === "array" || fieldObj.items && fieldObj.items.type !== void 0
-      ),
-      inlineChoices: fieldObj.choices
-    };
-  }
-  /**
-   * Fetch a page of choices for a dropdown field
-   */
-  async fetchChoices(fieldMeta, inputs, context, cursor) {
-    try {
-      this.debugLog(
-        cursor ? `Fetching more choices for ${fieldMeta.title}` : `Fetching choices for ${fieldMeta.title}`
-      );
-      this.startSpinner();
-      const page = await context.sdk.listActionInputFieldChoices({
-        app: context.resolvedParams.app,
-        action: context.resolvedParams.action,
-        actionType: context.resolvedParams.actionType,
-        connection: context.resolvedParams.connection,
-        inputField: fieldMeta.key,
-        inputs,
-        ...cursor && { cursor }
-      });
-      this.stopSpinner();
-      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) {
-      this.stopSpinner();
-      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).
-   * Single-select goes through @inquirer/search so users can type-to-filter long
-   * dropdowns (SELECT fields); multi-select stays on inquirer.prompt since search
-   * is single-select only.
-   */
-  async promptWithChoices({
-    fieldMeta,
-    choices: initialChoices,
-    nextCursor: initialCursor,
-    inputs,
-    context
-  }) {
-    this.stopSpinner();
-    const choices = [...initialChoices];
-    let nextCursor = initialCursor;
-    const LOAD_MORE_SENTINEL = Symbol("LOAD_MORE");
-    const SKIP_SENTINEL = Symbol("SKIP");
-    const CUSTOM_VALUE_SENTINEL = Symbol("CUSTOM_VALUE");
-    const message = `${fieldMeta.title}${fieldMeta.isRequired ? " (required)" : " (optional)"}:`;
-    while (true) {
-      let selectedValue;
-      if (!fieldMeta.isMultiSelect) {
-        const dataChoices = choices.map((c) => ({
-          name: c.label,
-          value: c.value
-        }));
-        selectedValue = await search({
-          message,
-          source: (term) => {
-            const trimmed = (term ?? "").trim();
-            const lower = trimmed.toLowerCase();
-            const matches = trimmed ? dataChoices.filter((c) => c.name.toLowerCase().includes(lower)) : dataChoices;
-            const out2 = [];
-            const skipChoice = !fieldMeta.isRequired ? [{ name: chalk.dim("(Skip)"), value: SKIP_SENTINEL }] : [];
-            const customValueChoice = {
-              name: chalk.dim("(Enter custom value)"),
-              value: CUSTOM_VALUE_SENTINEL
-            };
-            const loadMoreChoice = nextCursor && context ? {
-              name: chalk.dim("(Load more...)"),
-              value: LOAD_MORE_SENTINEL
-            } : null;
-            if (trimmed && matches.length > 0) {
-              out2.push(...matches);
-              out2.push(...skipChoice);
-              out2.push(customValueChoice);
-              if (loadMoreChoice) out2.push(loadMoreChoice);
-            } else if (trimmed) {
-              out2.push(customValueChoice);
-              if (loadMoreChoice) out2.push(loadMoreChoice);
-              out2.push(...skipChoice);
-            } else {
-              out2.push(...skipChoice);
-              out2.push(customValueChoice);
-              out2.push(...matches);
-              if (loadMoreChoice) out2.push(loadMoreChoice);
-            }
-            return out2;
-          }
-        });
-        if (selectedValue === SKIP_SENTINEL) {
-          return void 0;
-        }
-        if (selectedValue === CUSTOM_VALUE_SENTINEL) {
-          return await this.promptFreeForm(fieldMeta);
-        }
-      } else {
-        const promptChoices = choices.map((c) => ({
-          name: c.label,
-          value: c.value
-        }));
-        if (nextCursor) {
-          promptChoices.push({
-            name: chalk.dim("(Load more...)"),
-            value: LOAD_MORE_SENTINEL
-          });
-        }
-        const promptConfig = {
-          type: "checkbox",
-          name: fieldMeta.key,
-          message,
-          choices: promptChoices,
-          validate: (input) => {
-            if (fieldMeta.isRequired && (!input || input.length === 0)) {
-              return "At least one selection is required";
-            }
-            return true;
-          }
-        };
-        const answer = await inquirer.prompt([promptConfig]);
-        selectedValue = answer[fieldMeta.key];
-      }
-      const wantsMore = fieldMeta.isMultiSelect ? Array.isArray(selectedValue) && selectedValue.includes(LOAD_MORE_SENTINEL) : selectedValue === LOAD_MORE_SENTINEL;
-      if (wantsMore && nextCursor && context) {
-        if (fieldMeta.isMultiSelect && Array.isArray(selectedValue)) {
-          selectedValue = selectedValue.filter((v) => v !== LOAD_MORE_SENTINEL);
-        }
-        const result = await this.fetchChoices(
-          fieldMeta,
-          inputs,
-          context,
-          nextCursor
-        );
-        choices.push(...result.choices);
-        nextCursor = result.nextCursor;
-        continue;
-      }
-      return selectedValue;
-    }
-  }
-  /**
-   * Prompt user for free-form input (text or boolean)
-   */
-  async promptFreeForm(fieldMeta) {
-    const promptConfig = {
-      name: fieldMeta.key,
-      message: `${fieldMeta.title}${fieldMeta.isRequired ? " (required)" : " (optional)"}:`
-    };
-    if (fieldMeta.valueType === "boolean") {
-      promptConfig.type = "confirm";
-      promptConfig.default = fieldMeta.defaultValue !== void 0 ? Boolean(fieldMeta.defaultValue) : void 0;
-    } else if (fieldMeta.valueType === "array") {
-      promptConfig.type = "input";
-      promptConfig.default = fieldMeta.defaultValue;
-      promptConfig.message = `${fieldMeta.title}${fieldMeta.isRequired ? " (required)" : " (optional)"} (JSON array or comma-separated):`;
-      promptConfig.validate = (input) => {
-        if (fieldMeta.isRequired && !input) {
-          return "This field is required";
-        }
-        return true;
-      };
-      promptConfig.filter = (input) => {
-        if (!input) return input;
-        const trimmed = input.trim();
-        if (trimmed.startsWith("[")) {
-          try {
-            return JSON.parse(trimmed);
-          } catch {
-          }
-        }
-        return trimmed.split(",").map((s) => s.trim());
-      };
-    } else {
-      promptConfig.type = "input";
-      promptConfig.default = fieldMeta.defaultValue;
-      promptConfig.validate = (input) => {
-        if (fieldMeta.isRequired && !input) {
-          return "This field is required";
-        }
-        return true;
-      };
-    }
-    if (fieldMeta.description) {
-      promptConfig.prefix = chalk.gray(`\u2139  ${fieldMeta.description}
-`);
-    }
-    try {
-      const answer = await inquirer.prompt([promptConfig]);
-      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
-   */
-  storeFieldValue(inputs, key, value, isRequired) {
-    try {
-      if (value !== void 0 && 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;
-    }
-  }
-  async promptForField(field, inputs, context) {
-    const fieldMeta = this.extractFieldMetadata(field);
-    let choices = [];
-    let nextCursor;
-    if (fieldMeta.inlineChoices) {
-      choices = fieldMeta.inlineChoices;
-    } else if (fieldMeta.hasDropdown && context) {
-      const result = await this.fetchChoices(fieldMeta, inputs, context);
-      choices = result.choices;
-      nextCursor = result.nextCursor;
-    }
-    let selectedValue;
-    if (choices.length > 0) {
-      selectedValue = await this.promptWithChoices({
-        fieldMeta,
-        choices,
-        nextCursor,
-        inputs,
-        context
-      });
-    } else {
-      selectedValue = await this.promptFreeForm(fieldMeta);
-    }
-    this.storeFieldValue(
-      inputs,
-      fieldMeta.key,
-      selectedValue,
-      fieldMeta.isRequired
-    );
-  }
-  isUserCancellation(error) {
-    const errorObj = error;
-    return errorObj?.name === "ExitPromptError" || errorObj?.message?.includes("User force closed") || errorObj?.isTTYError === true;
-  }
-  hasResolver(paramName, sdk, functionName) {
-    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;
-      }
-    }
-    return false;
-  }
-  getResolver(paramName, sdk, functionName) {
-    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];
-      }
-    }
-    return null;
-  }
-  getLocalResolvers(sdk, functionName) {
-    if (!functionName || typeof sdk.getRegistry !== "function") {
-      return {};
-    }
-    const registry = sdk.getRegistry();
-    const functionInfo = registry.functions.find(
-      (f) => f.name === functionName
-    );
-    return functionInfo?.resolvers || {};
-  }
-  getResolverConstants(sdk, functionName) {
-    if (!functionName || typeof sdk.getRegistry !== "function") {
-      return {};
-    }
-    const registry = sdk.getRegistry();
-    const functionInfo = registry.functions.find(
-      (f) => f.name === functionName
-    );
-    const resolvers = functionInfo?.resolvers ?? {};
-    const constants = {};
-    for (const [key, resolver] of Object.entries(resolvers)) {
-      if (resolver && typeof resolver === "object" && resolver.type === "constant") {
-        constants[key] = resolver.value;
-      }
-    }
-    return constants;
-  }
+import chalk8 from 'chalk';
+import { makeTheme, createPrompt, useState, usePrefix, useMemo, useEffect, useKeypress, isEnterKey, isTabKey, isUpKey, isDownKey, usePagination, Separator } from '@inquirer/core';
+import ora from 'ora';
+import util, { stripVTControlCharacters } from 'util';
+import wrapAnsi3 from 'wrap-ansi';
+import * as jwt from 'jsonwebtoken';
+import { deletePassword, getKeyring, setPassword, getPassword } from 'cross-keychain';
+import Conf from 'conf';
+import * as fs from 'fs';
+import { promises, createWriteStream, existsSync, readdirSync, rmSync, mkdirSync, writeFileSync, copyFileSync, readFileSync } from 'fs';
+import crypto, { createHash } from 'crypto';
+import * as path from 'path';
+import { resolve, join, dirname, basename, relative, extname } from 'path';
+import * as lockfile from 'proper-lockfile';
+import { hostname } from 'os';
+import express from 'express';
+import { createInterface } from 'readline/promises';
+import open from 'open';
+import pkceChallenge from 'pkce-challenge';
+import { startMcpServer } from '@zapier/zapier-sdk-mcp';
+import { buildSync } from 'esbuild';
+import { mkdir, writeFile, access } from 'fs/promises';
+import * as ts from 'typescript';
+import isInstalledGlobally from 'is-installed-globally';
+import { execSync, spawn } from 'child_process';
+import Handlebars from 'handlebars';
+import { fileURLToPath } from 'url';
+import { triggerInboxResolver, DrainTriggerInboxSchema, WatchTriggerInboxSchema, injectCliLogin as injectCliLogin$1, definePlugin as definePlugin$1, omitExports as omitExports$1, zapierExperimentalSdkPlugin, createSdk, CORE_OPTIONS_ID, SDK_OPTIONS_ID, addPlugin } from '@zapier/zapier-sdk/experimental';
+import packageJsonLib, { VersionNotFoundError } from 'package-json';
+import semver from 'semver';
+import * as readline from 'readline';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
 function isSelectable(item) {
   return !Separator.isSeparator(item) && !item.disabled;
@@ -1529,9 +58,9 @@ function normalizeChoices(choices) {
 var theme = makeTheme({
   icon: { cursor: "\u276F" },
   style: {
-    disabled: (text) => chalk.dim(`- ${text}`),
-    searchTerm: (text) => chalk.cyan(text),
-    keysHelpTip: (keys) => keys.map(([key, action]) => `${chalk.bold(key)} ${chalk.dim(action)}`).join(chalk.dim(" \u2022 "))
+    disabled: (text) => chalk8.dim(`- ${text}`),
+    searchTerm: (text) => chalk8.cyan(text),
+    keysHelpTip: (keys) => keys.map(([key, action]) => `${chalk8.bold(key)} ${chalk8.dim(action)}`).join(chalk8.dim(" \u2022 "))
   }
 });
 var searchSelect = createPrompt(
@@ -1669,7 +198,7 @@ async function promptText({
   ]);
   return value;
 }
-var display = (c) => c.hint ? `${c.label} ${chalk.dim(`(${c.hint})`)}` : c.label;
+var display = (c) => c.hint ? `${c.label} ${chalk8.dim(`(${c.hint})`)}` : c.label;
 function buildSelectRows(question, term) {
   const row = (name, action) => ({
     name,
@@ -1683,8 +212,8 @@ function buildSelectRows(question, term) {
     name: display(c),
     value: c.value
   }));
-  const skipRow = offers(question, "skip") ? [row(chalk.dim("Skip (optional)"), "skip")] : [];
-  const customRow = offers(question, "custom") ? [row(chalk.dim("Enter a value manually\u2026"), "custom")] : [];
+  const skipRow = offers(question, "skip") ? [row(chalk8.dim("Skip (optional)"), "skip")] : [];
+  const customRow = offers(question, "custom") ? [row(chalk8.dim("Enter a value manually\u2026"), "custom")] : [];
   const committed = !!t || question.search !== void 0;
   let rows;
   if (!committed) {
@@ -1695,13 +224,13 @@ function buildSelectRows(question, term) {
     rows = [...customRow, ...skipRow];
   }
   if (offers(question, "search"))
-    rows.push(row(chalk.cyan("Search again\u2026"), "search"));
+    rows.push(row(chalk8.cyan("Search again\u2026"), "search"));
   if (offers(question, "next_page"))
-    rows.push(row(chalk.dim("Load more\u2026"), "next_page"));
-  if (offers(question, "retry")) rows.push(row(chalk.yellow("Retry"), "retry"));
-  if (offers(question, "cancel")) rows.push(row(chalk.dim("Cancel"), "cancel"));
+    rows.push(row(chalk8.dim("Load more\u2026"), "next_page"));
+  if (offers(question, "retry")) rows.push(row(chalk8.yellow("Retry"), "retry"));
+  if (offers(question, "cancel")) rows.push(row(chalk8.dim("Cancel"), "cancel"));
   for (const note of question.notes ?? [])
-    rows.push({ name: chalk.dim(note), value: note, disabled: true });
+    rows.push({ name: chalk8.dim(note), value: note, disabled: true });
   return rows;
 }
 function foldPage(acc, question, field) {
@@ -1751,12 +280,12 @@ async function answerSelect(question, field, box, failed = false) {
       })),
       ...offers(question, "next_page") ? [
         {
-          name: chalk.dim("Load more\u2026"),
+          name: chalk8.dim("Load more\u2026"),
           value: { action: "next_page" }
         }
       ] : [],
       ...(question.notes ?? []).map((note) => ({
-        name: chalk.dim(note),
+        name: chalk8.dim(note),
         value: note,
         disabled: true
       }))
@@ -1827,14 +356,14 @@ async function answerSelect(question, field, box, failed = false) {
     case "retry":
       return { type: "retry" };
     case "skip":
-      printAnswered(view.message, chalk.dim("(skipped)"));
+      printAnswered(view.message, chalk8.dim("(skipped)"));
       return { type: "skip" };
     case "cancel":
       return { type: "cancel" };
   }
 }
 function printAnswered(message, label) {
-  console.log(`${chalk.green("\u2714")} ${message} ${chalk.cyan(label)}`);
+  console.log(`${chalk8.green("\u2714")} ${message} ${chalk8.cyan(label)}`);
 }
 async function answerInput(question) {
   const message = question.placeholder ? question.message.replace(/:?\s*$/, ` (${question.placeholder}):`) : question.message;
@@ -1877,7 +406,7 @@ function createCliAnswer() {
   return ({ result }) => {
     if (result.error !== void 0) {
       const message = typeof result.error === "string" ? result.error : result.error.message;
-      console.log(chalk.yellow(`! ${message}`));
+      console.log(chalk8.yellow(`! ${message}`));
     }
     const question = result.question;
     const field = question.path.length ? question.path.join(".") : "value";
@@ -1891,6 +420,49 @@ function createCliAnswer() {
     }
   };
 }
+var ZapierCliError = class extends ZapierError {
+};
+var ZapierCliUserCancellationError = class extends ZapierCliError {
+  constructor(message = "Operation cancelled by user") {
+    super(message);
+    this.name = "ZapierCliUserCancellationError";
+    this.code = "ZAPIER_CLI_USER_CANCELLATION";
+    this.exitCode = 0;
+  }
+};
+var ZapierCliExitError = class extends ZapierCliError {
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.name = "ZapierCliExitError";
+    this.code = "ZAPIER_CLI_EXIT";
+    this.exitCode = exitCode;
+  }
+};
+var ZapierCliValidationError = class _ZapierCliValidationError extends ZapierCliError {
+  constructor(message, options = {}) {
+    super(message);
+    this.exitCode = 1;
+    this.name = options.name ?? "ZapierCliValidationError";
+    this.code = options.code ?? "ZAPIER_CLI_VALIDATION_ERROR";
+  }
+  withMessage(message) {
+    return new _ZapierCliValidationError(message, {
+      name: this.name,
+      code: this.code
+    });
+  }
+};
+var ZapierCliMissingParametersError = class extends ZapierCliError {
+  constructor(params) {
+    super(
+      `Missing required parameters: ${params.map((p) => p.name).join(", ")}`
+    );
+    this.name = "ZapierCliMissingParametersError";
+    this.code = "ZAPIER_CLI_MISSING_PARAMETERS";
+    this.exitCode = 1;
+    this.params = params;
+  }
+};
 
 // src/utils/cli-options.ts
 var RESERVED_CLI_OPTIONS = [
@@ -1922,7 +494,7 @@ var SHARED_COMMAND_CLI_OPTIONS = [
 
 // package.json
 var package_default = {
-  version: "0.66.2"};
+  version: "0.66.3"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {
@@ -2009,7 +581,7 @@ async function formatItemsFromSchema(_functionInfo, items, startingNumber = 0, o
   formatItemsGeneric(items, startingNumber);
 }
 function formatSingleItem(formatted, itemNumber) {
-  let titleLine = `${chalk.gray(`${itemNumber + 1}.`)} ${chalk.cyan(formatted.title)}`;
+  let titleLine = `${chalk8.gray(`${itemNumber + 1}.`)} ${chalk8.cyan(formatted.title)}`;
   const subtitleParts = [];
   if (formatted.hint !== void 0) {
     subtitleParts.push(
@@ -2027,11 +599,11 @@ function formatSingleItem(formatted, itemNumber) {
   }
   const uniqueParts = [...new Set(subtitleParts)];
   if (uniqueParts.length > 0) {
-    titleLine += ` ${chalk.gray(`(${uniqueParts.join(", ")})`)}`;
+    titleLine += ` ${chalk8.gray(`(${uniqueParts.join(", ")})`)}`;
   }
   console.log(titleLine);
   if (formatted.description) {
-    console.log(`   ${chalk.dim(formatted.description)}`);
+    console.log(`   ${chalk8.dim(formatted.description)}`);
   }
   if (formatted.raw !== void 0) {
     formatJsonOutput(formatted.raw);
@@ -2042,7 +614,7 @@ function formatSingleItem(formatted, itemNumber) {
     if (detail.label) {
       const isMultiline = detail.text.includes("\n");
       if (isMultiline) {
-        console.log(`   ${chalk.gray(detail.label + ":")}`);
+        console.log(`   ${chalk8.gray(detail.label + ":")}`);
         const displayText = formatDetailText(
           detail.text,
           DETAIL_INDENT + "   "
@@ -2051,7 +623,7 @@ function formatSingleItem(formatted, itemNumber) {
         console.log(`${DETAIL_INDENT}   ${styledText}`);
       } else {
         const styledValue = applyStyle(detail.text, detail.style);
-        console.log(`   ${chalk.gray(detail.label + ":")} ${styledValue}`);
+        console.log(`   ${chalk8.gray(detail.label + ":")} ${styledValue}`);
       }
     } else {
       const displayText = formatDetailText(detail.text, DETAIL_INDENT);
@@ -2075,16 +647,16 @@ function formatDetailText(text, indent = DETAIL_INDENT) {
 function applyStyle(value, style) {
   switch (style) {
     case "dim":
-      return chalk.dim(value);
+      return chalk8.dim(value);
     case "accent":
-      return chalk.magenta(value);
+      return chalk8.magenta(value);
     case "warning":
-      return chalk.red(value);
+      return chalk8.red(value);
     case "success":
-      return chalk.green(value);
+      return chalk8.green(value);
     case "normal":
     default:
-      return chalk.blue(value);
+      return chalk8.blue(value);
   }
 }
 function convertGenericItemToFormattedItem(item) {
@@ -2112,15 +684,15 @@ function formatMissingParamsError(error) {
   return [
     "Missing required parameters:",
     ...error.params.map(
-      ({ name, isPositional: isPositional3 }) => isPositional3 ? `  \u2022 <${toKebabCase(name)}>` : `  \u2022 --${toKebabCase(name)}`
+      ({ name, isPositional: isPositional2 }) => isPositional2 ? `  \u2022 <${toKebabCase(name)}>` : `  \u2022 --${toKebabCase(name)}`
     )
   ].join("\n");
 }
 function buildJsonErrors(error) {
   if (error instanceof ZapierCliMissingParametersError) {
-    return error.params.map(({ name, isPositional: isPositional3 }) => ({
+    return error.params.map(({ name, isPositional: isPositional2 }) => ({
       code: error.code,
-      message: isPositional3 ? `<${toKebabCase(name)}> is required in non-interactive mode` : `--${toKebabCase(name)} is required in non-interactive mode`
+      message: isPositional2 ? `<${toKebabCase(name)}> is required in non-interactive mode` : `--${toKebabCase(name)} is required in non-interactive mode`
     }));
   }
   const code = error instanceof ZapierError ? error.code : "UNKNOWN_ERROR";
@@ -2228,10 +800,10 @@ function createInteractiveRenderer(context = {}) {
         const obj = item;
         const name = obj?.name || obj?.key || obj?.id || "Item";
         console.log(
-          `${chalk.gray(`${startingNumber + index + 1}.`)} ${chalk.cyan(String(name))}`
+          `${chalk8.gray(`${startingNumber + index + 1}.`)} ${chalk8.cyan(String(name))}`
         );
         if (obj?.description)
-          console.log(`   ${chalk.dim(String(obj.description))}`);
+          console.log(`   ${chalk8.dim(String(obj.description))}`);
         console.log();
       });
     }
@@ -2242,35 +814,35 @@ function createInteractiveRenderer(context = {}) {
       if (!(Symbol.asyncIterator in Object(source))) {
         const items = source?.data;
         if (!Array.isArray(items) || items.length === 0) {
-          console.log(chalk.yellow(`No ${itemName} found.`));
+          console.log(chalk8.yellow(`No ${itemName} found.`));
           return;
         }
         await renderItemsForDisplay(items, functionInfo, 0);
-        console.log(chalk.green(`
+        console.log(chalk8.green(`
 \u2705 Showing ${items.length} ${itemName}`));
         return;
       }
       let totalShown = 0;
       let pageCount = 0;
-      console.log(chalk.blue(`\u{1F4CB} ${getListTitle(functionInfo)}
+      console.log(chalk8.blue(`\u{1F4CB} ${getListTitle(functionInfo)}
 `));
       for await (const page of source) {
         const items = page.data ?? [];
         pageCount++;
         if (items.length === 0 && pageCount === 1) {
-          console.log(chalk.yellow(`No ${itemName} found.`));
+          console.log(chalk8.yellow(`No ${itemName} found.`));
           return;
         }
         if (items.length === 0) break;
         if (pageCount > 1) {
           console.clear();
-          console.log(chalk.blue(`\u{1F4CB} ${getListTitle(functionInfo)}
+          console.log(chalk8.blue(`\u{1F4CB} ${getListTitle(functionInfo)}
 `));
         }
         await renderItemsForDisplay(items, functionInfo, totalShown);
         totalShown += items.length;
         console.log(
-          chalk.green(
+          chalk8.green(
             `
 \u2705 Showing ${totalShown} ${itemName} (page ${pageCount})`
           )
@@ -2289,7 +861,7 @@ function createInteractiveRenderer(context = {}) {
           break;
         }
       }
-      console.log(chalk.gray(`
+      console.log(chalk8.gray(`
 \u{1F4C4} Finished browsing ${itemName}`));
     },
     async renderCollectedList(items, { maxItems, userSpecifiedMaxItems, functionInfo } = {}) {
@@ -2299,30 +871,30 @@ function createInteractiveRenderer(context = {}) {
       }
       const itemName = getItemName(functionInfo);
       if (items.length === 0) {
-        console.log(chalk.yellow(`No ${itemName} found.`));
+        console.log(chalk8.yellow(`No ${itemName} found.`));
         return;
       }
-      console.log(chalk.green(`
+      console.log(chalk8.green(`
 \u2705 Found ${items.length} ${itemName}:
 `));
       await renderItemsForDisplay(items, functionInfo);
       if (userSpecifiedMaxItems && maxItems) {
         console.log(
-          chalk.gray(
+          chalk8.gray(
             `
 \u{1F4C4} Showing up to ${maxItems} ${itemName} (--max-items ${maxItems})`
           )
         );
       } else {
-        console.log(chalk.gray(`
+        console.log(chalk8.gray(`
 \u{1F4C4} All available ${itemName} shown`));
       }
     },
     renderItem(value, options) {
       if (options?.outputFile) {
         const label = options.commandName ? `\u2705 ${options.commandName} completed successfully!` : "\u2705 Done!";
-        console.log(chalk.green(label));
-        console.log(chalk.gray(`Output written to: ${options.outputFile}`));
+        console.log(chalk8.green(label));
+        console.log(chalk8.gray(`Output written to: ${options.outputFile}`));
       } else {
         formatJsonOutput(value);
       }
@@ -2332,17 +904,17 @@ function createInteractiveRenderer(context = {}) {
     },
     renderError(error) {
       if (error instanceof ZapierCliMissingParametersError) {
-        console.error(chalk.red("\u274C " + formatMissingParamsError(error)));
-        console.error("\n" + chalk.dim("Use --help to see available options"));
+        console.error(chalk8.red("\u274C " + formatMissingParamsError(error)));
+        console.error("\n" + chalk8.dim("Use --help to see available options"));
         throw new ZapierCliExitError(error.message, 1);
       }
       if (error instanceof ZapierError) {
         const formattedMessage = formatErrorMessage(error);
-        console.error(chalk.red("\u274C Error:"), formattedMessage);
+        console.error(chalk8.red("\u274C Error:"), formattedMessage);
         throw new ZapierCliExitError(formattedMessage, 1);
       }
       const msg = error instanceof Error ? error.message : "Unknown error";
-      console.error(chalk.red("\u274C Error:"), msg);
+      console.error(chalk8.red("\u274C Error:"), msg);
       throw new ZapierCliExitError(msg, 1);
     }
   };
@@ -2458,7 +1030,7 @@ async function promptConfirm(confirmType, itemType) {
   }
   const configOrFn = CONFIRM_MESSAGES[confirmType];
   const { messageBefore, messageAfter } = typeof configOrFn === "function" ? configOrFn(itemType) : configOrFn;
-  console.log(chalk.yellow(`
+  console.log(chalk8.yellow(`
 ${messageBefore}
 `));
   const { confirmed } = await inquirer.prompt([
@@ -2482,12 +1054,12 @@ function emitParamDeprecationWarnings({
     if (Array.isArray(value) && value.length === 0) continue;
     console.warn();
     console.warn(
-      chalk.yellow.bold("\u26A0\uFE0F  DEPRECATION WARNING") + chalk.yellow(
+      chalk8.yellow.bold("\u26A0\uFE0F  DEPRECATION WARNING") + chalk8.yellow(
         ` - \`${toKebabCase(param.name)}\` is deprecated and may be removed in a future release.`
       )
     );
     if (param.deprecationMessage) {
-      console.warn(chalk.yellow(`   ${param.deprecationMessage}`));
+      console.warn(chalk8.yellow(`   ${param.deprecationMessage}`));
     }
     console.warn();
   }
@@ -2526,20 +1098,16 @@ function getAuthFlowIsHeadless({
   if (isCallbackResume && !isHeadless) return null;
   return isHeadless;
 }
-function analyzeZodSchema(schema, functionInfo) {
+function analyzeZodSchema(schema) {
   const parameters = [];
   const schemaDef = schema._zod?.def;
   if (schemaDef?.type === "effect" && schemaDef.innerType) {
-    return analyzeZodSchema(schemaDef.innerType, functionInfo);
+    return analyzeZodSchema(schemaDef.innerType);
   }
   if (schema instanceof z.ZodObject) {
     const shape = schema.shape;
     for (const [key, fieldSchema] of Object.entries(shape)) {
-      const param = analyzeZodField(
-        key,
-        fieldSchema,
-        functionInfo
-      );
+      const param = analyzeZodField(key, fieldSchema);
       if (param) {
         parameters.push(param);
       }
@@ -2547,7 +1115,7 @@ function analyzeZodSchema(schema, functionInfo) {
   }
   return parameters;
 }
-function analyzeZodField(name, schema, functionInfo) {
+function analyzeZodField(name, schema) {
   let baseSchema = schema;
   let required = true;
   let defaultValue = void 0;
@@ -2607,10 +1175,6 @@ function analyzeZodField(name, schema, functionInfo) {
   } else if (baseSchema instanceof z.ZodObject || baseSchema instanceof z.ZodRecord) {
     paramType = "object";
   }
-  let paramHasResolver = false;
-  if (functionInfo?.resolvers?.[name] || functionInfo?.boundResolvers?.[name]) {
-    paramHasResolver = true;
-  }
   return {
     name,
     type: paramType,
@@ -2618,16 +1182,21 @@ function analyzeZodField(name, schema, functionInfo) {
     description: schema.description,
     default: defaultValue,
     choices,
-    hasResolver: paramHasResolver,
     isPositional: isPositional(schema),
     elementType,
     deprecationMessage,
     isDeprecated
   };
 }
-function analyzeInputParameters(inputParameters, functionInfo) {
+function positionalProjection(schema, positional) {
+  if (!positional?.length || !schema) return [];
+  const shape = schema.shape;
+  if (!shape) return [];
+  return positional.filter((name) => name in shape).map((name) => ({ name, schema: shape[name] }));
+}
+function analyzePositionalProjection(projection) {
   const cliParams = [];
-  for (const param of inputParameters) {
+  for (const param of projection) {
     let schema = param.schema;
     let isOptional = false;
     if (schema instanceof z.ZodOptional) {
@@ -2637,11 +1206,7 @@ function analyzeInputParameters(inputParameters, functionInfo) {
     if (schema instanceof z.ZodObject) {
       const shape = schema.shape;
       for (const [key, fieldSchema] of Object.entries(shape)) {
-        const analyzed = analyzeZodField(
-          key,
-          fieldSchema,
-          functionInfo
-        );
+        const analyzed = analyzeZodField(key, fieldSchema);
         if (analyzed) {
           if (isOptional) {
             analyzed.required = false;
@@ -2650,7 +1215,7 @@ function analyzeInputParameters(inputParameters, functionInfo) {
         }
       }
     } else {
-      const analyzed = analyzeZodField(param.name, param.schema, functionInfo);
+      const analyzed = analyzeZodField(param.name, param.schema);
       if (analyzed) {
         analyzed.required = !isOptional;
         analyzed.isPositional = true;
@@ -2660,29 +1225,25 @@ function analyzeInputParameters(inputParameters, functionInfo) {
   }
   return cliParams;
 }
-function reconstructPositionalArgs(inputParameters, flatParams) {
-  const args = [];
-  for (const param of inputParameters) {
-    let schema = param.schema;
-    if (schema instanceof z.ZodOptional) {
-      schema = schema._zod.def.innerType;
-    }
-    if (schema instanceof z.ZodObject) {
-      const shape = schema.shape;
+function nestPositionalParams(projection, flatParams) {
+  const out2 = {};
+  for (const { name, schema } of projection) {
+    const inner = schema instanceof z.ZodOptional ? schema._zod.def.innerType : schema;
+    if (inner instanceof z.ZodObject) {
       const obj = {};
       let hasValues = false;
-      for (const key of Object.keys(shape)) {
+      for (const key of Object.keys(inner.shape)) {
         if (key in flatParams && flatParams[key] !== void 0) {
           obj[key] = flatParams[key];
           hasValues = true;
         }
       }
-      args.push(hasValues ? obj : void 0);
-    } else {
-      args.push(flatParams[param.name]);
+      if (hasValues) out2[name] = obj;
+    } else if (flatParams[name] !== void 0) {
+      out2[name] = flatParams[name];
     }
   }
-  return args;
+  return out2;
 }
 function methodNameToCliCommand(methodName) {
   return toKebabCase(methodName);
@@ -2694,7 +1255,7 @@ function generateCliCommands(program2, sdk) {
   }
   const registry = sdk.getRegistry({ package: "cli" });
   registry.functions.forEach((fnInfo) => {
-    if (!fnInfo.inputSchema && !fnInfo.inputParameters) {
+    if (!fnInfo.inputSchema) {
       console.warn(`Schema not found for ${fnInfo.name}`);
       return;
     }
@@ -2764,12 +1325,11 @@ function generateCliCommands(program2, sdk) {
   });
 }
 function createCommandConfig(cliCommandName, functionInfo, sdk) {
-  const usesInputParameters = !!functionInfo.inputParameters;
   const schema = functionInfo.inputSchema;
-  const parameters = usesInputParameters ? analyzeInputParameters(functionInfo.inputParameters, functionInfo) : analyzeZodSchema(schema, functionInfo);
-  if (functionInfo.boundResolvers && Object.keys(functionInfo.boundResolvers).length > 0) {
-    for (const param of parameters) param.hasResolver = true;
-  }
+  const projection = positionalProjection(schema, functionInfo.positional);
+  const usesPositionalProjection = projection.length > 0;
+  const parameters = usesPositionalProjection ? analyzePositionalProjection(projection) : analyzeZodSchema(schema);
+  for (const param of parameters) param.promptable = true;
   const schemaAliases = getSchemaAliases(schema);
   if (schemaAliases) {
     const aliasedNames = new Set(Object.keys(schemaAliases));
@@ -2819,72 +1379,55 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
           }
         }
       }
-      const boundResolvers = functionInfo.boundResolvers;
-      if (boundResolvers && Object.keys(boundResolvers).length > 0) {
-        const seedInput = Object.fromEntries(
-          Object.entries(rawParams).filter(([, v]) => v !== void 0)
-        );
-        const controller = createController(sdk);
-        const spinner = promptingEnabled && !options.debug ? ora({ text: "", spinner: "dots" }) : void 0;
-        let resolved;
-        try {
-          const isRegisteredPositional = (name) => {
-            const p = parameters.find((param) => param.name === name);
-            return !!p && takesPositionalSlot(p);
-          };
-          spinner?.start();
-          resolved = await controller.resolve({
-            method: functionInfo.name,
-            input: seedInput,
-            answer: spinner ? withEngineSpinner(createCliAnswer(), spinner) : promptingEnabled ? createCliAnswer() : ({ state }) => {
-              const missing = /* @__PURE__ */ new Map();
-              missing.set(
-                state.current?.join(".") ?? "value",
-                isRegisteredPositional(String(state.current?.[0] ?? ""))
-              );
-              for (const p of parameters) {
-                if (!p.required || p.isDeprecated || p.isAlias) continue;
-                if (p.name in state.resolved) continue;
-                if (state.settled.includes(p.name)) continue;
-                if (boundResolvers[p.name]?.type === "constant") continue;
-                if (!missing.has(p.name)) {
-                  missing.set(p.name, isRegisteredPositional(p.name));
-                }
+      const resolvers = functionInfo.resolvers;
+      const seedInput = usesPositionalProjection ? nestPositionalParams(projection, rawParams) : Object.fromEntries(
+        Object.entries(rawParams).filter(([, v]) => v !== void 0)
+      );
+      const controller = createController(sdk);
+      const spinner = promptingEnabled && !options.debug ? ora({ text: "", spinner: "dots" }) : void 0;
+      let resolved;
+      try {
+        const isRegisteredPositional = (name) => {
+          const p = parameters.find((param) => param.name === name);
+          return !!p && takesPositionalSlot(p);
+        };
+        spinner?.start();
+        resolved = await controller.resolve({
+          method: functionInfo.name,
+          input: seedInput,
+          answer: spinner ? withEngineSpinner(createCliAnswer(), spinner) : promptingEnabled ? createCliAnswer() : ({ state }) => {
+            const missing = /* @__PURE__ */ new Map();
+            missing.set(
+              state.current?.join(".") ?? "value",
+              isRegisteredPositional(String(state.current?.[0] ?? ""))
+            );
+            for (const p of parameters) {
+              if (!p.required || p.isDeprecated || p.isAlias) continue;
+              if (p.name in state.resolved) continue;
+              if (state.settled.includes(p.name)) continue;
+              if (resolvers?.[p.name]?.type === "constant") continue;
+              if (!missing.has(p.name)) {
+                missing.set(p.name, isRegisteredPositional(p.name));
               }
-              throw new ZapierCliMissingParametersError(
-                [...missing].map(([name, isPositional3]) => ({
-                  name,
-                  isPositional: isPositional3
-                }))
-              );
-            },
-            interactive: promptingEnabled
-          });
-        } catch (err) {
-          if (err instanceof CoreCancelledSignal) {
-            throw new ZapierCliUserCancellationError();
-          }
-          throw err;
-        } finally {
-          spinner?.stop();
+            }
+            throw new ZapierCliMissingParametersError(
+              [...missing].map(([name, isPositional2]) => ({
+                name,
+                isPositional: isPositional2
+              }))
+            );
+          },
+          interactive: promptingEnabled
+        });
+      } catch (err) {
+        if (err instanceof CoreCancelledSignal) {
+          throw new ZapierCliUserCancellationError();
         }
-        Object.assign(resolvedParams, resolved);
-      } else if (schema && !usesInputParameters) {
-        const resolver = new SchemaParameterResolver();
-        const resolved = await resolver.resolveParameters(
-          schema,
-          rawParams,
-          sdk,
-          functionInfo.name,
-          {
-            interactiveMode,
-            debug: !!options.debug || process.env.DEBUG === "true" || process.argv.includes("--debug")
-          }
-        );
-        Object.assign(resolvedParams, resolved);
-      } else {
-        Object.assign(resolvedParams, rawParams);
+        throw err;
+      } finally {
+        spinner?.stop();
       }
+      Object.assign(resolvedParams, resolved);
       const confirm = functionInfo.confirm;
       let confirmMessageAfter;
       if (confirm && interactiveMode) {
@@ -2893,7 +1436,7 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
           functionInfo.itemType
         );
         if (!confirmResult.confirmed) {
-          console.log(chalk.yellow("Operation cancelled."));
+          console.log(chalk8.yellow("Operation cancelled."));
           return;
         }
         confirmMessageAfter = confirmResult.messageAfter;
@@ -2921,10 +1464,9 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
         }
         case "single": {
           const callSdkMethod = () => {
-            if (usesInputParameters) {
-              const positionalArgs = reconstructPositionalArgs(
-                functionInfo.inputParameters,
-                resolvedParams
+            if (usesPositionalProjection) {
+              const positionalArgs = (functionInfo.positional ?? []).map(
+                (name) => resolvedParams[name]
               );
               return sdkMethod(...positionalArgs);
             }
@@ -2955,7 +1497,7 @@ function createCommandConfig(cliCommandName, functionInfo, sdk) {
             renderer.renderItem(normalizedResult.value);
           }
           if (confirmMessageAfter) {
-            console.log(chalk.yellow(`
+            console.log(chalk8.yellow(`
 ${confirmMessageAfter}`));
           }
           break;
@@ -3032,7 +1574,7 @@ function addCommand(program2, commandName, config2) {
   let hasPositionalArray = false;
   config2.parameters.forEach((param) => {
     const kebabName = toKebabCase(param.name);
-    if (param.hasResolver && param.required) {
+    if (param.promptable && param.required) {
       command.argument(
         `[${kebabName}]`,
         param.description || `${kebabName} parameter`
@@ -4151,20 +2693,20 @@ var getCallablePromise = () => {
 var getCallablePromise_default = getCallablePromise;
 var log = {
   info: (message, ...args) => {
-    console.error(chalk.blue("\u2139"), message, ...args);
+    console.error(chalk8.blue("\u2139"), message, ...args);
   },
   error: (message, ...args) => {
-    console.error(chalk.red("\u2716"), message, ...args);
+    console.error(chalk8.red("\u2716"), message, ...args);
   },
   success: (message, ...args) => {
-    console.error(chalk.green("\u2713"), message, ...args);
+    console.error(chalk8.green("\u2713"), message, ...args);
   },
   warn: (message, ...args) => {
-    console.error(chalk.yellow("\u26A0"), message, ...args);
+    console.error(chalk8.yellow("\u26A0"), message, ...args);
   },
   debug: (message, ...args) => {
     if (process.env.DEBUG === "true" || process.argv.includes("--debug")) {
-      console.error(chalk.gray("\u{1F41B}"), message, ...args);
+      console.error(chalk8.gray("\u{1F41B}"), message, ...args);
     }
   }
 };
@@ -7321,7 +5863,7 @@ function buildTemplateVariables({
   };
 }
 function cleanupProject({ projectDir }) {
-  console.log("\n" + chalk.yellow("!") + "  Cleaning up...");
+  console.log("\n" + chalk8.yellow("!") + "  Cleaning up...");
   rmSync(projectDir, { recursive: true, force: true });
 }
 async function withInterruptCleanup(cleanup, fn) {
@@ -7531,8 +6073,8 @@ function buildNextSteps({
 }
 function createConsoleDisplayHooks() {
   return {
-    onItemComplete: (message) => console.log("   " + chalk.green("\u2713") + "  " + chalk.dim(message)),
-    onWarn: (message) => console.warn(chalk.yellow("!") + "  " + message),
+    onItemComplete: (message) => console.log("   " + chalk8.green("\u2713") + "  " + chalk8.dim(message)),
+    onWarn: (message) => console.warn(chalk8.yellow("!") + "  " + message),
     onStepStart: ({
       description,
       stepNumber,
@@ -7541,31 +6083,31 @@ function createConsoleDisplayHooks() {
       nonInteractive
     }) => {
       const progressMessage = `${description}...`;
-      const stepCounter = chalk.dim(`${stepNumber}/${totalSteps}`);
+      const stepCounter = chalk8.dim(`${stepNumber}/${totalSteps}`);
       if (nonInteractive) {
         console.log(
-          "\n" + chalk.bold(`\u276F  ${progressMessage}`) + "  " + stepCounter + "\n"
+          "\n" + chalk8.bold(`\u276F  ${progressMessage}`) + "  " + stepCounter + "\n"
         );
       } else {
         console.log(
-          chalk.dim("\u2192") + "  " + progressMessage + "  " + stepCounter
+          chalk8.dim("\u2192") + "  " + progressMessage + "  " + stepCounter
         );
       }
       if (command) {
-        console.log("   " + chalk.cyan(`$ ${command}`));
+        console.log("   " + chalk8.cyan(`$ ${command}`));
       }
     },
     onStepSuccess: ({ stepNumber, totalSteps }) => console.log(
-      "\n" + chalk.green("\u2713") + "  " + chalk.dim(`Step ${stepNumber}/${totalSteps} complete`) + "\n"
+      "\n" + chalk8.green("\u2713") + "  " + chalk8.dim(`Step ${stepNumber}/${totalSteps} complete`) + "\n"
     ),
     onStepError: ({ description, command, err }) => {
       const detail = err instanceof Error && err.message ? `
-   ${chalk.dim(err.message)}` : "";
+   ${chalk8.dim(err.message)}` : "";
       const hint = command ? `
-   ${chalk.dim("run manually:")} ${chalk.cyan(`$ ${command}`)}` : "";
+   ${chalk8.dim("run manually:")} ${chalk8.cyan(`$ ${command}`)}` : "";
       console.error(
         `
-${chalk.red("\u2716")}  ${chalk.bold(description)}${chalk.dim(" failed")}${detail}${hint}`
+${chalk8.red("\u2716")}  ${chalk8.bold(description)}${chalk8.dim(" failed")}${detail}${hint}`
       );
     }
   };
@@ -7577,22 +6119,22 @@ function displaySummaryAndNextSteps({
   packageManager
 }) {
   const formatStatus = (complete) => ({
-    icon: complete ? chalk.green("\u2713") : chalk.yellow("!"),
-    text: complete ? chalk.green("Setup complete") : chalk.yellow("Setup interrupted")
+    icon: complete ? chalk8.green("\u2713") : chalk8.yellow("!"),
+    text: complete ? chalk8.green("Setup complete") : chalk8.yellow("Setup interrupted")
   });
-  const formatNextStep = (step, i) => "   " + chalk.dim(`${i + 1}.`) + "  " + chalk.bold(step.description);
-  const formatCommand = (cmd) => "       " + chalk.cyan(`$ ${cmd}`);
-  const formatCompletedStep = (step) => "   " + chalk.green("\u2713") + "  " + step.description;
+  const formatNextStep = (step, i) => "   " + chalk8.dim(`${i + 1}.`) + "  " + chalk8.bold(step.description);
+  const formatCommand = (cmd) => "       " + chalk8.cyan(`$ ${cmd}`);
+  const formatCompletedStep = (step) => "   " + chalk8.green("\u2713") + "  " + step.description;
   const { execCmd } = getPackageManagerCommands({ packageManager });
   const leftoverSteps = steps.filter(
     (s) => !completedSetupStepIds.includes(s.id)
   );
   const isComplete = leftoverSteps.length === 0;
   const status = formatStatus(isComplete);
-  console.log("\n" + chalk.bold("\u276F  Summary") + "\n");
-  console.log("   " + chalk.dim("Project") + "   " + chalk.bold(projectName));
+  console.log("\n" + chalk8.bold("\u276F  Summary") + "\n");
+  console.log("   " + chalk8.dim("Project") + "   " + chalk8.bold(projectName));
   console.log(
-    "   " + chalk.dim("Status") + "    " + status.icon + "  " + status.text
+    "   " + chalk8.dim("Status") + "    " + status.icon + "  " + status.text
   );
   const completedSteps = steps.filter(
     (s) => completedSetupStepIds.includes(s.id)
@@ -7602,7 +6144,7 @@ function displaySummaryAndNextSteps({
     for (const step of completedSteps) console.log(formatCompletedStep(step));
   }
   const nextSteps = buildNextSteps({ projectName, leftoverSteps, execCmd });
-  console.log("\n" + chalk.bold("\u276F  Next Steps") + "\n");
+  console.log("\n" + chalk8.bold("\u276F  Next Steps") + "\n");
   nextSteps.forEach((step, i) => {
     console.log(formatNextStep(step, i));
     if (step.command) console.log(formatCommand(step.command));
@@ -7679,13 +6221,13 @@ function createInteractiveCallback() {
     const attrs = message.message_attributes;
     console.log(
       `
-${chalk.bold(`Message #${messageNumber}`)} ${chalk.dim(message.id)} ${chalk.dim(`(lease #${attrs.lease_count})`)}`
+${chalk8.bold(`Message #${messageNumber}`)} ${chalk8.dim(message.id)} ${chalk8.dim(`(lease #${attrs.lease_count})`)}`
     );
     if (attrs.error_message) {
-      console.log(chalk.yellow(`  upstream error: ${attrs.error_message}`));
+      console.log(chalk8.yellow(`  upstream error: ${attrs.error_message}`));
     }
     if (attrs.possible_duplicate_data) {
-      console.log(chalk.yellow("  possible duplicate data"));
+      console.log(chalk8.yellow("  possible duplicate data"));
     }
     while (true) {
       let action;
@@ -7715,7 +6257,7 @@ ${chalk.bold(`Message #${messageNumber}`)} ${chalk.dim(message.id)} ${chalk.dim(
         throw error;
       }
       if (action === "view") {
-        console.log(chalk.dim(JSON.stringify(message.payload, null, 2)));
+        console.log(chalk8.dim(JSON.stringify(message.payload, null, 2)));
         continue;
       }
       if (action === "ack") {
@@ -7818,7 +6360,7 @@ function describeReason(reason) {
 }
 function printDrainError(reason, message) {
   console.error(
-    chalk.red(`Error processing ${message.id}: ${describeReason(reason)}`)
+    chalk8.red(`Error processing ${message.id}: ${describeReason(reason)}`)
   );
 }
 function printDrainSummary(counts) {
@@ -7828,7 +6370,7 @@ function printDrainSummary(counts) {
   if (skipped > 0) parts.push(`${skipped} skipped`);
   parts.push(`${counts.rejected} rejected`);
   console.log(
-    chalk.dim(
+    chalk8.dim(
       `
 Processed ${total} message${total === 1 ? "" : "s"} (${parts.join(", ")}).`
     )
@@ -7836,7 +6378,7 @@ Processed ${total} message${total === 1 ? "" : "s"} (${parts.join(", ")}).`
 }
 function warnInteractiveContinueOnErrorOverride() {
   console.warn(
-    chalk.yellow(
+    chalk8.yellow(
       'Note: continueOnError=false is overridden to true in interactive mode (the "Skip (let lease expire)" choice would otherwise terminate the drain).'
     )
   );
@@ -8162,7 +6704,7 @@ function renderDeprecationNotices() {
   console.error();
   for (const message of messages) {
     for (const line of buildBoxLines(message)) {
-      console.error(chalk.red.bold(line));
+      console.error(chalk8.red.bold(line));
     }
     console.error();
   }
@@ -8183,7 +6725,7 @@ function buildBoxLines(message) {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@zapier/zapier-sdk-cli",
-  version: "0.66.2"};
+  version: "0.66.3"};
 
 // src/sdk.ts
 var warnedDeprecatedMethods = /* @__PURE__ */ new Set();
@@ -8194,9 +6736,9 @@ var cliCoreOptions = {
     warnedDeprecatedMethods.add(methodName);
     console.warn();
     console.warn(
-      chalk.yellow.bold("\u26A0\uFE0F  DEPRECATION WARNING") + chalk.yellow(` - \`${toKebabCase(methodName)}\` is deprecated.`)
+      chalk8.yellow.bold("\u26A0\uFE0F  DEPRECATION WARNING") + chalk8.yellow(` - \`${toKebabCase(methodName)}\` is deprecated.`)
     );
-    console.warn(chalk.yellow(`   ${deprecation.message}`));
+    console.warn(chalk8.yellow(`   ${deprecation.message}`));
     console.warn();
   }
 };
@@ -8486,26 +7028,26 @@ function displayUpdateNotification(versionInfo, packageName) {
   if (versionInfo.isDeprecated) {
     console.error();
     console.error(
-      chalk.red.bold("\u26A0\uFE0F  DEPRECATION WARNING") + chalk.red(
+      chalk8.red.bold("\u26A0\uFE0F  DEPRECATION WARNING") + chalk8.red(
         ` - ${packageName} v${versionInfo.currentVersion} is deprecated.`
       )
     );
     if (versionInfo.deprecationMessage) {
-      console.error(chalk.red(`   ${versionInfo.deprecationMessage}`));
+      console.error(chalk8.red(`   ${versionInfo.deprecationMessage}`));
     }
-    console.error(chalk.red(`   Please update to the latest version.`));
+    console.error(chalk8.red(`   Please update to the latest version.`));
     console.error();
   }
   if (versionInfo.hasUpdate) {
     console.error();
     console.error(
-      chalk.yellow.bold("\u{1F4E6} Update available!") + chalk.yellow(
+      chalk8.yellow.bold("\u{1F4E6} Update available!") + chalk8.yellow(
         ` ${packageName} v${versionInfo.currentVersion} \u2192 v${versionInfo.latestVersion}`
       )
     );
     console.error(
-      chalk.yellow(
-        `   Run ${chalk.bold(getUpdateCommand(packageName))} to update.`
+      chalk8.yellow(
+        `   Run ${chalk8.bold(getUpdateCommand(packageName))} to update.`
       )
     );
     console.error();
@@ -8613,11 +7155,11 @@ function buildFrameLines(state, frameIndex) {
   const bodyWidth = width - 2;
   const bodyTextWidth = innerWidth - 2;
   const content = [];
-  content.push(chalk.bold.cyan("Approval review"));
+  content.push(chalk8.bold.cyan("Approval review"));
   content.push("");
   if (!state.verdict) {
     content.push(
-      chalk.yellow(`${SPINNER_FRAMES[frameIndex]} Checking approval...`)
+      chalk8.yellow(`${SPINNER_FRAMES[frameIndex]} Checking approval...`)
     );
   }
   const recentMessages = state.messages.slice(-5);
@@ -8628,13 +7170,13 @@ function buildFrameLines(state, frameIndex) {
       "\n"
     );
     segments.forEach((segment, segmentIndex) => {
-      const prefix = segmentIndex === 0 ? chalk.cyan("> ") : "  ";
-      content.push(`${prefix}${dimmed ? chalk.dim(segment) : segment}`);
+      const prefix = segmentIndex === 0 ? chalk8.cyan("> ") : "  ";
+      content.push(`${prefix}${dimmed ? chalk8.dim(segment) : segment}`);
     });
   });
   if (state.streamError) {
     if (hasMessages || !state.verdict) content.push("");
-    content.push(chalk.bold.red("Approval stream error"));
+    content.push(chalk8.bold.red("Approval stream error"));
     for (const segment of wrapAnsi3(state.streamError, bodyTextWidth, {
       hard: true
     }).split("\n")) {
@@ -8644,7 +7186,7 @@ function buildFrameLines(state, frameIndex) {
   if (state.verdict) {
     if (hasMessages || state.streamError) content.push("");
     content.push(
-      chalk.bold.green(`${state.verdict.icon} ${state.verdict.label}`)
+      chalk8.bold.green(`${state.verdict.icon} ${state.verdict.label}`)
     );
     if (state.verdict.reason) {
       for (const segment of wrapAnsi3(state.verdict.reason, bodyTextWidth, {
@@ -8656,12 +7198,12 @@ function buildFrameLines(state, frameIndex) {
   }
   const pad = (line) => {
     const padding = " ".repeat(Math.max(0, innerWidth - displayWidth(line)));
-    return `${chalk.cyan("\u2502")} ${line}${padding} ${chalk.cyan("\u2502")}`;
+    return `${chalk8.cyan("\u2502")} ${line}${padding} ${chalk8.cyan("\u2502")}`;
   };
   return [
-    chalk.cyan(`\u256D${"\u2500".repeat(bodyWidth)}\u256E`),
+    chalk8.cyan(`\u256D${"\u2500".repeat(bodyWidth)}\u256E`),
     ...content.map(pad),
-    chalk.cyan(`\u2570${"\u2500".repeat(bodyWidth)}\u256F`)
+    chalk8.cyan(`\u2570${"\u2500".repeat(bodyWidth)}\u256F`)
   ];
 }
 function createApprovalProgressRenderer({