@zapier/zapier-sdk-cli 0.0.1

package/src/utils/parameter-resolver.ts

@@ -0,0 +1,573 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { z } from "zod";
+import { ActionsSDK } from "@zapier/actions-sdk";
+
+// For editor-like prompts, we'll use a regular input prompt with multiline support
+
+// ============================================================================
+// Types
+// ============================================================================
+
+interface ResolvableParameter {
+  name: string;
+  path: string[];
+  schema: z.ZodType;
+  description?: string;
+  resolverMeta?: any;
+  isRequired: boolean;
+}
+
+interface ResolverContext {
+  sdk: ActionsSDK;
+  currentParams: any;
+  resolvedParams: any;
+}
+
+// ============================================================================
+// Schema Parameter Resolver
+// ============================================================================
+
+export class SchemaParameterResolver {
+  async resolveParameters(
+    schema: z.ZodSchema,
+    providedParams: any,
+    sdk: ActionsSDK,
+  ): Promise<any> {
+    // 1. Try to parse with current parameters
+    const parseResult = schema.safeParse(providedParams);
+
+    // Even if parsing succeeds, check if we should resolve optional but important parameters
+    const allResolvable = this.findAllResolvableParameters(schema);
+    const shouldResolveAnyway = allResolvable.filter((param) => {
+      const hasValue =
+        this.getNestedValue(providedParams, param.path) !== undefined;
+      // Resolve any parameters with resolvers even if optional, unless explicitly provided
+      return !hasValue && param.resolverMeta?.resolver;
+    });
+
+    if (parseResult.success && shouldResolveAnyway.length === 0) {
+      return parseResult.data;
+    }
+
+    // 2. Analyze what's missing and can be resolved
+    let missingResolvable: ResolvableParameter[];
+
+    if (!parseResult.success) {
+      missingResolvable = this.findResolvableParameters(
+        schema,
+        parseResult.error,
+        providedParams,
+      );
+    } else {
+      // Schema parsing succeeded, but we want to resolve optional important parameters
+      missingResolvable = shouldResolveAnyway;
+    }
+
+    if (missingResolvable.length === 0) {
+      // No resolvable parameters, throw original error
+      throw parseResult.error;
+    }
+
+    // 3. Resolve missing parameters interactively
+    const resolvedParams = { ...providedParams };
+    const context: ResolverContext = {
+      sdk,
+      currentParams: providedParams,
+      resolvedParams,
+    };
+
+    // Sort by dependency order (parameters that depend on others go last)
+    const sortedMissing = this.sortByDependencies(missingResolvable);
+
+    for (const missing of sortedMissing) {
+      try {
+        const value = await this.resolveParameter(missing, context);
+        this.setNestedValue(resolvedParams, missing.path, value);
+
+        // Update context with newly resolved value
+        context.resolvedParams = resolvedParams;
+      } catch (error) {
+        if (this.isUserCancellation(error)) {
+          console.log(chalk.yellow("\n\nOperation cancelled by user"));
+          process.exit(0);
+        }
+        console.error(chalk.red(`Failed to resolve ${missing.name}:`), error);
+        throw error;
+      }
+    }
+
+    // 4. Validate final parameters
+    const finalResult = schema.safeParse(resolvedParams);
+
+    if (!finalResult.success) {
+      console.error(
+        chalk.red("❌ Parameter validation failed after resolution:"),
+      );
+      throw finalResult.error;
+    }
+
+    return finalResult.data;
+  }
+
+  private findAllResolvableParameters(
+    schema: z.ZodSchema,
+  ): ResolvableParameter[] {
+    const resolvable: ResolvableParameter[] = [];
+    this.analyzeSchema(schema, [], resolvable);
+    return resolvable;
+  }
+
+  private findResolvableParameters(
+    schema: z.ZodSchema,
+    error: z.ZodError,
+    providedParams: any,
+  ): ResolvableParameter[] {
+    const resolvable = this.findAllResolvableParameters(schema);
+
+    // Filter to only include parameters that are actually missing/invalid
+    const errorPaths = new Set(
+      error.issues.map((issue) => issue.path.join(".")),
+    );
+
+    return resolvable.filter((param) => {
+      const paramPath = param.path.join(".");
+      const isErrorPath = errorPaths.has(paramPath);
+      const hasValue =
+        this.getNestedValue(providedParams, param.path) !== undefined;
+
+      // Include if there's an error for this path or if it's required and missing
+      // Also include optional parameters that have resolvers and aren't provided
+      const shouldResolve =
+        isErrorPath ||
+        (param.isRequired && !hasValue) ||
+        (!param.isRequired && !hasValue && param.resolverMeta?.resolver);
+
+      return shouldResolve;
+    });
+  }
+
+  private analyzeSchema(
+    schema: z.ZodType,
+    currentPath: string[],
+    resolvable: ResolvableParameter[],
+  ): void {
+    // Handle different Zod types
+    if (schema instanceof z.ZodObject) {
+      const shape = schema.shape;
+
+      Object.entries(shape).forEach(([key, fieldSchema]) => {
+        const fieldPath = [...currentPath, key];
+        this.analyzeSchemaField(
+          key,
+          fieldSchema as z.ZodType,
+          fieldPath,
+          resolvable,
+        );
+      });
+    } else if (schema instanceof z.ZodOptional) {
+      this.analyzeSchema(schema.unwrap(), currentPath, resolvable);
+    } else if (schema instanceof z.ZodDefault) {
+      this.analyzeSchema(schema.removeDefault(), currentPath, resolvable);
+    }
+  }
+
+  private analyzeSchemaField(
+    name: string,
+    schema: z.ZodType,
+    path: string[],
+    resolvable: ResolvableParameter[],
+  ): void {
+    const resolverMeta = (schema._def as any).resolverMeta;
+
+    if (resolverMeta?.resolver) {
+      resolvable.push({
+        name,
+        path,
+        schema,
+        description: schema.description,
+        resolverMeta,
+        isRequired: !schema.isOptional(),
+      });
+    }
+
+    // Recursively analyze nested objects
+    if (schema instanceof z.ZodObject) {
+      this.analyzeSchema(schema, path, resolvable);
+    } else if (schema instanceof z.ZodOptional) {
+      this.analyzeSchemaField(name, schema.unwrap(), path, resolvable);
+    } else if (schema instanceof z.ZodDefault) {
+      this.analyzeSchemaField(name, schema.removeDefault(), path, resolvable);
+    }
+  }
+
+  private sortByDependencies(
+    parameters: ResolvableParameter[],
+  ): ResolvableParameter[] {
+    // Simple topological sort based on 'depends' field
+    const sorted: ResolvableParameter[] = [];
+    const remaining = [...parameters];
+
+    while (remaining.length > 0) {
+      const canResolve = remaining.filter((param) => {
+        const depends = param.resolverMeta?.resolver?.depends || [];
+        return depends.every((dep: string) =>
+          sorted.some((resolved) => resolved.name === dep),
+        );
+      });
+
+      if (canResolve.length === 0) {
+        // No more resolvable parameters, add remaining ones (circular dependency or no dependencies)
+        sorted.push(...remaining);
+        break;
+      }
+
+      sorted.push(...canResolve);
+      canResolve.forEach((param) => {
+        const index = remaining.indexOf(param);
+        remaining.splice(index, 1);
+      });
+    }
+
+    return sorted;
+  }
+
+  private async resolveParameter(
+    paramInfo: ResolvableParameter,
+    context: ResolverContext,
+  ): Promise<any> {
+    const resolver = paramInfo.resolverMeta?.resolver;
+
+    if (!resolver) {
+      return await this.promptStaticInput(paramInfo);
+    }
+
+    if (resolver.type === "static") {
+      return await this.promptStaticInput(paramInfo, resolver);
+    }
+
+    if (resolver.type === "dynamic") {
+      return await this.resolveDynamicParameter(paramInfo, resolver, context);
+    }
+
+    if (resolver.type === "fields") {
+      return await this.resolveFieldsParameter(paramInfo, resolver, context);
+    }
+
+    throw new Error(`Unknown resolver type: ${resolver.type}`);
+  }
+
+  private async promptStaticInput(
+    paramInfo: ResolvableParameter,
+    resolver?: any,
+  ): Promise<any> {
+    const promptConfig: any = {
+      type:
+        resolver?.inputType === "editor"
+          ? "input"
+          : resolver?.inputType || "input",
+      name: "value",
+      message: `Enter ${paramInfo.description || paramInfo.name}${paramInfo.isRequired ? "" : " (optional)"}:`,
+    };
+
+    // Only use placeholder as default for required parameters
+    if (resolver?.placeholder && paramInfo.isRequired) {
+      promptConfig.default = resolver.placeholder;
+    }
+
+    // Add validation for required parameters
+    if (paramInfo.isRequired) {
+      promptConfig.validate = (input: any) => {
+        if (!input || (typeof input === "string" && input.trim() === "")) {
+          return "This field is required. Please enter a value.";
+        }
+        return true;
+      };
+    }
+
+    // For editor-like prompts, provide helpful instructions
+    if (resolver?.inputType === "editor") {
+      promptConfig.message += " (JSON format)";
+    }
+
+    try {
+      const result = await inquirer.prompt([promptConfig]);
+
+      // For optional parameters, treat empty input as undefined
+      if (
+        !paramInfo.isRequired &&
+        (!result.value || result.value.trim() === "")
+      ) {
+        return undefined;
+      }
+
+      // Try to parse JSON if it looks like JSON
+      if (
+        typeof result.value === "string" &&
+        result.value.trim().startsWith("{")
+      ) {
+        try {
+          return JSON.parse(result.value);
+        } catch {
+          console.warn(
+            chalk.yellow("Warning: Could not parse as JSON, using as string"),
+          );
+          return result.value;
+        }
+      }
+
+      return result.value;
+    } catch (error) {
+      if (this.isUserCancellation(error)) {
+        console.log(chalk.yellow("\n\nOperation cancelled by user"));
+        process.exit(0);
+      }
+      throw error;
+    }
+  }
+
+  private async resolveDynamicParameter(
+    paramInfo: ResolvableParameter,
+    resolver: any,
+    context: ResolverContext,
+  ): Promise<any> {
+    console.log(chalk.gray(`Fetching options for ${paramInfo.name}...`));
+
+    try {
+      // Use the new fetch function approach
+      const options = await resolver.fetch(context.sdk, context.resolvedParams);
+
+      if (options.length === 0) {
+        console.log(chalk.yellow(`No options available for ${paramInfo.name}`));
+        return await this.promptStaticInput(paramInfo);
+      }
+
+      // Generate prompt configuration
+      const promptConfig = resolver.prompt(options, context.resolvedParams);
+
+      // Execute the prompt
+      let result;
+      try {
+        result = await inquirer.prompt([promptConfig]);
+      } catch (error) {
+        if (this.isUserCancellation(error)) {
+          console.log(chalk.yellow("\n\nOperation cancelled by user"));
+          process.exit(0);
+        }
+        throw error;
+      }
+      let value = result[promptConfig.name || "value"];
+
+      // Handle JSON parsing if the value looks like JSON
+      if (typeof value === "string" && value.trim().startsWith("{")) {
+        try {
+          value = JSON.parse(value);
+        } catch {
+          console.warn(
+            chalk.yellow("Warning: Could not parse as JSON, using as string"),
+          );
+        }
+      }
+
+      return value;
+    } catch (error) {
+      if (this.isUserCancellation(error)) {
+        console.log(chalk.yellow("\n\nOperation cancelled by user"));
+        process.exit(0);
+      }
+      if (error instanceof Error && error.message.includes("401")) {
+        console.log(
+          chalk.yellow(
+            `⚠️  Invalid auth token, falling back to manual input for ${paramInfo.name}`,
+          ),
+        );
+      } else {
+        console.error(
+          chalk.red(`Failed to fetch options for ${paramInfo.name}:`),
+          error,
+        );
+        console.log(chalk.yellow("Falling back to manual input..."));
+      }
+      return await this.promptStaticInput(paramInfo);
+    }
+  }
+
+  private async resolveFieldsParameter(
+    paramInfo: ResolvableParameter,
+    resolver: any,
+    context: ResolverContext,
+  ): Promise<any> {
+    console.log(
+      chalk.gray(`Fetching field definitions for ${paramInfo.name}...`),
+    );
+
+    try {
+      // Fetch field definitions using the resolver's fetch function
+      const fields = await resolver.fetch(context.sdk, context.resolvedParams);
+
+      if (fields.length === 0) {
+        console.log(chalk.yellow(`No input fields required for this action`));
+        return {};
+      }
+
+      console.log(
+        chalk.blue(
+          `\nConfiguring inputs for ${context.resolvedParams.app} ${context.resolvedParams.type} ${context.resolvedParams.action}:`,
+        ),
+      );
+
+      const inputs: Record<string, any> = {};
+
+      // Separate required and optional fields
+      const requiredFields = fields.filter((field: any) => field.required);
+      const optionalFields = fields.filter((field: any) => !field.required);
+
+      // First, prompt for all required fields
+      if (requiredFields.length > 0) {
+        console.log(
+          chalk.cyan(`\nRequired fields (${requiredFields.length}):`),
+        );
+        for (const field of requiredFields) {
+          await this.promptForField(field, inputs);
+        }
+      }
+
+      // Then ask if user wants to configure optional fields
+      if (optionalFields.length > 0) {
+        console.log(
+          chalk.gray(
+            `\nThere are ${optionalFields.length} optional field(s) available.`,
+          ),
+        );
+
+        let shouldConfigureOptional;
+        try {
+          shouldConfigureOptional = await inquirer.prompt([
+            {
+              type: "confirm",
+              name: "configure",
+              message: "Would you like to configure optional fields?",
+              default: false,
+            },
+          ]);
+        } catch (error) {
+          if (this.isUserCancellation(error)) {
+            console.log(chalk.yellow("\n\nOperation cancelled by user"));
+            process.exit(0);
+          }
+          throw error;
+        }
+
+        if (shouldConfigureOptional.configure) {
+          console.log(chalk.cyan(`\nOptional fields:`));
+          for (const field of optionalFields) {
+            await this.promptForField(field, inputs);
+          }
+        }
+      }
+
+      return inputs;
+    } catch (error) {
+      if (this.isUserCancellation(error)) {
+        console.log(chalk.yellow("\n\nOperation cancelled by user"));
+        process.exit(0);
+      }
+      console.error(
+        chalk.red(`Failed to fetch field definitions for ${paramInfo.name}:`),
+        error,
+      );
+      console.log(chalk.yellow("Falling back to manual JSON input..."));
+      return await this.promptStaticInput(paramInfo);
+    }
+  }
+
+  private async promptForField(
+    field: any,
+    inputs: Record<string, any>,
+  ): Promise<void> {
+    const fieldPrompt: any = {
+      type: "input",
+      name: field.key,
+      message: `${field.label || field.key}${field.required ? " (required)" : " (optional)"}:`,
+    };
+
+    // Add description/help text if available
+    if (field.help_text || field.description) {
+      fieldPrompt.message += `\n  ${chalk.dim(field.help_text || field.description)}`;
+    }
+
+    // Set default value
+    if (field.default !== undefined) {
+      fieldPrompt.default = field.default;
+    }
+
+    // Add validation for required fields
+    if (field.required) {
+      fieldPrompt.validate = (input: any) => {
+        if (!input || (typeof input === "string" && input.trim() === "")) {
+          return "This field is required. Please enter a value.";
+        }
+        return true;
+      };
+    }
+
+    let result;
+    try {
+      result = await inquirer.prompt([fieldPrompt]);
+    } catch (error) {
+      if (this.isUserCancellation(error)) {
+        console.log(chalk.yellow("\n\nOperation cancelled by user"));
+        process.exit(0);
+      }
+      throw error;
+    }
+
+    // Only include non-empty values
+    if (result[field.key] !== undefined && result[field.key] !== "") {
+      let value = result[field.key];
+
+      // Try to parse as appropriate type
+      if (field.type === "integer" && typeof value === "string") {
+        const parsed = parseInt(value, 10);
+        if (!isNaN(parsed)) value = parsed;
+      } else if (field.type === "number" && typeof value === "string") {
+        const parsed = parseFloat(value);
+        if (!isNaN(parsed)) value = parsed;
+      } else if (field.type === "boolean" && typeof value === "string") {
+        value = value.toLowerCase() === "true" || value === "1";
+      }
+
+      inputs[field.key] = value;
+    }
+  }
+
+  private getNestedValue(obj: any, path: string[]): any {
+    return path.reduce((current, key) => current?.[key], obj);
+  }
+
+  private setNestedValue(obj: any, path: string[], value: any): void {
+    const lastKey = path[path.length - 1];
+    const parentPath = path.slice(0, -1);
+
+    const parent = parentPath.reduce((current, key) => {
+      if (!current[key]) {
+        current[key] = {};
+      }
+      return current[key];
+    }, obj);
+
+    parent[lastKey] = value;
+  }
+
+  private isUserCancellation(error: any): boolean {
+    // Check for various ways user cancellation can be detected
+    return (
+      error &&
+      (error.name === "ExitPromptError" ||
+        error.message?.includes("User force closed the prompt") ||
+        error.message?.includes("SIGINT") ||
+        error.code === "SIGINT" ||
+        error.signal === "SIGINT")
+    );
+  }
+}

