@zapier/zapier-sdk-cli 0.35.1 → 0.36.1

package/dist/cli.cjs

@@ -6,13 +6,14 @@ var zod = require('zod');
 var zapierSdk = require('@zapier/zapier-sdk');
 var inquirer = require('inquirer');
 var chalk7 = require('chalk');
+var ora = require('ora');
 var util = require('util');
+var wrapAnsi = require('wrap-ansi');
 var cliLogin = require('@zapier/zapier-sdk-cli-login');
 var open = require('open');
 var crypto = require('crypto');
 var express = require('express');
 var pkceChallenge = require('pkce-challenge');
-var ora = require('ora');
 var zapierSdkMcp = require('@zapier/zapier-sdk-mcp');
 var esbuild = require('esbuild');
 var fs = require('fs');
@@ -49,13 +50,14 @@ function _interopNamespace(e) {
 
 var inquirer__default = /*#__PURE__*/_interopDefault(inquirer);
 var chalk7__default = /*#__PURE__*/_interopDefault(chalk7);
+var ora__default = /*#__PURE__*/_interopDefault(ora);
 var util__default = /*#__PURE__*/_interopDefault(util);
+var wrapAnsi__default = /*#__PURE__*/_interopDefault(wrapAnsi);
 var cliLogin__namespace = /*#__PURE__*/_interopNamespace(cliLogin);
 var open__default = /*#__PURE__*/_interopDefault(open);
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var express__default = /*#__PURE__*/_interopDefault(express);
 var pkceChallenge__default = /*#__PURE__*/_interopDefault(pkceChallenge);
-var ora__default = /*#__PURE__*/_interopDefault(ora);
 var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var ts__namespace = /*#__PURE__*/_interopNamespace(ts);
@@ -143,9 +145,31 @@ function getLocalResolutionOrderForParams(paramNames, resolvers) {
   return order;
 }
 var SchemaParameterResolver = class {
+  constructor() {
+    this.debug = false;
+    this.spinner = null;
+  }
+  debugLog(message) {
+    if (this.debug) {
+      this.stopSpinner();
+      console.log(chalk7__default.default.gray(`[Zapier CLI] ${message}`));
+    }
+  }
+  startSpinner() {
+    if (!this.debug && !this.spinner) {
+      this.spinner = ora__default.default({ text: "", spinner: "dots" }).start();
+    }
+  }
+  stopSpinner() {
+    if (this.spinner) {
+      this.spinner.stop();
+      this.spinner = null;
+    }
+  }
   async resolveParameters(schema, providedParams, sdk2, functionName, options) {
     return zapierSdk.runWithTelemetryContext(async () => {
-      const interactiveMode = options?.interactiveMode ?? true;
+      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(
@@ -155,27 +179,18 @@ var SchemaParameterResolver = class {
         const hasValue = this.getNestedValue(providedParams, param.path) !== void 0;
         return !hasValue;
       });
-      const functionallyRequired = missingResolvable.filter((param) => {
+      const required = missingResolvable.filter((param) => {
         if (param.isRequired) return true;
-        if (param.name === "inputs") {
-          return interactiveMode;
-        }
+        if (param.name === "inputs") return interactiveMode;
         return false;
       });
-      const alwaysPrompt = missingResolvable.filter((param) => {
-        if (functionallyRequired.includes(param)) return false;
-        if (param.name === "connectionId") {
-          return true;
-        }
-        return false;
-      });
-      const trulyOptional = missingResolvable.filter(
-        (param) => !functionallyRequired.includes(param) && !alwaysPrompt.includes(param)
+      const optional = missingResolvable.filter(
+        (param) => !required.includes(param)
       );
-      if (parseResult.success && functionallyRequired.length === 0 && alwaysPrompt.length === 0) {
+      if (parseResult.success && required.length === 0 && optional.length === 0) {
         return parseResult.data;
       }
-      if (functionallyRequired.length === 0 && alwaysPrompt.length === 0) {
+      if (required.length === 0 && optional.length === 0) {
         if (!parseResult.success) {
           throw new ZapierCliValidationError(formatZodError(parseResult.error));
         }
@@ -189,19 +204,16 @@ var SchemaParameterResolver = class {
         functionName
       };
       const localResolvers = this.getLocalResolvers(sdk2, functionName);
-      if (functionallyRequired.length > 0) {
-        const requiredParamNames = functionallyRequired.map((p) => p.name);
+      if (required.length > 0) {
+        const requiredParamNames = required.map((p) => p.name);
         const requiredResolutionOrder = getLocalResolutionOrderForParams(
           requiredParamNames,
           localResolvers
         );
         const orderedRequiredParams = requiredResolutionOrder.map((paramName) => {
-          let param = functionallyRequired.find((p) => p.name === paramName);
-          if (!param) {
-            param = alwaysPrompt.find((p) => p.name === paramName);
-          }
+          let param = required.find((p) => p.name === paramName);
           if (!param) {
-            param = trulyOptional.find((p) => p.name === paramName);
+            param = optional.find((p) => p.name === paramName);
           }
           return param;
         }).filter((param) => param !== void 0);
@@ -234,33 +246,31 @@ var SchemaParameterResolver = class {
         const resolvedParamNames = new Set(
           orderedRequiredParams.map((p) => p.name)
         );
-        alwaysPrompt.splice(
-          0,
-          alwaysPrompt.length,
-          ...alwaysPrompt.filter((p) => !resolvedParamNames.has(p.name))
-        );
-        trulyOptional.splice(
+        optional.splice(
           0,
-          trulyOptional.length,
-          ...trulyOptional.filter((p) => !resolvedParamNames.has(p.name))
+          optional.length,
+          ...optional.filter((p) => !resolvedParamNames.has(p.name))
         );
       }
-      if (interactiveMode && alwaysPrompt.length > 0) {
-        const alwaysPromptNames = alwaysPrompt.map((p) => p.name);
-        const alwaysPromptResolutionOrder = getLocalResolutionOrderForParams(
-          alwaysPromptNames,
+      if (interactiveMode && optional.length > 0) {
+        const optionalParamNames = optional.map((p) => p.name);
+        const optionalResolutionOrder = getLocalResolutionOrderForParams(
+          optionalParamNames,
           localResolvers
         );
-        const orderedAlwaysPromptParams = alwaysPromptResolutionOrder.map((paramName) => alwaysPrompt.find((p) => p.name === paramName)).filter((param) => param !== void 0);
-        for (const param of orderedAlwaysPromptParams) {
+        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
+              functionName,
+              { isOptional: true }
             );
-            this.setNestedValue(resolvedParams, param.path, value);
-            context.resolvedParams = resolvedParams;
+            if (value !== void 0) {
+              this.setNestedValue(resolvedParams, param.path, value);
+              context.resolvedParams = resolvedParams;
+            }
           } catch (error) {
             if (this.isUserCancellation(error)) {
               console.log(chalk7__default.default.yellow("\n\nOperation cancelled by user"));
@@ -270,44 +280,6 @@ var SchemaParameterResolver = class {
           }
         }
       }
-      if (interactiveMode && trulyOptional.length > 0) {
-        const optionalNames = trulyOptional.map((p) => p.name).join(", ");
-        const shouldResolveOptional = await inquirer__default.default.prompt([
-          {
-            type: "confirm",
-            name: "resolveOptional",
-            message: `Would you like to be prompted for optional parameters (${optionalNames})?`,
-            default: false
-          }
-        ]);
-        if (shouldResolveOptional.resolveOptional) {
-          const optionalParamNames = trulyOptional.map((p) => p.name);
-          const optionalResolutionOrder = getLocalResolutionOrderForParams(
-            optionalParamNames,
-            localResolvers
-          );
-          const orderedOptionalParams = optionalResolutionOrder.map((paramName) => trulyOptional.find((p) => p.name === paramName)).filter(
-            (param) => param !== void 0
-          );
-          for (const param of orderedOptionalParams) {
-            try {
-              const value = await this.resolveParameter(
-                param,
-                context,
-                functionName
-              );
-              this.setNestedValue(resolvedParams, param.path, value);
-              context.resolvedParams = resolvedParams;
-            } catch (error) {
-              if (this.isUserCancellation(error)) {
-                console.log(chalk7__default.default.yellow("\n\nOperation cancelled by user"));
-                throw new ZapierCliUserCancellationError();
-              }
-              throw error;
-            }
-          }
-        }
-      }
       const finalResult = schema.safeParse(resolvedParams);
       if (!finalResult.success) {
         throw new ZapierCliValidationError(
@@ -402,7 +374,7 @@ var SchemaParameterResolver = class {
       throw new ZapierCliMissingParametersError(missingParams);
     }
   }
-  async resolveParameter(param, context, functionName) {
+  async resolveParameter(param, context, functionName, options) {
     const resolver = this.getResolver(
       param.name,
       context.sdk,
@@ -411,53 +383,102 @@ var SchemaParameterResolver = class {
     if (!resolver) {
       throw new Error(`No resolver found for parameter: ${param.name}`);
     }
-    console.log(chalk7__default.default.blue(`
-\u{1F50D} Resolving ${param.name}...`));
+    return this.resolveWithResolver(resolver, param, context, {
+      isOptional: options?.isOptional
+    });
+  }
+  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 === "static") {
       const staticResolver = resolver;
       const promptConfig = {
         type: staticResolver.inputType === "password" ? "password" : "input",
-        name: param.name,
-        message: `Enter ${param.name}:`,
+        name: promptName,
+        message: `Enter ${promptLabel}${isOptional ? " (optional)" : ""}:`,
         ...staticResolver.placeholder && {
           default: staticResolver.placeholder
         }
       };
+      this.stopSpinner();
       const answers = await inquirer__default.default.prompt([promptConfig]);
-      return answers[param.name];
+      const value = answers[promptName];
+      if (isOptional && (value === void 0 || value === "")) {
+        return void 0;
+      }
+      return value;
     } 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 (param.isRequired && param.name !== "connectionId") {
-        console.log(chalk7__default.default.gray(`Fetching options for ${param.name}...`));
-      }
-      const items = await dynamicResolver.fetch(
+      this.debugLog(`Fetching options for ${promptLabel}`);
+      const fetchResult = await dynamicResolver.fetch(
         context.sdk,
         context.resolvedParams
       );
-      const safeItems = items || [];
+      const items = Array.isArray(fetchResult) ? fetchResult : fetchResult?.data ?? [];
       const promptConfig = dynamicResolver.prompt(
-        safeItems,
+        items,
         context.resolvedParams
       );
+      promptConfig.name = promptName;
+      this.stopSpinner();
+      if (isOptional && promptConfig.choices) {
+        const SKIP_SENTINEL = Symbol("SKIP");
+        promptConfig.choices = [
+          { name: chalk7__default.default.dim("(Skip)"), value: SKIP_SENTINEL },
+          ...promptConfig.choices
+        ];
+        const answers2 = await inquirer__default.default.prompt([promptConfig]);
+        const value = answers2[promptName];
+        if (value === SKIP_SENTINEL) {
+          return void 0;
+        }
+        return value;
+      }
       const answers = await inquirer__default.default.prompt([promptConfig]);
-      return answers[param.name];
+      return answers[promptName];
     } else if (resolver.type === "fields") {
+      if (isOptional && !inArrayContext) {
+        this.stopSpinner();
+        const { confirm } = await inquirer__default.default.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 ${param.name}`);
+    throw new Error(`Unknown resolver type for ${promptLabel}`);
   }
-  async resolveFieldsRecursively(resolver, context, param) {
+  async resolveFieldsRecursively(resolver, context, param, options = {}) {
     const inputs = {};
     let processedFieldKeys = /* @__PURE__ */ new Set();
     let iteration = 0;
@@ -471,15 +492,15 @@ var SchemaParameterResolver = class {
           inputs
         }
       };
-      console.log(
-        chalk7__default.default.gray(
-          `Fetching input fields for ${param.name}${iteration > 1 ? ` (iteration ${iteration})` : ""}...`
-        )
+      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(
@@ -494,7 +515,8 @@ var SchemaParameterResolver = class {
         processedFieldKeys,
         [],
         iteration,
-        updatedContext
+        updatedContext,
+        { inArrayContext: options.inArrayContext }
       );
       if (fieldStats.newRequired === 0 && fieldStats.newOptional === 0) {
         break;
@@ -511,13 +533,60 @@ var SchemaParameterResolver = class {
         )
       );
     }
+    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__default.default.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(chalk7__default.default.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) {
+  async processFieldItems(items, targetInputs, processedFieldKeys, fieldsetPath = [], iteration = 1, context, options = {}) {
     let newRequiredCount = 0;
     let newOptionalCount = 0;
     let optionalSkipped = false;
@@ -543,7 +612,8 @@ var SchemaParameterResolver = class {
           processedFieldKeys,
           nestedPath,
           iteration,
-          context
+          context,
+          options
         );
         newRequiredCount += nestedStats.newRequired;
         newOptionalCount += nestedStats.newOptional;
@@ -557,15 +627,22 @@ var SchemaParameterResolver = class {
         const isRequired = typedItem.is_required || false;
         if (isRequired) {
           newRequiredCount++;
-          if (newRequiredCount === 1 && fieldsetPath.length === 0) {
-            console.log(
-              chalk7__default.default.blue(
-                `
-\u{1F4DD} Please provide values for the following ${iteration === 1 ? "" : "additional "}input fields:`
-              )
+          if (typedItem.resolver && context) {
+            const param = {
+              name: typedItem.key,
+              path: [typedItem.key],
+              schema: zod.z.unknown(),
+              isRequired: true
+            };
+            targetInputs[typedItem.key] = await this.resolveWithResolver(
+              typedItem.resolver,
+              param,
+              context,
+              { isOptional: false }
             );
+          } else {
+            await this.promptForField(typedItem, targetInputs, context);
           }
-          await this.promptForField(typedItem, targetInputs, context);
           processedFieldKeys.add(typedItem.key);
         } else {
           newOptionalCount++;
@@ -579,42 +656,50 @@ var SchemaParameterResolver = class {
       });
       if (optionalFields.length > 0) {
         const pathContext = fieldsetPath.length > 0 ? ` in ${fieldsetPath.join(" > ")}` : "";
-        console.log(
-          chalk7__default.default.gray(
-            `
+        if (options.inArrayContext) {
+          for (const field of optionalFields) {
+            await this.promptForField(field, targetInputs, context);
+            const typedField = field;
+            processedFieldKeys.add(typedField.key);
+          }
+        } else {
+          console.log(
+            chalk7__default.default.gray(
+              `
 There are ${optionalFields.length} ${iteration === 1 ? "" : "additional "}optional field(s) available${pathContext}.`
-          )
-        );
-        try {
-          const shouldConfigureOptional = await inquirer__default.default.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(chalk7__default.default.cyan(`
+            )
+          );
+          try {
+            const shouldConfigureOptional = await inquirer__default.default.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(chalk7__default.default.cyan(`
 Optional fields${pathContext}:`));
-            for (const field of optionalFields) {
-              await this.promptForField(field, targetInputs, context);
-              const typedField = field;
-              processedFieldKeys.add(typedField.key);
+              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);
+              });
             }
-          } else {
-            optionalSkipped = true;
-            optionalFields.forEach((field) => {
-              const typedField = field;
-              processedFieldKeys.add(typedField.key);
-            });
-          }
-        } catch (error) {
-          if (this.isUserCancellation(error)) {
-            console.log(chalk7__default.default.yellow("\n\nOperation cancelled by user"));
-            throw new ZapierCliUserCancellationError();
+          } catch (error) {
+            if (this.isUserCancellation(error)) {
+              console.log(chalk7__default.default.yellow("\n\nOperation cancelled by user"));
+              throw new ZapierCliUserCancellationError();
+            }
+            throw error;
           }
-          throw error;
         }
       }
     }
@@ -654,10 +739,11 @@ Optional fields${pathContext}:`));
       isRequired: fieldObj.is_required || false,
       defaultValue: fieldObj.default_value ?? fieldObj.default,
       valueType,
-      hasDropdown: fieldObj.format === "SELECT",
+      hasDropdown: fieldObj.format === "SELECT" || Boolean(fieldObj.choices),
       isMultiSelect: Boolean(
         valueType === "array" || fieldObj.items && fieldObj.items.type !== void 0
-      )
+      ),
+      inlineChoices: fieldObj.choices
     };
   }
   /**
@@ -665,11 +751,10 @@ Optional fields${pathContext}:`));
    */
   async fetchChoices(fieldMeta, inputs, context, cursor) {
     try {
-      console.log(
-        chalk7__default.default.gray(
-          cursor ? `  Fetching more choices...` : `  Fetching choices for ${fieldMeta.title}...`
-        )
+      this.debugLog(
+        cursor ? `Fetching more choices for ${fieldMeta.title}` : `Fetching choices for ${fieldMeta.title}`
       );
+      this.startSpinner();
       const page = await context.sdk.listInputFieldChoices({
         appKey: context.resolvedParams.appKey,
         actionKey: context.resolvedParams.actionKey,
@@ -679,13 +764,14 @@ Optional fields${pathContext}:`));
         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(
-          chalk7__default.default.yellow(`  No choices available for ${fieldMeta.title}`)
+          chalk7__default.default.yellow(`No choices available for ${fieldMeta.title}`)
         );
       }
       return {
@@ -693,8 +779,9 @@ Optional fields${pathContext}:`));
         nextCursor: page.nextCursor
       };
     } catch (error) {
+      this.stopSpinner();
       console.warn(
-        chalk7__default.default.yellow(`  \u26A0\uFE0F  Failed to fetch choices for ${fieldMeta.title}:`),
+        chalk7__default.default.yellow(`Failed to fetch choices for ${fieldMeta.title}:`),
         error
       );
       return { choices: [] };
@@ -710,6 +797,7 @@ Optional fields${pathContext}:`));
     inputs,
     context
   }) {
+    this.stopSpinner();
     const choices = [...initialChoices];
     let nextCursor = initialCursor;
     const LOAD_MORE_SENTINEL = Symbol("LOAD_MORE");
@@ -772,6 +860,27 @@ Optional fields${pathContext}:`));
     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;
@@ -819,7 +928,9 @@ Optional fields${pathContext}:`));
     const fieldMeta = this.extractFieldMetadata(field);
     let choices = [];
     let nextCursor;
-    if (fieldMeta.hasDropdown && context) {
+    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;
@@ -913,7 +1024,7 @@ var SHARED_COMMAND_CLI_OPTIONS = [
 
 // package.json
 var package_default = {
-  version: "0.35.1"};
+  version: "0.36.1"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {
@@ -981,7 +1092,7 @@ function formatJsonOutput(data) {
     util__default.default.inspect(data, { colors: true, depth: null, breakLength: 80 })
   );
 }
-function formatItemsFromSchema(functionInfo, items, startingNumber = 0) {
+async function formatItemsFromSchema(functionInfo, items, startingNumber = 0, options) {
   const outputSchema = functionInfo.outputSchema || getOutputSchema(functionInfo.inputSchema);
   if (!outputSchema) {
     formatItemsGeneric(items, startingNumber);
@@ -1022,11 +1133,39 @@ function formatSingleItem(formatted, itemNumber) {
     return;
   }
   for (const detail of formatted.details) {
-    const styledText = applyStyle(detail.text, detail.style);
-    console.log(`   ${styledText}`);
+    if (detail.label) {
+      const isMultiline = detail.text.includes("\n");
+      if (isMultiline) {
+        console.log(`   ${chalk7__default.default.gray(detail.label + ":")}`);
+        const displayText = formatDetailText(
+          detail.text,
+          DETAIL_INDENT + "   "
+        );
+        const styledText = applyStyle(displayText, detail.style);
+        console.log(`${DETAIL_INDENT}   ${styledText}`);
+      } else {
+        const styledValue = applyStyle(detail.text, detail.style);
+        console.log(`   ${chalk7__default.default.gray(detail.label + ":")} ${styledValue}`);
+      }
+    } else {
+      const displayText = formatDetailText(detail.text, DETAIL_INDENT);
+      const styledText = applyStyle(displayText, detail.style);
+      console.log(`   ${styledText}`);
+    }
   }
   console.log();
 }
+var DETAIL_INDENT = "   ";
+var DETAIL_MAX_LINES = 5;
+function formatDetailText(text, indent = DETAIL_INDENT) {
+  const columns = Math.max((process.stdout.columns || 80) - indent.length, 40);
+  const wrapped = wrapAnsi__default.default(text, columns, { hard: true, trim: false });
+  const lines = wrapped.split("\n");
+  if (lines.length <= DETAIL_MAX_LINES) {
+    return lines.join("\n" + indent);
+  }
+  return lines.slice(0, DETAIL_MAX_LINES).join("\n" + indent) + "\n" + indent + "\u2026";
+}
 function applyStyle(value, style) {
   switch (style) {
     case "dim":
@@ -1373,15 +1512,16 @@ var CONFIRM_MESSAGES = {
     messageBefore: "You are about to create a sensitive secret that will be displayed as plain text.\nOnce created, you cannot retrieve it again.",
     messageAfter: "Please treat this secret like a password and store it securely!"
   },
-  delete: {
-    messageBefore: "You are about to delete this record."
-  }
+  delete: (itemType) => ({
+    messageBefore: `You are about to delete the ${itemType || "item"}.`
+  })
 };
-async function promptConfirm(confirmType) {
+async function promptConfirm(confirmType, itemType) {
   if (!confirmType || !CONFIRM_MESSAGES[confirmType]) {
     return { confirmed: true };
   }
-  const { messageBefore, messageAfter } = CONFIRM_MESSAGES[confirmType];
+  const configOrFn = CONFIRM_MESSAGES[confirmType];
+  const { messageBefore, messageAfter } = typeof configOrFn === "function" ? configOrFn(itemType) : configOrFn;
   console.log(chalk7__default.default.yellow(`
 ${messageBefore}
 `));
@@ -1465,6 +1605,7 @@ function analyzeZodField(name, schema, functionInfo) {
     }
   }
   let paramType = "string";
+  let elementType;
   let choices;
   if (baseSchema instanceof zod.z.ZodString) {
     paramType = "string";
@@ -1474,6 +1615,14 @@ function analyzeZodField(name, schema, functionInfo) {
     paramType = "boolean";
   } else if (baseSchema instanceof zod.z.ZodArray) {
     paramType = "array";
+    const elementSchema = baseSchema._zod.def.element;
+    if (elementSchema instanceof zod.z.ZodObject || elementSchema instanceof zod.z.ZodRecord) {
+      elementType = "object";
+    } else if (elementSchema instanceof zod.z.ZodNumber) {
+      elementType = "number";
+    } else if (elementSchema instanceof zod.z.ZodBoolean) {
+      elementType = "boolean";
+    }
   } else if (baseSchema instanceof zod.z.ZodEnum) {
     paramType = "string";
     choices = baseSchema.options;
@@ -1492,7 +1641,8 @@ function analyzeZodField(name, schema, functionInfo) {
     default: defaultValue,
     choices,
     hasResolver: paramHasResolver,
-    isPositional: zapierSdk.isPositional(schema)
+    isPositional: zapierSdk.isPositional(schema),
+    elementType
   };
 }
 function analyzeInputParameters(inputParameters, functionInfo) {
@@ -1679,7 +1829,10 @@ function createCommandConfig(cliCommandName, functionInfo, sdk2) {
           rawParams,
           sdk2,
           functionInfo.name,
-          { interactiveMode }
+          {
+            interactiveMode,
+            debug: !!options2.debug || process.env.DEBUG === "true" || process.argv.includes("--debug")
+          }
         );
       } else {
         resolvedParams = rawParams;
@@ -1687,7 +1840,10 @@ function createCommandConfig(cliCommandName, functionInfo, sdk2) {
       const confirm = functionInfo.confirm;
       let confirmMessageAfter;
       if (confirm && interactiveMode) {
-        const confirmResult = await promptConfirm(confirm);
+        const confirmResult = await promptConfirm(
+          confirm,
+          functionInfo.itemType
+        );
         if (!confirmResult.confirmed) {
           console.log(chalk7__default.default.yellow("Operation cancelled."));
           return;
@@ -1876,7 +2032,8 @@ function convertCliArgsToSdkParams(parameters, positionalArgs, options) {
     if ((param.required || param.isPositional) && argIndex < positionalArgs.length) {
       sdkParams[param.name] = convertValue(
         positionalArgs[argIndex],
-        param.type
+        param.type,
+        param.elementType
       );
       argIndex++;
     }
@@ -1888,12 +2045,12 @@ function convertCliArgsToSdkParams(parameters, positionalArgs, options) {
       if (param.type === "array" && Array.isArray(value) && value.length === 0) {
         return;
       }
-      sdkParams[camelKey] = convertValue(value, param.type);
+      sdkParams[camelKey] = convertValue(value, param.type, param.elementType);
     }
   });
   return sdkParams;
 }
-function convertValue(value, type) {
+function convertValue(value, type, elementType) {
   if (value === void 0) {
     return void 0;
   }
@@ -1902,8 +2059,20 @@ function convertValue(value, type) {
       return Number(value);
     case "boolean":
       return Boolean(value);
-    case "array":
-      return Array.isArray(value) ? value : [value];
+    case "array": {
+      const arr = Array.isArray(value) ? value : [value];
+      if (elementType !== "object") return arr;
+      return arr.flatMap((item) => {
+        if (typeof item === "string" && (item.startsWith("{") || item.startsWith("["))) {
+          try {
+            return JSON.parse(item);
+          } catch {
+            return item;
+          }
+        }
+        return item;
+      });
+    }
     case "string":
       return value;
     case "object":
@@ -4389,7 +4558,7 @@ function createZapierCliSdk(options = {}) {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@zapier/zapier-sdk-cli",
-  version: "0.35.1"};
+  version: "0.36.1"};
 var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
 var CACHE_RESET_INTERVAL_MS = (() => {
   const { ZAPIER_SDK_UPDATE_CHECK_INTERVAL_MS = `${ONE_DAY_MS}` } = process.env;