@zapier/zapier-sdk-cli 0.15.0 → 0.15.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk-cli",
-  "version": "0.15.0",
+  "version": "0.15.2",
   "description": "Command line interface for Zapier SDK",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
@@ -47,9 +47,9 @@
     "semver": "^7.7.3",
     "typescript": "^5.8.3",
     "zod": "^3.25.67",
-    "@zapier/zapier-sdk": "0.15.2",
-    "@zapier/zapier-sdk-cli-login": "0.3.4",
-    "@zapier/zapier-sdk-mcp": "0.3.26"
+    "@zapier/zapier-sdk": "0.15.3",
+    "@zapier/zapier-sdk-mcp": "0.3.27",
+    "@zapier/zapier-sdk-cli-login": "0.3.4"
   },
   "devDependencies": {
     "@types/express": "^5.0.3",

package/src/plugins/buildManifest/index.test.ts

@@ -4,7 +4,6 @@ import { BuildManifestSchema } from "./schemas";
 import type {
   AppItem,
   Manifest,
-  ManifestEntry,
   UpdateManifestEntryOptions,
 } from "@zapier/zapier-sdk";
 import {
@@ -49,20 +48,20 @@ describe("buildManifest plugin", () => {
 
     mockUpdateManifestEntry = vi
       .fn()
-      .mockImplementation(
-        async (
-          options: UpdateManifestEntryOptions,
-        ): Promise<[string, ManifestEntry, Manifest]> => {
-          const manifestKey = options.entry.implementationName;
-          const updatedManifest: Manifest = {
-            apps: {
-              ...options.manifest?.apps,
-              [manifestKey]: options.entry,
-            },
-          };
-          return [manifestKey, options.entry, updatedManifest];
-        },
-      );
+      .mockImplementation(async (options: UpdateManifestEntryOptions) => {
+        const manifestKey = options.entry.implementationName;
+        const updatedManifest: Manifest = {
+          apps: {
+            ...options.manifest?.apps,
+            [manifestKey]: options.entry,
+          },
+        };
+        return {
+          key: manifestKey,
+          entry: options.entry,
+          manifest: updatedManifest,
+        };
+      });
 
     mockListAppsItems = vi.fn();
   });
@@ -81,6 +80,31 @@ describe("buildManifest plugin", () => {
       .addPlugin(() => ({
         context: {
           updateManifestEntry: mockUpdateManifestEntry,
+          addActionEntry: vi
+            .fn()
+            .mockResolvedValue(["test-key", {}, { apps: {} }]),
+          findActionEntry: vi.fn().mockResolvedValue({
+            key: "test-key",
+            entry: {},
+            manifest: { apps: {} },
+          }),
+          hasActionEntry: vi.fn().mockResolvedValue(true),
+          listActionEntries: vi
+            .fn()
+            .mockResolvedValue([
+              [
+                "test-key",
+                { key: "test-key", entry: {}, manifest: { apps: {} } },
+              ],
+            ]),
+          deleteActionEntry: vi.fn().mockResolvedValue({ apps: {} }),
+          findManifestEntry: vi
+            .fn()
+            .mockResolvedValue([
+              "test-key",
+              { key: "test-key", entry: {}, manifest: { apps: {} } },
+            ]),
+          readManifestFromFile: vi.fn().mockResolvedValue({ apps: {} }),
         },
       }))
       .addPlugin(() => ({

package/src/plugins/buildManifest/index.ts

@@ -76,7 +76,7 @@ export const buildManifestPlugin: Plugin<
           version: manifestEntry.version || "",
         });
 
-        const [updatedManifestKey, , manifest] =
+        const { key: updatedManifestKey, manifest } =
           await context.updateManifestEntry({
             appKey: app.key,
             entry: manifestEntry,

package/src/utils/parameter-resolver.ts

@@ -1,7 +1,7 @@
 import inquirer from "inquirer";
 import chalk from "chalk";
 import { z } from "zod";
-import type { ZapierSdk } from "@zapier/zapier-sdk";
+import type { ZapierSdk, ActionTypeProperty } from "@zapier/zapier-sdk";
 import { ZapierCliUserCancellationError } from "./errors";
 
 // ============================================================================
@@ -23,6 +23,17 @@ interface ResolverContext {
   functionName?: string;
 }
 
+interface FieldMetadata {
+  key: string;
+  title: string;
+  description?: string;
+  isRequired: boolean;
+  defaultValue?: unknown;
+  valueType: string;
+  hasDropdown: boolean;
+  isMultiSelect: boolean;
+}
+
 // ============================================================================
 // Local Resolution Helper Functions
 // ============================================================================
@@ -501,6 +512,7 @@ export class SchemaParameterResolver {
         processedFieldKeys,
         [],
         iteration,
+        updatedContext,
       );
 
       // If no new fields were processed, we're done
@@ -535,6 +547,7 @@ export class SchemaParameterResolver {
     processedFieldKeys: Set<string>,
     fieldsetPath: string[] = [],
     iteration: number = 1,
+    context?: ResolverContext,
   ): Promise<{
     newRequired: number;
     newOptional: number;
@@ -581,6 +594,7 @@ export class SchemaParameterResolver {
           processedFieldKeys,
           nestedPath,
           iteration,
+          context,
         );
 
         newRequiredCount += nestedStats.newRequired;
@@ -608,7 +622,7 @@ export class SchemaParameterResolver {
             );
           }
 
-          await this.promptForField(typedItem, targetInputs);
+          await this.promptForField(typedItem, targetInputs, context);
           processedFieldKeys.add(typedItem.key);
         } else {
           // Collect optional fields for batch processing
@@ -656,7 +670,7 @@ export class SchemaParameterResolver {
           if (shouldConfigureOptional.configure) {
             console.log(chalk.cyan(`\nOptional fields${pathContext}:`));
             for (const field of optionalFields) {
-              await this.promptForField(field, targetInputs);
+              await this.promptForField(field, targetInputs, context);
               const typedField = field as { key: string };
               processedFieldKeys.add(typedField.key);
             }
@@ -704,54 +718,244 @@ export class SchemaParameterResolver {
     parent[lastKey] = value;
   }
 
-  private async promptForField(
-    field: unknown,
-    inputs: Record<string, unknown>,
-  ): Promise<void> {
+  /**
+   * Extract and normalize field metadata from raw field object
+   */
+  private extractFieldMetadata(field: unknown): FieldMetadata {
     const fieldObj = field as {
       type?: string;
       key: string;
+      title?: string;
       label?: string;
       is_required?: boolean;
+      description?: string;
       helpText?: string;
+      default_value?: unknown;
       default?: unknown;
-      choices?: Array<{ label?: string; value: unknown }>;
+      value_type?: string;
+      format?: string;
+      items?: { type: string };
     };
 
-    const fieldPrompt: Record<string, unknown> = {
-      type: fieldObj.type === "boolean" ? "confirm" : "input",
-      name: fieldObj.key,
-      message: `${fieldObj.label || fieldObj.key}${fieldObj.is_required ? " (required)" : " (optional)"}:`,
+    const valueType = fieldObj.value_type || "string";
+
+    return {
+      key: fieldObj.key,
+      title: fieldObj.title || fieldObj.label || fieldObj.key,
+      description: fieldObj.description || fieldObj.helpText,
+      isRequired: fieldObj.is_required || false,
+      defaultValue: fieldObj.default_value ?? fieldObj.default,
+      valueType,
+      hasDropdown: fieldObj.format === "SELECT",
+      isMultiSelect: Boolean(
+        valueType === "array" ||
+          (fieldObj.items && fieldObj.items.type !== undefined),
+      ),
     };
+  }
+
+  /**
+   * Fetch a page of choices for a dropdown field
+   */
+  private async fetchChoices(
+    fieldMeta: FieldMetadata,
+    inputs: Record<string, unknown>,
+    context: ResolverContext,
+    cursor?: string,
+  ): Promise<{
+    choices: Array<{ label: string; value: unknown }>;
+    nextCursor?: string;
+  }> {
+    try {
+      console.log(
+        chalk.gray(
+          cursor
+            ? `  Fetching more choices...`
+            : `  Fetching choices for ${fieldMeta.title}...`,
+        ),
+      );
+
+      const page = await context.sdk.listInputFieldChoices({
+        appKey: context.resolvedParams.appKey as string,
+        actionKey: context.resolvedParams.actionKey as string,
+        actionType: context.resolvedParams.actionType as ActionTypeProperty,
+        authenticationId: context.resolvedParams.authenticationId as
+          | number
+          | null,
+        inputFieldKey: fieldMeta.key,
+        inputs,
+        ...(cursor && { cursor }),
+      });
+
+      const choices = page.data.map((choice) => ({
+        label: choice.label || choice.key || String(choice.value),
+        value: choice.value ?? choice.key,
+      }));
+
+      if (choices.length === 0 && !cursor) {
+        console.log(
+          chalk.yellow(`  No choices available for ${fieldMeta.title}`),
+        );
+      }
+
+      return {
+        choices,
+        nextCursor: page.nextCursor,
+      };
+    } catch (error) {
+      console.warn(
+        chalk.yellow(`  ⚠️  Failed to fetch choices for ${fieldMeta.title}:`),
+        error,
+      );
+      return { choices: [] };
+    }
+  }
+
+  /**
+   * Prompt user with choices (handles both single and multi-select with pagination)
+   */
+  private async promptWithChoices({
+    fieldMeta,
+    choices: initialChoices,
+    nextCursor: initialCursor,
+    inputs,
+    context,
+  }: {
+    fieldMeta: FieldMetadata;
+    choices: Array<{ label: string; value: unknown }>;
+    nextCursor?: string;
+    inputs: Record<string, unknown>;
+    context?: ResolverContext;
+  }): Promise<unknown> {
+    const choices = [...initialChoices];
+    let nextCursor = initialCursor;
+    const LOAD_MORE_SENTINEL = Symbol("LOAD_MORE");
+
+    // Progressive loading loop
+    while (true) {
+      const promptChoices = choices.map((choice) => ({
+        name: choice.label,
+        value: choice.value,
+      }));
+
+      // Add "(Load more...)" option if there are more pages
+      if (nextCursor) {
+        promptChoices.push({
+          name: chalk.dim("(Load more...)"),
+          value: LOAD_MORE_SENTINEL,
+        });
+      }
+
+      // Add skip option for optional fields (single-select only)
+      if (!fieldMeta.isRequired && !fieldMeta.isMultiSelect) {
+        promptChoices.push({ name: "(Skip)", value: undefined });
+      }
+
+      const promptConfig = {
+        type: fieldMeta.isMultiSelect ? "checkbox" : "list",
+        name: fieldMeta.key,
+        message: `${fieldMeta.title}${fieldMeta.isRequired ? " (required)" : " (optional)"}:`,
+        choices: promptChoices,
+        ...(fieldMeta.isMultiSelect && {
+          validate: (input: unknown[]) => {
+            if (fieldMeta.isRequired && (!input || input.length === 0)) {
+              return "At least one selection is required";
+            }
+            return true;
+          },
+        }),
+      };
+
+      const answer = await inquirer.prompt([promptConfig as any]);
+      let selectedValue = answer[fieldMeta.key];
+
+      // Check if user selected "Load more..."
+      const wantsMore = fieldMeta.isMultiSelect
+        ? Array.isArray(selectedValue) &&
+          selectedValue.includes(LOAD_MORE_SENTINEL)
+        : selectedValue === LOAD_MORE_SENTINEL;
+
+      if (wantsMore && nextCursor && context) {
+        // Remove sentinel from multi-select
+        if (fieldMeta.isMultiSelect && Array.isArray(selectedValue)) {
+          selectedValue = selectedValue.filter((v) => v !== LOAD_MORE_SENTINEL);
+        }
 
-    if (fieldObj.helpText) {
-      fieldPrompt.prefix = chalk.gray(`ℹ ${fieldObj.helpText}\n`);
+        // Fetch next page
+        const result = await this.fetchChoices(
+          fieldMeta,
+          inputs,
+          context,
+          nextCursor,
+        );
+        choices.push(...result.choices);
+        nextCursor = result.nextCursor;
+
+        // Re-prompt with updated choices
+        continue;
+      }
+
+      return selectedValue;
     }
+  }
 
-    if (fieldObj.default !== undefined) {
-      fieldPrompt.default = fieldObj.default;
+  /**
+   * Prompt user for free-form input (text or boolean)
+   */
+  private async promptFreeForm(fieldMeta: FieldMetadata): Promise<unknown> {
+    const promptConfig: Record<string, unknown> = {
+      name: fieldMeta.key,
+      message: `${fieldMeta.title}${fieldMeta.isRequired ? " (required)" : " (optional)"}:`,
+    };
+
+    if (fieldMeta.valueType === "boolean") {
+      promptConfig.type = "confirm";
+      promptConfig.default =
+        fieldMeta.defaultValue !== undefined
+          ? Boolean(fieldMeta.defaultValue)
+          : undefined;
+    } else {
+      promptConfig.type = "input";
+      promptConfig.default = fieldMeta.defaultValue;
+      promptConfig.validate = (input: string) => {
+        if (fieldMeta.isRequired && !input) {
+          return "This field is required";
+        }
+        return true;
+      };
     }
 
-    if (fieldObj.choices && fieldObj.choices.length > 0) {
-      fieldPrompt.type = "list";
-      (fieldPrompt as { choices: unknown[] }).choices = fieldObj.choices.map(
-        (choice: unknown) => {
-          const choiceObj = choice as { label?: unknown; value: unknown };
-          return {
-            name: choiceObj.label || choiceObj.value,
-            value: choiceObj.value,
-          };
-        },
-      );
+    // Add help text if available
+    if (fieldMeta.description) {
+      promptConfig.prefix = chalk.gray(`ℹ  ${fieldMeta.description}\n`);
     }
 
     try {
-      const answer = await inquirer.prompt([fieldPrompt as any]);
+      const answer = await inquirer.prompt([promptConfig as any]);
+      return answer[fieldMeta.key];
+    } catch (error) {
+      if (this.isUserCancellation(error)) {
+        console.log(chalk.yellow("\n\nOperation cancelled by user"));
+        throw new ZapierCliUserCancellationError();
+      }
+      throw error;
+    }
+  }
 
-      if (answer[fieldObj.key] !== undefined && answer[fieldObj.key] !== "") {
-        inputs[fieldObj.key] = answer[fieldObj.key];
-      } else if (fieldObj.is_required) {
-        throw new Error(`Required field ${fieldObj.key} cannot be empty`);
+  /**
+   * Store field value in inputs object with validation
+   */
+  private storeFieldValue(
+    inputs: Record<string, unknown>,
+    key: string,
+    value: unknown,
+    isRequired: boolean,
+  ): void {
+    try {
+      if (value !== undefined && value !== "") {
+        inputs[key] = value;
+      } else if (isRequired) {
+        throw new Error(`Required field ${key} cannot be empty`);
       }
     } catch (error) {
       if (this.isUserCancellation(error)) {
@@ -762,6 +966,45 @@ export class SchemaParameterResolver {
     }
   }
 
+  private async promptForField(
+    field: unknown,
+    inputs: Record<string, unknown>,
+    context?: ResolverContext,
+  ): Promise<void> {
+    const fieldMeta = this.extractFieldMetadata(field);
+
+    // Fetch choices if field has dropdown
+    let choices: Array<{ label: string; value: unknown }> = [];
+    let nextCursor: string | undefined;
+    if (fieldMeta.hasDropdown && context) {
+      const result = await this.fetchChoices(fieldMeta, inputs, context);
+      choices = result.choices;
+      nextCursor = result.nextCursor;
+    }
+
+    // Prompt user based on field type
+    let selectedValue: unknown;
+    if (choices.length > 0) {
+      selectedValue = await this.promptWithChoices({
+        fieldMeta,
+        choices,
+        nextCursor,
+        inputs,
+        context,
+      });
+    } else {
+      selectedValue = await this.promptFreeForm(fieldMeta);
+    }
+
+    // Store result
+    this.storeFieldValue(
+      inputs,
+      fieldMeta.key,
+      selectedValue,
+      fieldMeta.isRequired,
+    );
+  }
+
   private isUserCancellation(error: unknown): boolean {
     const errorObj = error as {
       name?: string;