@zapier/zapier-sdk-cli 0.1.0 → 0.2.0

package/dist/utils/cli-generator.js

@@ -1,16 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateCliCommands = generateCliCommands;
-const zod_1 = require("zod");
-const zapier_sdk_1 = require("@zapier/zapier-sdk");
-const parameter_resolver_1 = require("./parameter-resolver");
-const pager_1 = require("./pager");
-const schema_formatter_1 = require("./schema-formatter");
-const chalk_1 = __importDefault(require("chalk"));
-const util_1 = __importDefault(require("util"));
+import { z } from "zod";
+import { hasResolver, isPositional } from "@zapier/zapier-sdk";
+import { SchemaParameterResolver } from "./parameter-resolver";
+import { createPager } from "./pager";
+import { formatItemsFromSchema } from "./schema-formatter";
+import chalk from "chalk";
+import util from "util";
 // ============================================================================
 // JSON Formatting
 // ============================================================================
@@ -20,17 +14,17 @@ function formatJsonOutput(data) {
         typeof data === "object" &&
         !Array.isArray(data) &&
         (data.success !== undefined || data.id || data.status)) {
-        console.log(chalk_1.default.green("✅ Action completed successfully!\n"));
+        console.log(chalk.green("✅ Action completed successfully!\n"));
     }
     // Use util.inspect for colored output