package/src/utils/schema-formatter.ts

@@ -0,0 +1,88 @@
+import chalk from "chalk";
+import { z } from "zod";
+import {
+  getFormatMetadata,
+  getOutputSchema,
+  type FormatMetadata,
+} from "../../../actions-sdk/dist/output-schemas";
+
+// ============================================================================
+// Generic Schema-Driven Formatter
+// ============================================================================
+
+export function formatItemsFromSchema(
+  inputSchema: z.ZodType,
+  items: any[],
+): void {
+  // Get the output schema and its format metadata
+  const outputSchema = getOutputSchema(inputSchema);
+  if (!outputSchema) {
+    // Fallback to generic formatting if no output schema
+    formatItemsGeneric(items);
+    return;
+  }
+
+  const formatMeta = getFormatMetadata(outputSchema);
+  if (!formatMeta) {
+    // Fallback to generic formatting if no format metadata
+    formatItemsGeneric(items);
+    return;
+  }
+
+  // Format each item using the schema metadata
+  items.forEach((item, index) => {
+    formatSingleItem(item, index, formatMeta);
+  });
+}
+
+function formatSingleItem(
+  item: any,
+  index: number,
+  formatMeta: FormatMetadata,
+): void {
+  // Get the formatted item from the format function
+  const formatted = formatMeta.format(item);
+
+  // Build the main title line
+  let titleLine = `${chalk.gray(`${index + 1}.`)} ${chalk.cyan(formatted.title)}`;
+  if (formatted.subtitle) {
+    titleLine += ` ${chalk.gray(formatted.subtitle)}`;
+  }
+  console.log(titleLine);
+
+  // Format detail lines
+  for (const detail of formatted.details) {
+    const styledText = applyStyle(detail.text, detail.style);
+    console.log(`   ${styledText}`);
+  }
+
+  console.log(); // Empty line between items
+}
+
+function applyStyle(value: string, style: string): string {
+  switch (style) {
+    case "dim":
+      return chalk.dim(value);
+    case "accent":
+      return chalk.magenta(value);
+    case "warning":
+      return chalk.red(value);
+    case "success":
+      return chalk.green(value);
+    case "normal":
+    default:
+      return chalk.blue(value);
+  }
+}
+
+function formatItemsGeneric(items: any[]): void {
+  // Fallback formatting for items without schema metadata
+  items.forEach((item, index) => {
+    const name = item.name || item.key || item.id || "Item";
+    console.log(`${chalk.gray(`${index + 1}.`)} ${chalk.cyan(name)}`);
+    if (item.description) {
+      console.log(`   ${chalk.dim(item.description)}`);
+    }
+    console.log();
+  });
+}

