@zapier/zapier-sdk-cli 0.35.1 → 0.36.1

package/dist/cli.mjs

@@ -4,14 +4,15 @@ import { z } from 'zod';
 import { createFunction, OutputPropertySchema, DEFAULT_CONFIG_PATH, injectCliLogin, createZapierSdkWithoutRegistry, registryPlugin, ZapierError, ZapierValidationError, ZapierUnknownError, batch, toSnakeCase, buildApplicationLifecycleEvent, isCredentialsObject, isPositional, runWithTelemetryContext, formatErrorMessage, getOsInfo, getPlatformVersions, getCiPlatform, isCi, getReleaseId, getCurrentTimestamp, generateEventId } from '@zapier/zapier-sdk';
 import inquirer from 'inquirer';
 import chalk7 from 'chalk';
+import ora from 'ora';
 import util from 'util';
+import wrapAnsi from 'wrap-ansi';
 import * as cliLogin from '@zapier/zapier-sdk-cli-login';
 import { logout, getConfigPath, getLoggedInUser, getPkceLoginConfig, AUTH_MODE_HEADER, getLoginStorageMode, updateLogin, getConfig } from '@zapier/zapier-sdk-cli-login';
 import open from 'open';
 import crypto, { createHash } from 'crypto';
 import express from 'express';
 import pkceChallenge from 'pkce-challenge';
-import ora from 'ora';
 import { startMcpServer } from '@zapier/zapier-sdk-mcp';
 import { buildSync } from 'esbuild';
 import * as fs from 'fs';
@@ -106,9 +107,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.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, sdk2, functionName, options) {
     return 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(
@@ -118,27 +141,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));
         }
@@ -152,19 +166,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);
+          let param = required.find((p) => p.name === paramName);
           if (!param) {
-            param = alwaysPrompt.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);
@@ -197,33 +208,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.yellow("\n\nOperation cancelled by user"));
@@ -233,44 +242,6 @@ var SchemaParameterResolver = class {
           }
         }
       }
-      if (interactiveMode && trulyOptional.length > 0) {
-        const optionalNames = trulyOptional.map((p) => p.name).join(", ");
-        const shouldResolveOptional = await inquirer.prompt([
-          {
-            type: "confirm",
-            name: "resolveOptional",
-            message: `Would you like to be prompted for optional parameters (${optionalNames})?`,
-            default: false
-          }
-        ]);
-        if (shouldResolveOptional.resolveOptional) {
-          const optionalParamNames = trulyOptional.map((p) => p.name);
-          const optionalResolutionOrder = 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.yellow("\n\nOperation cancelled by user"));
-                throw new ZapierCliUserCancellationError();
-              }
-              throw error;
-            }
-          }
-        }
-      }
       const finalResult = schema.safeParse(resolvedParams);
       if (!finalResult.success) {
         throw new ZapierCliValidationError(
@@ -365,7 +336,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,
@@ -374,53 +345,102 @@ var SchemaParameterResolver = class {
     if (!resolver) {
       throw new Error(`No resolver found for parameter: ${param.name}`);
     }
-    console.log(chalk7.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.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.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.dim("(Skip)"), value: SKIP_SENTINEL },
+          ...promptConfig.choices
+        ];
+        const answers2 = await inquirer.prompt([promptConfig]);
+        const value = answers2[promptName];
+        if (value === SKIP_SENTINEL) {
+          return void 0;
+        }
+        return value;
+      }
       const answers = await inquirer.prompt([promptConfig]);
-      return answers[param.name];
+      return answers[promptName];
     } 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 ${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;
@@ -434,15 +454,15 @@ var SchemaParameterResolver = class {
           inputs
         }
       };
