@zapier/zapier-sdk-cli 0.10.0 → 0.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk-cli",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "description": "Command line interface for Zapier SDK",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -42,9 +42,9 @@
     "ora": "^8.2.0",
     "pkce-challenge": "^5.0.0",
     "zod": "^3.25.67",
-    "@zapier/zapier-sdk": "0.10.0",
+    "@zapier/zapier-sdk": "0.11.1",
     "@zapier/zapier-sdk-cli-login": "0.3.2",
-    "@zapier/zapier-sdk-mcp": "0.3.7"
+    "@zapier/zapier-sdk-mcp": "0.3.9"
   },
   "devDependencies": {
     "@types/express": "^5.0.3",

package/src/utils/parameter-resolver.ts

@@ -459,7 +459,7 @@ export class SchemaParameterResolver {
     const inputs: Record<string, unknown> = {};
     let processedFieldKeys = new Set<string>();
     let iteration = 0;
-    const maxIterations = 5; // Prevent infinite loops
+    const maxIterations = 10; // Prevent infinite loops
 
     while (iteration < maxIterations) {
       iteration++;
@@ -479,12 +479,12 @@ export class SchemaParameterResolver {
         ),
       );
 
-      const fields = await typedResolver.fetch(
+      const rootFieldItems = await typedResolver.fetch(
         updatedContext.sdk,
         updatedContext.resolvedParams,
       );
 
-      if (!fields || fields.length === 0) {
+      if (!rootFieldItems || rootFieldItems.length === 0) {
         if (iteration === 1) {
           console.log(
             chalk.yellow(`No input fields required for this action.`),
@@ -493,59 +493,180 @@ export class SchemaParameterResolver {
         break;
       }
 
-      // Find new fields that we haven't processed yet
-      const newFields = fields.filter(
-        (field: unknown) =>
-          !(
-            (field as { key: string }).key &&
-            processedFieldKeys.has((field as { key: string }).key)
-          ),
+      // Process fields recursively, maintaining fieldset structure
+      const fieldStats = await this.processFieldItems(
+        rootFieldItems,
+        inputs,
+        processedFieldKeys,
+        [],
+        iteration,
       );
 
-      if (newFields.length === 0) {
-        // No new fields, we're done
+      // If no new fields were processed, we're done
+      if (fieldStats.newRequired === 0 && fieldStats.newOptional === 0) {
         break;
       }
 
-      // Separate new required and optional fields
-      const newRequiredFields = newFields.filter(
-        (field: unknown) => (field as { is_required: boolean }).is_required,
-      );
-      const newOptionalFields = newFields.filter(
-        (field: unknown) => !(field as { is_required: boolean }).is_required,
+      // If we only processed optional fields and skipped them, no need to re-fetch
+      if (fieldStats.newRequired === 0 && fieldStats.optionalSkipped) {
+        break;
+      }
+    }
+
+    if (iteration >= maxIterations) {
+      console.log(
+        chalk.yellow(
+          `\n⚠️  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`,
+        ),
       );
+    }
+
+    return inputs;
+  }
+
+  /**
+   * Recursively processes fieldsets and their fields, maintaining natural structure
+   * and creating nested inputs as needed (e.g., fieldset "foo" becomes inputs.foo = [{}])
+   */
+  private async processFieldItems(
+    items: unknown[],
+    targetInputs: Record<string, unknown>,
+    processedFieldKeys: Set<string>,
+    fieldsetPath: string[] = [],
+    iteration: number = 1,
+  ): Promise<{
+    newRequired: number;
+    newOptional: number;
+    optionalSkipped: boolean;
+  }> {
+    let newRequiredCount = 0;
+    let newOptionalCount = 0;
+    let optionalSkipped = false;
+
+    for (const item of items) {
+      const typedItem = item as {
+        type?: string;
+        key?: string;
+        title?: string;
+        fields?: unknown[];
+        is_required?: boolean;
+      };
 
-      // Prompt for new required fields
-      if (newRequiredFields.length > 0) {
+      if (typedItem.type === "fieldset" && typedItem.fields && typedItem.key) {
+        // Show fieldset context to user
+        const fieldsetTitle = typedItem.title || typedItem.key;
+        const pathDisplay =
+          fieldsetPath.length > 0 ? ` (in ${fieldsetPath.join(" > ")})` : "";
         console.log(
-          chalk.blue(
-            `\n📝 Please provide values for the following ${iteration === 1 ? "" : "additional "}input fields:`,
+          chalk.cyan(
+            `\n📁 Processing fieldset: ${fieldsetTitle}${pathDisplay}`,
           ),
         );
-        for (const field of newRequiredFields) {
-          await this.promptForField(field, inputs);
-          processedFieldKeys.add((field as { key: string }).key);
+
+        // Create fieldset array in target inputs if it doesn't exist
+        if (!targetInputs[typedItem.key]) {
+          targetInputs[typedItem.key] = [{}];
+        }
+
+        // Process fields within this fieldset recursively
+        const fieldsetTarget = (
+          targetInputs[typedItem.key] as Record<string, unknown>[]
+        )[0];
+        const nestedPath = [...fieldsetPath, fieldsetTitle];
+
+        const nestedStats = await this.processFieldItems(
+          typedItem.fields,
+          fieldsetTarget,
+          processedFieldKeys,
+          nestedPath,
+          iteration,
+        );
+
+        newRequiredCount += nestedStats.newRequired;
+        newOptionalCount += nestedStats.newOptional;
+        if (nestedStats.optionalSkipped) {
+          optionalSkipped = true;
+        }
+      } else if (typedItem.type === "input_field" && typedItem.key) {
+        // Skip if already processed
+        if (processedFieldKeys.has(typedItem.key)) {
+          continue;
+        }
+
+        const isRequired = typedItem.is_required || false;
+
+        if (isRequired) {
+          // Process required field immediately
+          newRequiredCount++;
+          if (newRequiredCount === 1 && fieldsetPath.length === 0) {
+            // Only show this message once at root level
+            console.log(
+              chalk.blue(
+                `\n📝 Please provide values for the following ${iteration === 1 ? "" : "additional "}input fields:`,
+              ),
+            );
+          }
+
+          await this.promptForField(typedItem, targetInputs);
+          processedFieldKeys.add(typedItem.key);
+        } else {
+          // Collect optional fields for batch processing
+          newOptionalCount++;
         }
       }
+      // Skip info fields - they're for display only
+    }
 
-      // Ask about optional fields
-      let shouldConfigureOptional = { configure: false };
-      if (newOptionalFields.length > 0) {
+    // Handle optional fields after processing all required fields
+    if (newOptionalCount > 0) {
+      const optionalFields = items.filter((item: unknown) => {
+        const typedItem = item as {
+          type?: string;
+          key?: string;
+          is_required?: boolean;
+        };
+        return (
+          typedItem.type === "input_field" &&
+          typedItem.key &&
+          !typedItem.is_required &&
+          !processedFieldKeys.has(typedItem.key)
+        );
+      });
+
+      if (optionalFields.length > 0) {
+        const pathContext =
+          fieldsetPath.length > 0 ? ` in ${fieldsetPath.join(" > ")}` : "";
         console.log(
           chalk.gray(
-            `\nThere are ${newOptionalFields.length} ${iteration === 1 ? "" : "additional "}optional field(s) available.`,
+            `\nThere are ${optionalFields.length} ${iteration === 1 ? "" : "additional "}optional field(s) available${pathContext}.`,
           ),
         );
 
         try {
-          shouldConfigureOptional = await inquirer.prompt([
+          const shouldConfigureOptional = await inquirer.prompt([
             {
               type: "confirm",
               name: "configure",
-              message: `Would you like to configure ${iteration === 1 ? "" : "these additional "}optional fields?`,
+              message: `Would you like to configure ${iteration === 1 ? "" : "these additional "}optional fields${pathContext}?`,
               default: false,
             },
           ]);
+
+          if (shouldConfigureOptional.configure) {
+            console.log(chalk.cyan(`\nOptional fields${pathContext}:`));
+            for (const field of optionalFields) {
+              await this.promptForField(field, targetInputs);
+              const typedField = field as { key: string };
+              processedFieldKeys.add(typedField.key);
+            }
+          } else {
+            optionalSkipped = true;
+            // Mark these fields as processed even if skipped to avoid re-asking
+            optionalFields.forEach((field: unknown) => {
+              const typedField = field as { key: string };
+              processedFieldKeys.add(typedField.key);
+            });
+          }
         } catch (error) {
           if (this.isUserCancellation(error)) {
             console.log(chalk.yellow("\n\nOperation cancelled by user"));
@@ -553,39 +674,14 @@ export class SchemaParameterResolver {
           }
           throw error;
         }
-
-        if (shouldConfigureOptional.configure) {
-          console.log(chalk.cyan(`\nOptional fields:`));
-          for (const field of newOptionalFields) {
-            await this.promptForField(field, inputs);
-            processedFieldKeys.add((field as { key: string }).key);
-          }
-        } else {
-          // Mark these fields as processed even if skipped to avoid re-asking
-          newOptionalFields.forEach((field: unknown) =>
-            processedFieldKeys.add((field as { key: string }).key),
-          );
-        }
-      }
-
-      // If we only processed optional fields and skipped them, no need to re-fetch
-      if (
-        newRequiredFields.length === 0 &&
-        (!newOptionalFields.length || !shouldConfigureOptional.configure)
-      ) {
-        break;
       }
     }
 
-    if (iteration >= maxIterations) {
-      console.log(
-        chalk.yellow(
-          `\n⚠️  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`,
-        ),
-      );
-    }
-
-    return inputs;
+    return {
+      newRequired: newRequiredCount,
+      newOptional: newOptionalCount,
+      optionalSkipped,
+    };
   }
 
   private getNestedValue(obj: unknown, path: string[]): unknown {