package/test/cli.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from "vitest";
+import { execSync } from "child_process";
+import path from "path";
+
+describe("Zapier CLI", () => {
+  const cliPath = path.join(__dirname, "../bin/zapier.js");
+
+  it("should show help when called with --help", () => {
+    const output = execSync(`node ${cliPath} --help`, { encoding: "utf8" });
+
+    expect(output).toContain("CLI for Zapier SDK");
+    expect(output).toContain("Commands:");
+    expect(output).toContain("browse");
+  });
+
+  it("should show browse help when called with browse --help", () => {
+    const output = execSync(`node ${cliPath} browse --help`, {
+      encoding: "utf8",
+    });
+
+    expect(output).toContain("Browse available apps and actions");
+    expect(output).toContain("apps");
+    expect(output).toContain("actions");
+  });
+
+  it("should show browse apps help when called with browse apps --help", () => {
+    const output = execSync(`node ${cliPath} browse apps --help`, {
+      encoding: "utf8",
+    });
+
+    expect(output).toContain("List all available apps");
+    expect(output).toContain("--category");
+    expect(output).toContain("--limit");
+  });
+
+  it("should show browse actions help when called with browse actions --help", () => {
+    const output = execSync(`node ${cliPath} browse actions --help`, {
+      encoding: "utf8",
+    });
+
+    expect(output).toContain("List available actions");
+    expect(output).toContain("--app");
+    expect(output).toContain("--type");
+    expect(output).toContain("--limit");
+  });
+});

package/tsconfig.build.json

@@ -0,0 +1,6 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "paths": {}
+  }
+}