-      console.log(
-        chalk7.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(
@@ -457,7 +477,8 @@ var SchemaParameterResolver = class {
         processedFieldKeys,
         [],
         iteration,
-        updatedContext
+        updatedContext,
+        { inArrayContext: options.inArrayContext }
       );
       if (fieldStats.newRequired === 0 && fieldStats.newOptional === 0) {
         break;
@@ -474,13 +495,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.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.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;
@@ -506,7 +574,8 @@ var SchemaParameterResolver = class {
           processedFieldKeys,
           nestedPath,
           iteration,
-          context
+          context,
+          options
         );
         newRequiredCount += nestedStats.newRequired;
         newOptionalCount += nestedStats.newOptional;
@@ -520,15 +589,22 @@ var SchemaParameterResolver = class {
         const isRequired = typedItem.is_required || false;
         if (isRequired) {
           newRequiredCount++;
-          if (newRequiredCount === 1 && fieldsetPath.length === 0) {
-            console.log(
-              chalk7.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: 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++;
@@ -542,42 +618,50 @@ var SchemaParameterResolver = class {
       });
       if (optionalFields.length > 0) {
         const pathContext = fieldsetPath.length > 0 ? ` in ${fieldsetPath.join(" > ")}` : "";
-        console.log(
-          chalk7.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.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(chalk7.cyan(`
+            )
+          );
+          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(chalk7.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.yellow("\n\nOperation cancelled by user"));
-            throw new ZapierCliUserCancellationError();
+          } catch (error) {
+            if (this.isUserCancellation(error)) {
+              console.log(chalk7.yellow("\n\nOperation cancelled by user"));
+              throw new ZapierCliUserCancellationError();
+            }
+            throw error;
           }
-          throw error;
         }
       }
     }
@@ -617,10 +701,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
     };
   }
   /**
@@ -628,11 +713,10 @@ Optional fields${pathContext}:`));
    */
   async fetchChoices(fieldMeta, inputs, context, cursor) {
     try {
-      console.log(
-        chalk7.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,
@@ -642,13 +726,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.yellow(`  No choices available for ${fieldMeta.title}`)
+          chalk7.yellow(`No choices available for ${fieldMeta.title}`)
         );
       }
       return {
@@ -656,8 +741,9 @@ Optional fields${pathContext}:`));
         nextCursor: page.nextCursor
       };
     } catch (error) {
+      this.stopSpinner();
       console.warn(
-        chalk7.yellow(`  \u26A0\uFE0F  Failed to fetch choices for ${fieldMeta.title}:`),
+        chalk7.yellow(`Failed to fetch choices for ${fieldMeta.title}:`),
         error
       );
       return { choices: [] };
@@ -673,6 +759,7 @@ Optional fields${pathContext}:`));
     inputs,
     context
   }) {
+    this.stopSpinner();
     const choices = [...initialChoices];
     let nextCursor = initialCursor;
     const LOAD_MORE_SENTINEL = Symbol("LOAD_MORE");
@@ -735,6 +822,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;
@@ -782,7 +890,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;
@@ -876,7 +986,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 = {}) {
@@ -944,7 +1054,7 @@ function formatJsonOutput(data) {
     util.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);
@@ -985,11 +1095,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.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.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(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":
@@ -1336,15 +1474,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.yellow(`
 ${messageBefore}
 `));
@@ -1428,6 +1567,7 @@ function analyzeZodField(name, schema, functionInfo) {
     }
   }
   let paramType = "string";
+  let elementType;
   let choices;
   if (baseSchema instanceof z.ZodString) {
     paramType = "string";
@@ -1437,6 +1577,14 @@ function analyzeZodField(name, schema, functionInfo) {
     paramType = "boolean";
   } else if (baseSchema instanceof z.ZodArray) {
     paramType = "array";
+    const elementSchema = baseSchema._zod.def.element;
+    if (elementSchema instanceof z.ZodObject || elementSchema instanceof z.ZodRecord) {
+      elementType = "object";
+    } else if (elementSchema instanceof z.ZodNumber) {
+      elementType = "number";
+    } else if (elementSchema instanceof z.ZodBoolean) {
+      elementType = "boolean";
+    }
   } else if (baseSchema instanceof z.ZodEnum) {
     paramType = "string";
     choices = baseSchema.options;
@@ -1455,7 +1603,8 @@ function analyzeZodField(name, schema, functionInfo) {
     default: defaultValue,
     choices,
     hasResolver: paramHasResolver,
-    isPositional: isPositional(schema)
+    isPositional: isPositional(schema),
+    elementType
   };
 }
 function analyzeInputParameters(inputParameters, functionInfo) {
@@ -1642,7 +1791,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;
@@ -1650,7 +1802,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.yellow("Operation cancelled."));
           return;
@@ -1839,7 +1994,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++;
     }
@@ -1851,12 +2007,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;
   }
@@ -1865,8 +2021,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":
@@ -4352,7 +4520,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;