-    console.log(util_1.default.inspect(data, { colors: true, depth: null, breakLength: 80 }));
+    console.log(util.inspect(data, { colors: true, depth: null, breakLength: 80 }));
 }
 // ============================================================================
 // Schema Analysis
 // ============================================================================
 function analyzeZodSchema(schema) {
     const parameters = [];
-    if (schema instanceof zod_1.z.ZodObject) {
+    if (schema instanceof z.ZodObject) {
         const shape = schema.shape;
         for (const [key, fieldSchema] of Object.entries(shape)) {
             const param = analyzeZodField(key, fieldSchema);
@@ -46,11 +40,11 @@ function analyzeZodField(name, schema) {
     let required = true;
     let defaultValue = undefined;
     // Unwrap optional and default wrappers
-    if (baseSchema instanceof zod_1.z.ZodOptional) {
+    if (baseSchema instanceof z.ZodOptional) {
         required = false;
         baseSchema = baseSchema._def.innerType;
     }
-    if (baseSchema instanceof zod_1.z.ZodDefault) {
+    if (baseSchema instanceof z.ZodDefault) {
         required = false;
         defaultValue = baseSchema._def.defaultValue();
         baseSchema = baseSchema._def.innerType;
@@ -58,23 +52,23 @@ function analyzeZodField(name, schema) {
     // Determine parameter type
     let paramType = "string";
     let choices;
-    if (baseSchema instanceof zod_1.z.ZodString) {
+    if (baseSchema instanceof z.ZodString) {
         paramType = "string";
     }
-    else if (baseSchema instanceof zod_1.z.ZodNumber) {
+    else if (baseSchema instanceof z.ZodNumber) {
         paramType = "number";
     }
-    else if (baseSchema instanceof zod_1.z.ZodBoolean) {
+    else if (baseSchema instanceof z.ZodBoolean) {
         paramType = "boolean";
     }
-    else if (baseSchema instanceof zod_1.z.ZodArray) {
+    else if (baseSchema instanceof z.ZodArray) {
         paramType = "array";
     }
-    else if (baseSchema instanceof zod_1.z.ZodEnum) {
+    else if (baseSchema instanceof z.ZodEnum) {
         paramType = "string";
         choices = baseSchema._def.values;
     }
-    else if (baseSchema instanceof zod_1.z.ZodRecord) {
+    else if (baseSchema instanceof z.ZodRecord) {
         // Handle Record<string, any> as JSON string input
         paramType = "string";
     }
@@ -86,7 +80,8 @@ function analyzeZodField(name, schema) {
         description: schema.description,
         default: defaultValue,
         choices,
-        hasResolver: (0, zapier_sdk_1.hasResolver)(name),
+        hasResolver: hasResolver(name),
+        isPositional: isPositional(schema),
     };
 }
 // ============================================================================
@@ -109,7 +104,7 @@ function methodNameToCliCommand(methodName) {
 // ============================================================================
 // CLI Command Generation - Completely Generic
 // ============================================================================
-function generateCliCommands(program, sdk) {
+export function generateCliCommands(program, sdk) {
     // Check if SDK has registry
     if (!sdk.__registry) {
         console.error("SDK registry not available");
@@ -144,7 +139,7 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
             // Convert CLI args to SDK method parameters
             const rawParams = convertCliArgsToSdkParams(parameters, args.slice(0, -1), options);
             // Resolve missing parameters interactively using schema metadata
-            const resolver = new parameter_resolver_1.SchemaParameterResolver();
+            const resolver = new SchemaParameterResolver();
             const resolvedParams = await resolver.resolveParameters(schema, rawParams, sdk);
             if (shouldUsePaging && !shouldUseJson) {
                 // Use interactive paging for list commands
@@ -171,8 +166,8 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
                 }
                 else if (hasOutputFile) {
                     // Show success message for file output instead of printing generated content
-                    console.log(chalk_1.default.green(`✅ ${cliCommandName} completed successfully!`));
-                    console.log(chalk_1.default.gray(`Output written to: ${resolvedParams.output}`));
+                    console.log(chalk.green(`✅ ${cliCommandName} completed successfully!`));
+                    console.log(chalk.gray(`Output written to: ${resolvedParams.output}`));
                 }
             }
         }
@@ -181,19 +176,19 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
             if (error instanceof Error && error.message.includes('"code"')) {
                 try {
                     const validationErrors = JSON.parse(error.message);
-                    console.error(chalk_1.default.red("❌ Validation Error:"));
+                    console.error(chalk.red("❌ Validation Error:"));
                     validationErrors.forEach((err) => {
                         const field = err.path?.join(".") || "unknown";
-                        console.error(chalk_1.default.yellow(`  • ${field}: ${err.message}`));
+                        console.error(chalk.yellow(`  • ${field}: ${err.message}`));
                     });
-                    console.error("\n" + chalk_1.default.dim(`Use --help to see available options`));
+                    console.error("\n" + chalk.dim(`Use --help to see available options`));
                 }
                 catch {
-                    console.error(chalk_1.default.red("Error:"), error.message);
+                    console.error(chalk.red("Error:"), error.message);
                 }
             }
             else {
-                console.error(chalk_1.default.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+                console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
             }
             process.exit(1);
         }
@@ -218,6 +213,10 @@ function addCommand(program, commandName, config) {
             // Required parameters without resolvers become required positional arguments
             command.argument(`<${kebabName}>`, param.description || `${kebabName} parameter`);
         }
+        else if (param.isPositional) {
+            // Optional parameters marked as positional become optional positional arguments
+            command.argument(`[${kebabName}]`, param.description || `${kebabName} parameter`);
+        }
         else {
             // Optional parameters become flags (whether they have resolvers or not)
             const flags = [`--${kebabName}`];
@@ -239,10 +238,11 @@ function addCommand(program, commandName, config) {
 // ============================================================================
 function convertCliArgsToSdkParams(parameters, positionalArgs, options) {
     const sdkParams = {};
-    // Handle positional arguments (required parameters only, whether they have resolvers or not)
+    // Handle positional arguments (required parameters or optional positional parameters)
     let argIndex = 0;
     parameters.forEach((param) => {
-        if (param.required && argIndex < positionalArgs.length) {
+        if ((param.required || param.isPositional) &&
+            argIndex < positionalArgs.length) {
             // Use the original camelCase parameter name for the SDK
             sdkParams[param.name] = convertValue(positionalArgs[argIndex], param.type);
             argIndex++;
@@ -288,8 +288,8 @@ function convertValue(value, type) {
 async function handlePaginatedList(sdkMethodName, baseParams, sdk, schema) {
     const limit = baseParams.limit || 20;
     const itemName = getItemNameFromMethod(sdkMethodName);
-    console.log(chalk_1.default.blue(`📋 Fetching ${itemName}...`));
-    const pager = (0, pager_1.createPager)({
+    console.log(chalk.blue(`📋 Fetching ${itemName}...`));
+    const pager = createPager({
         pageSize: Math.min(limit, 20),
         itemName,
     });
@@ -298,14 +298,14 @@ async function handlePaginatedList(sdkMethodName, baseParams, sdk, schema) {
         if (items.length > 0) {
             console.clear();
         }
-        console.log(chalk_1.default.blue(`📋 ${getListTitleFromMethod(sdkMethodName)}\n`));
+        console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName)}\n`));
         if (items.length === 0) {
-            console.log(chalk_1.default.yellow(`No ${itemName} found.`));
+            console.log(chalk.yellow(`No ${itemName} found.`));
             return;
         }
         // Use schema for formatting
         if (schema) {
-            (0, schema_formatter_1.formatItemsFromSchema)(schema, items);
+            formatItemsFromSchema(schema, items);
         }
         else {
             // Fallback to generic formatting
@@ -314,7 +314,7 @@ async function handlePaginatedList(sdkMethodName, baseParams, sdk, schema) {
         const totalInfo = totalAvailable
             ? ` of ${totalAvailable.toLocaleString()} total`
             : "";
-        console.log(chalk_1.default.green(`\n✅ Showing ${totalShown}${totalInfo} ${itemName}`));
+        console.log(chalk.green(`\n✅ Showing ${totalShown}${totalInfo} ${itemName}`));
     };
     await pager.paginate((params) => sdk[sdkMethodName]({
         ...baseParams,
@@ -337,13 +337,13 @@ function formatNonPaginatedResults(result, requestedLimit, userSpecifiedLimit, u
     }
     const itemName = methodName ? getItemNameFromMethod(methodName) : "items";
     if (result.length === 0) {
-        console.log(chalk_1.default.yellow(`No ${itemName} found.`));
+        console.log(chalk.yellow(`No ${itemName} found.`));
         return;
     }
-    console.log(chalk_1.default.green(`\n✅ Found ${result.length} ${itemName}:\n`));
+    console.log(chalk.green(`\n✅ Found ${result.length} ${itemName}:\n`));
     // Use schema for formatting
     if (schema) {
-        (0, schema_formatter_1.formatItemsFromSchema)(schema, result);
+        formatItemsFromSchema(schema, result);
     }
     else {
         // Fallback to generic formatting
@@ -351,19 +351,19 @@ function formatNonPaginatedResults(result, requestedLimit, userSpecifiedLimit, u
     }
     // Show appropriate status message
     if (userSpecifiedLimit && requestedLimit) {
-        console.log(chalk_1.default.gray(`\n📄 Showing up to ${requestedLimit} ${itemName} (--limit ${requestedLimit})`));
+        console.log(chalk.gray(`\n📄 Showing up to ${requestedLimit} ${itemName} (--limit ${requestedLimit})`));
     }
     else {
-        console.log(chalk_1.default.gray(`\n📄 All available ${itemName} shown`));
+        console.log(chalk.gray(`\n📄 All available ${itemName} shown`));
     }
 }
 function formatItemsGeneric(items) {
     // Fallback formatting for items without schema metadata
     items.forEach((item, index) => {
         const name = item.name || item.key || item.id || "Item";
-        console.log(`${chalk_1.default.gray(`${index + 1}.`)} ${chalk_1.default.cyan(name)}`);
+        console.log(`${chalk.gray(`${index + 1}.`)} ${chalk.cyan(name)}`);
         if (item.description) {
-            console.log(`   ${chalk_1.default.dim(item.description)}`);
+            console.log(`   ${chalk.dim(item.description)}`);
         }
         console.log();
     });

package/dist/utils/config.d.ts

@@ -0,0 +1,2 @@
+import Conf from "conf";
+export declare const config: Conf<Record<string, unknown>>;

package/dist/utils/config.js

@@ -0,0 +1,2 @@
+import Conf from "conf";
+export const config = new Conf({ projectName: "zapier-sdk-cli" });

package/dist/utils/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const ZAPIER_BASE = "https://zapier.com";
+export declare const LOGIN_CLIENT_ID = "K5eEnRE9TTmSFATdkkWhKF8NOKwoiOnYAyIqJjae";
+export declare const LOGIN_PORTS: number[];
+export declare const LOGIN_TIMEOUT_MS = 300000;
+export declare const AUTH_MODE_HEADER = "X-Auth";

package/dist/utils/constants.js

@@ -0,0 +1,6 @@
+export const ZAPIER_BASE = "https://zapier.com";
+// OAuth client ID for zapier-sdk CLI
+export const LOGIN_CLIENT_ID = "K5eEnRE9TTmSFATdkkWhKF8NOKwoiOnYAyIqJjae";
+export const LOGIN_PORTS = [49505, 50575, 52804, 55981, 61010, 63851];
+export const LOGIN_TIMEOUT_MS = 300000; // 5 minutes
+export const AUTH_MODE_HEADER = "X-Auth";

package/dist/utils/getCallablePromise.d.ts

@@ -0,0 +1,6 @@
+declare const getCallablePromise: <T>() => {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (reason: unknown) => void;
+};
+export default getCallablePromise;

package/dist/utils/getCallablePromise.js

@@ -0,0 +1,14 @@
+const getCallablePromise = () => {
+    let resolve = () => { };
+    let reject = () => { };
+    const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+    });
+    return {
+        promise,
+        resolve,
+        reject,
+    };
+};
+export default getCallablePromise;

package/dist/utils/getConfigPath.d.ts

@@ -0,0 +1 @@
+export declare const getConfigPath: () => string;

package/dist/utils/getConfigPath.js

@@ -0,0 +1,4 @@
+import { config } from "./config";
+export const getConfigPath = () => {
+    return config.path;
+};

package/dist/utils/log.d.ts

@@ -0,0 +1,7 @@
+declare const log: {
+    info: (message: string, ...args: any[]) => void;
+    error: (message: string, ...args: any[]) => void;
+    success: (message: string, ...args: any[]) => void;
+    warn: (message: string, ...args: any[]) => void;
+};
+export default log;

package/dist/utils/log.js

@@ -0,0 +1,16 @@
+import chalk from "chalk";
+const log = {
+    info: (message, ...args) => {
+        console.log(chalk.blue("ℹ"), message, ...args);
+    },
+    error: (message, ...args) => {
+        console.error(chalk.red("✖"), message, ...args);
+    },
+    success: (message, ...args) => {
+        console.log(chalk.green("✓"), message, ...args);
+    },
+    warn: (message, ...args) => {
+        console.log(chalk.yellow("⚠"), message, ...args);
+    },
+};
+export default log;

package/dist/utils/pager.js

@@ -1,19 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Pager = void 0;
-exports.createPager = createPager;
-exports.fetchAllPages = fetchAllPages;
-exports.showPaginationStatus = showPaginationStatus;
-const inquirer_1 = __importDefault(require("inquirer"));
-const chalk_1 = __importDefault(require("chalk"));
+import inquirer from "inquirer";
+import chalk from "chalk";
 /**
  * Generic pager that handles pagination for any data source
  * Supports interactive "load more" functionality
  */
-class Pager {
+export class Pager {
     constructor(options = {}) {
         this.allItems = [];
         this.currentOffset = 0;
@@ -67,7 +58,7 @@ class Pager {
                     : "";
                 const message = `Load more ${this.itemName}? (${this.allItems.length}${totalInfo} shown so far)`;
                 // Ask user if they want to load more
-                const { loadMore } = await inquirer_1.default.prompt([
+                const { loadMore } = await inquirer.prompt([
                     {
                         type: "confirm",
                         name: "loadMore",
@@ -98,17 +89,16 @@ class Pager {
         this.currentOffset = 0;
     }
 }
-exports.Pager = Pager;
 /**
  * Convenience function to create a pager for a specific use case
  */
-function createPager(options = {}) {
+export function createPager(options = {}) {
     return new Pager(options);
 }
 /**
  * Simple pagination without interactivity - just fetches all results up to a limit
  */
-async function fetchAllPages(fetchFunction, baseParams, maxResults = 100) {
+export async function fetchAllPages(fetchFunction, baseParams, maxResults = 100) {
     const pageSize = Math.min(maxResults, 50); // Reasonable page size
     const allItems = [];
     let offset = 0;
@@ -136,12 +126,12 @@ async function fetchAllPages(fetchFunction, baseParams, maxResults = 100) {
 /**
  * Display helper for showing pagination status
  */
-function showPaginationStatus(currentCount, requestedLimit, itemName = "items") {
+export function showPaginationStatus(currentCount, requestedLimit, itemName = "items") {
     if (currentCount >= requestedLimit) {
-        console.log(chalk_1.default.yellow(`\n📄 Showing first ${currentCount} ${itemName} (limit: ${requestedLimit})`));
-        console.log(chalk_1.default.gray(`Use --limit to increase the limit, or add paging with --page`));
+        console.log(chalk.yellow(`\n📄 Showing first ${currentCount} ${itemName} (limit: ${requestedLimit})`));
+        console.log(chalk.gray(`Use --limit to increase the limit, or add paging with --page`));
     }
     else {
-        console.log(chalk_1.default.gray(`\n📄 Showing all ${currentCount} ${itemName}`));
+        console.log(chalk.gray(`\n📄 Showing all ${currentCount} ${itemName}`));
     }
 }

package/dist/utils/parameter-resolver.js

@@ -1,23 +1,17 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaParameterResolver = void 0;
-const inquirer_1 = __importDefault(require("inquirer"));
-const chalk_1 = __importDefault(require("chalk"));
-const zod_1 = require("zod");
-const zapier_sdk_1 = require("@zapier/zapier-sdk");
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { z } from "zod";
+import { getResolver, hasResolver, getResolutionOrderForParams, } from "@zapier/zapier-sdk";
 // ============================================================================
 // Schema Parameter Resolver
 // ============================================================================
-class SchemaParameterResolver {
+export class SchemaParameterResolver {
     async resolveParameters(schema, providedParams, sdk) {
         // 1. Try to parse with current parameters
         const parseResult = schema.safeParse(providedParams);
         // Get all schema parameters to check which ones have resolvers
         const allParams = this.extractParametersFromSchema(schema);
-        const resolvableParams = allParams.filter((param) => (0, zapier_sdk_1.hasResolver)(param.name));
+        const resolvableParams = allParams.filter((param) => hasResolver(param.name));
         // Get all missing parameters that have resolvers
         const missingResolvable = resolvableParams.filter((param) => {
             const hasValue = this.getNestedValue(providedParams, param.path) !== undefined;
@@ -57,7 +51,7 @@ class SchemaParameterResolver {
         };
         if (functionallyRequired.length > 0) {
             const requiredParamNames = functionallyRequired.map((p) => p.name);
-            const requiredResolutionOrder = (0, zapier_sdk_1.getResolutionOrderForParams)(requiredParamNames);
+            const requiredResolutionOrder = getResolutionOrderForParams(requiredParamNames);
             const orderedRequiredParams = requiredResolutionOrder
                 .map((paramName) => functionallyRequired.find((p) => p.name === paramName))
                 .filter((param) => param !== undefined);
@@ -70,10 +64,10 @@ class SchemaParameterResolver {
                 }
                 catch (error) {
                     if (this.isUserCancellation(error)) {
-                        console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
+                        console.log(chalk.yellow("\n\nOperation cancelled by user"));
                         process.exit(0);
                     }
-                    console.error(chalk_1.default.red(`Failed to resolve ${param.name}:`), error);
+                    console.error(chalk.red(`Failed to resolve ${param.name}:`), error);
                     throw error;
                 }
             }
@@ -81,7 +75,7 @@ class SchemaParameterResolver {
         // 3. Ask user if they want to resolve truly optional parameters
         if (trulyOptional.length > 0) {
             const optionalNames = trulyOptional.map((p) => p.name).join(", ");
-            const shouldResolveOptional = await inquirer_1.default.prompt([
+            const shouldResolveOptional = await inquirer.prompt([
                 {
                     type: "confirm",
                     name: "resolveOptional",
@@ -92,7 +86,7 @@ class SchemaParameterResolver {
             if (shouldResolveOptional.resolveOptional) {
                 // Resolve optional parameters using their resolvers
                 const optionalParamNames = trulyOptional.map((p) => p.name);
-                const optionalResolutionOrder = (0, zapier_sdk_1.getResolutionOrderForParams)(optionalParamNames);
+                const optionalResolutionOrder = getResolutionOrderForParams(optionalParamNames);
                 const orderedOptionalParams = optionalResolutionOrder
                     .map((paramName) => trulyOptional.find((p) => p.name === paramName))
                     .filter((param) => param !== undefined);
@@ -105,10 +99,10 @@ class SchemaParameterResolver {
                     }
                     catch (error) {
                         if (this.isUserCancellation(error)) {
-                            console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
+                            console.log(chalk.yellow("\n\nOperation cancelled by user"));
                             process.exit(0);
                         }
-                        console.error(chalk_1.default.red(`Failed to resolve ${param.name}:`), error);
+                        console.error(chalk.red(`Failed to resolve ${param.name}:`), error);
                         throw error;
                     }
                 }
@@ -117,7 +111,7 @@ class SchemaParameterResolver {
         // 3. Validate final parameters
         const finalResult = schema.safeParse(resolvedParams);
         if (!finalResult.success) {
-            console.error(chalk_1.default.red("❌ Parameter validation failed after resolution:"));
+            console.error(chalk.red("❌ Parameter validation failed after resolution:"));
             throw finalResult.error;
         }
         return finalResult.data;
@@ -125,7 +119,7 @@ class SchemaParameterResolver {
     extractParametersFromSchema(schema) {
         const parameters = [];
         // Only handle ZodObject at the top level
-        if (schema instanceof zod_1.z.ZodObject) {
+        if (schema instanceof z.ZodObject) {
             const shape = schema.shape;
             for (const [key, fieldSchema] of Object.entries(shape)) {
                 const param = this.analyzeFieldSchema(key, fieldSchema);
@@ -140,11 +134,11 @@ class SchemaParameterResolver {
         let baseSchema = fieldSchema;
         let isRequired = true;
         // Check if field is optional or has default
-        if (baseSchema instanceof zod_1.z.ZodOptional) {
+        if (baseSchema instanceof z.ZodOptional) {
             isRequired = false;
             baseSchema = baseSchema._def.innerType;
         }
-        if (baseSchema instanceof zod_1.z.ZodDefault) {
+        if (baseSchema instanceof z.ZodDefault) {
             isRequired = false;
             baseSchema = baseSchema._def.innerType;
         }
@@ -163,11 +157,11 @@ class SchemaParameterResolver {
         };
     }
     async resolveParameter(param, context) {
-        const resolver = (0, zapier_sdk_1.getResolver)(param.name);
+        const resolver = getResolver(param.name);
         if (!resolver) {
             throw new Error(`No resolver found for parameter: ${param.name}`);
         }
-        console.log(chalk_1.default.blue(`\n🔍 Resolving ${param.name}...`));
+        console.log(chalk.blue(`\n🔍 Resolving ${param.name}...`));
         if (resolver.type === "static") {
             // Static resolver - just prompt for input
             const promptConfig = {
@@ -176,33 +170,33 @@ class SchemaParameterResolver {
                 message: `Enter ${param.name}:`,
                 ...(resolver.placeholder && { default: resolver.placeholder }),
             };
-            const answers = await inquirer_1.default.prompt([promptConfig]);
+            const answers = await inquirer.prompt([promptConfig]);
             return answers[param.name];
         }
         else if (resolver.type === "dynamic") {
             // Dynamic resolver - fetch options and prompt for selection
             try {
-                console.log(chalk_1.default.gray(`Fetching options for ${param.name}...`));
+                console.log(chalk.gray(`Fetching options for ${param.name}...`));
                 const items = await resolver.fetch(context.sdk, context.resolvedParams);
                 if (!items || items.length === 0) {
                     throw new Error(`No options available for ${param.name}`);
                 }
                 const promptConfig = resolver.prompt(items, context.resolvedParams);
-                const answers = await inquirer_1.default.prompt([promptConfig]);
+                const answers = await inquirer.prompt([promptConfig]);
                 return answers[param.name];
             }
             catch (error) {
-                console.error(chalk_1.default.red(`Failed to fetch options for ${param.name}:`), error instanceof Error ? error.message : error);
+                console.error(chalk.red(`Failed to fetch options for ${param.name}:`), error instanceof Error ? error.message : error);
                 throw error;
             }
         }
         else if (resolver.type === "fields") {
             // Fields resolver - fetch field definitions and prompt for each input
             try {
-                console.log(chalk_1.default.gray(`Fetching input fields for ${param.name}...`));
+                console.log(chalk.gray(`Fetching input fields for ${param.name}...`));
                 const fields = await resolver.fetch(context.sdk, context.resolvedParams);
                 if (!fields || fields.length === 0) {
-                    console.log(chalk_1.default.yellow(`No input fields required for this action.`));
+                    console.log(chalk.yellow(`No input fields required for this action.`));
                     return {};
                 }
                 const inputs = {};
@@ -211,17 +205,17 @@ class SchemaParameterResolver {
                 const optionalFields = fields.filter((field) => !field.required);
                 // First, prompt for all required fields
                 if (requiredFields.length > 0) {
-                    console.log(chalk_1.default.blue(`\n📝 Please provide values for the following input fields:`));
+                    console.log(chalk.blue(`\n📝 Please provide values for the following input fields:`));
                     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_1.default.gray(`\nThere are ${optionalFields.length} optional field(s) available.`));
+                    console.log(chalk.gray(`\nThere are ${optionalFields.length} optional field(s) available.`));
                     let shouldConfigureOptional;
                     try {
-                        shouldConfigureOptional = await inquirer_1.default.prompt([
+                        shouldConfigureOptional = await inquirer.prompt([
                             {
                                 type: "confirm",
                                 name: "configure",
@@ -232,13 +226,13 @@ class SchemaParameterResolver {
                     }
                     catch (error) {
                         if (this.isUserCancellation(error)) {
-                            console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
+                            console.log(chalk.yellow("\n\nOperation cancelled by user"));
                             process.exit(0);
                         }
                         throw error;
                     }
                     if (shouldConfigureOptional.configure) {
-                        console.log(chalk_1.default.cyan(`\nOptional fields:`));
+                        console.log(chalk.cyan(`\nOptional fields:`));
                         for (const field of optionalFields) {
                             await this.promptForField(field, inputs);
                         }
@@ -247,7 +241,7 @@ class SchemaParameterResolver {
                 return inputs;
             }
             catch (error) {
-                console.error(chalk_1.default.red(`Failed to fetch fields for ${param.name}:`), error instanceof Error ? error.message : error);
+                console.error(chalk.red(`Failed to fetch fields for ${param.name}:`), error instanceof Error ? error.message : error);
                 throw error;
             }
         }
@@ -271,7 +265,7 @@ class SchemaParameterResolver {
             type: field.type === "boolean" ? "confirm" : "input",
             name: field.key,
             message: `${field.label || field.key}${field.required ? " (required)" : " (optional)"}:`,
-            ...(field.helpText && { prefix: chalk_1.default.gray(`ℹ ${field.helpText}\n`) }),
+            ...(field.helpText && { prefix: chalk.gray(`ℹ ${field.helpText}\n`) }),
             ...(field.default && { default: field.default }),
         };
         if (field.choices && field.choices.length > 0) {
@@ -282,7 +276,7 @@ class SchemaParameterResolver {
             }));
         }
         try {
-            const answer = await inquirer_1.default.prompt([fieldPrompt]);
+            const answer = await inquirer.prompt([fieldPrompt]);
             if (answer[field.key] !== undefined && answer[field.key] !== "") {
                 inputs[field.key] = answer[field.key];
             }
@@ -292,7 +286,7 @@ class SchemaParameterResolver {
         }
         catch (error) {
             if (this.isUserCancellation(error)) {
-                console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
+                console.log(chalk.yellow("\n\nOperation cancelled by user"));
                 process.exit(0);
             }
             throw error;
@@ -304,4 +298,3 @@ class SchemaParameterResolver {
             error?.isTTYError);
     }
 }
-exports.SchemaParameterResolver = SchemaParameterResolver;