@zapier/zapier-sdk-cli 0.1.1 → 0.2.1

package/dist/cli.js

@@ -1,10 +1,9 @@
 #!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const commander_1 = require("commander");
-const zapier_sdk_1 = require("@zapier/zapier-sdk");
-const cli_generator_1 = require("./utils/cli-generator");
-const program = new commander_1.Command();
+import { Command } from "commander";
+import { createZapierSdk } from "@zapier/zapier-sdk";
+import { generateCliCommands } from "./utils/cli-generator";
+import { createLoginCommand, createLogoutCommand, createWhoamiCommand, createConfigPathCommand, } from "./commands";
+const program = new Command();
 program
     .name("zapier-sdk")
     .description("CLI for Zapier SDK - Commands auto-generated from SDK schemas")
@@ -12,12 +11,15 @@ program
     .option("--debug", "Enable debug logging");
 // Check for debug flag early
 const isDebugMode = process.env.DEBUG === "true" || process.argv.includes("--debug");
-// Create SDK instance for CLI operations
-// Auth will be resolved from environment variables or command options
-const sdk = (0, zapier_sdk_1.createZapierSdk)({
-    // Token will be picked up from ZAPIER_TOKEN env var or provided via options
+// Create SDK instance - automatically handles token resolution
+const sdk = createZapierSdk({
     debug: isDebugMode,
 });
+// Add auth commands before generating SDK commands
+program.addCommand(createLoginCommand());
+program.addCommand(createLogoutCommand());
+program.addCommand(createWhoamiCommand());
+program.addCommand(createConfigPathCommand());
 // Generate CLI commands from SDK schemas
-(0, cli_generator_1.generateCliCommands)(program, sdk);
+generateCliCommands(program, sdk);
 program.parse();

package/dist/commands/configPath.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createConfigPathCommand(): Command;

package/dist/commands/configPath.js

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+import { getConfigPath } from "@zapier/zapier-sdk";
+export function createConfigPathCommand() {
+    return new Command("get-config-path")
+        .description("Show the path to the configuration file")
+        .action(async () => {
+        console.log(`Configuration file: ${getConfigPath()}`);
+    });
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,4 @@
+export { createLoginCommand } from "./login";
+export { createLogoutCommand } from "./logout";
+export { createWhoamiCommand } from "./whoami";
+export { createConfigPathCommand } from "./configPath";

package/dist/commands/index.js

@@ -0,0 +1,4 @@
+export { createLoginCommand } from "./login";
+export { createLogoutCommand } from "./logout";
+export { createWhoamiCommand } from "./whoami";
+export { createConfigPathCommand } from "./configPath";

package/dist/commands/login.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createLoginCommand(): Command;

package/dist/commands/login.js

@@ -0,0 +1,25 @@
+import { Command } from "commander";
+import login from "../utils/auth/login";
+import { getLoggedInUser } from "@zapier/zapier-sdk";
+export function createLoginCommand() {
+    return new Command("login")
+        .description("Log in to Zapier to access your account")
+        .option("--timeout <seconds>", "Login timeout in seconds (default: 300)", "300")
+        .action(async (options) => {
+        try {
+            const timeoutSeconds = parseInt(options.timeout, 10);
+            if (isNaN(timeoutSeconds) || timeoutSeconds <= 0) {
+                throw new Error("Timeout must be a positive number");
+            }
+            await login(timeoutSeconds * 1000); // Convert to milliseconds
+            const user = await getLoggedInUser();
+            console.log(`✅ Successfully logged in as ${user.email}`);
+            // Force immediate exit to prevent hanging (especially in development with tsx)
+            setTimeout(() => process.exit(0), 100);
+        }
+        catch (error) {
+            console.error("❌ Login failed:", error instanceof Error ? error.message : "Unknown error");
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createLogoutCommand(): Command;

package/dist/commands/logout.js

@@ -0,0 +1,16 @@
+import { Command } from "commander";
+import { logout } from "@zapier/zapier-sdk";
+export function createLogoutCommand() {
+    return new Command("logout")
+        .description("Log out of your Zapier account")
+        .action(async () => {
+        try {
+            logout();
+            console.log("✅ Successfully logged out");
+        }
+        catch (error) {
+            console.error("❌ Logout failed:", error instanceof Error ? error.message : "Unknown error");
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/whoami.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createWhoamiCommand(): Command;

package/dist/commands/whoami.js

@@ -0,0 +1,17 @@
+import { Command } from "commander";
+import { getLoggedInUser } from "@zapier/zapier-sdk";
+import { spinPromise } from "../utils/spinner";
+export function createWhoamiCommand() {
+    return new Command("whoami")
+        .description("Show current login status and user information")
+        .action(async () => {
+        try {
+            const user = await spinPromise(getLoggedInUser(), "Checking login status...");
+            console.log(`✅ Logged in as ${user.email} (Account ID: ${user.accountId})`);
+        }
+        catch {
+            console.log("❌ Not logged in. Use 'zapier-sdk login' to authenticate.");
+            process.exit(1);
+        }
+    });
+}

package/dist/utils/api/client.d.ts

@@ -0,0 +1,15 @@
+export interface ApiResponse<T = any> {
+    data: T;
+    status: number;
+}
+export declare const createApiClient: () => {
+    post: <T = any>(url: string, data: any, options?: {
+        headers?: Record<string, string>;
+    }) => Promise<ApiResponse<T>>;
+};
+declare const api: {
+    post: <T = any>(url: string, data: any, options?: {
+        headers?: Record<string, string>;
+    }) => Promise<ApiResponse<T>>;
+};
+export default api;

package/dist/utils/api/client.js

@@ -0,0 +1,27 @@
+export const createApiClient = () => {
+    const post = async (url, data, options = {}) => {
+        const { headers = {} } = options;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+                Connection: "close",
+                ...headers,
+            },
+            body: new URLSearchParams(data),
+        });
+        if (!response.ok) {
+            throw new Error(`${response.status} ${response.statusText}`);
+        }
+        const responseData = await response.json();
+        return {
+            data: responseData,
+            status: response.status,
+        };
+    };
+    return {
+        post,
+    };
+};
+const api = createApiClient();
+export default api;

package/dist/utils/auth/login.d.ts

@@ -0,0 +1,2 @@
+declare const login: (timeoutMs?: number) => Promise<string>;
+export default login;

package/dist/utils/auth/login.js

@@ -0,0 +1,134 @@
+import open from "open";
+import crypto from "node:crypto";
+import express from "express";
+import pkceChallenge from "pkce-challenge";
+import { AUTH_MODE_HEADER, LOGIN_CLIENT_ID, LOGIN_PORTS, LOGIN_TIMEOUT_MS, ZAPIER_BASE, } from "../constants";
+import { spinPromise } from "../spinner";
+import log from "../log";
+import api from "../api/client";
+import getCallablePromise from "../getCallablePromise";
+import { updateLogin, logout } from "@zapier/zapier-sdk";
+const findAvailablePort = () => {
+    return new Promise((resolve, reject) => {
+        let portIndex = 0;
+        const tryPort = (port) => {
+            const server = express().listen(port, () => {
+                server.close();
+                resolve(port);
+            });
+            server.on("error", (err) => {
+                if (err.code === "EADDRINUSE") {
+                    if (portIndex < LOGIN_PORTS.length) {
+                        // Try next predefined port
+                        tryPort(LOGIN_PORTS[portIndex++]);
+                    }
+                    else {
+                        // All configured ports are busy
+                        reject(new Error(`All configured OAuth callback ports are busy: ${LOGIN_PORTS.join(", ")}. Please try again later or close applications using these ports.`));
+                    }
+                }
+                else {
+                    reject(err);
+                }
+            });
+        };
+        if (LOGIN_PORTS.length > 0) {
+            tryPort(LOGIN_PORTS[portIndex++]);
+        }
+        else {
+            reject(new Error("No OAuth callback ports configured"));
+        }
+    });
+};
+const generateRandomString = () => {
+    const array = new Uint32Array(28);
+    crypto.getRandomValues(array);
+    return Array.from(array, (dec) => ("0" + dec.toString(16)).substring(-2)).join("");
+};
+const login = async (timeoutMs = LOGIN_TIMEOUT_MS) => {
+    // Force logout
+    logout();
+    // Find an available port
+    const availablePort = await findAvailablePort();
+    const redirectUri = `http://localhost:${availablePort}/oauth`;
+    log.info(`Using port ${availablePort} for OAuth callback`);
+    const { promise: promisedCode, resolve: setCode } = getCallablePromise();
+    const app = express();
+    app.get("/oauth", (req, res) => {
+        setCode(String(req.query.code));
+        // Set headers to prevent keep-alive
+        res.setHeader("Connection", "close");
+        res.end("You can now close this tab and return to the CLI.");
+    });
+    const server = app.listen(availablePort);
+    // Track connections to force close them if needed
+    const connections = new Set();
+    server.on("connection", (conn) => {
+        connections.add(conn);
+        conn.on("close", () => connections.delete(conn));
+    });
+    // Set up signal handlers for graceful shutdown
+    const cleanup = () => {
+        server.close();
+        log.info("\n❌ Login cancelled by user");
+        process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    const { code_verifier: codeVerifier, code_challenge: codeChallenge } = await pkceChallenge();
+    const authUrl = `${ZAPIER_BASE}/oauth/authorize/?${new URLSearchParams({
+        response_type: "code",
+        client_id: LOGIN_CLIENT_ID,
+        redirect_uri: redirectUri,
+        scope: "internal offline_access",
+        state: generateRandomString(),
+        code_challenge: codeChallenge,
+        code_challenge_method: "S256",
+    }).toString()}`;
+    log.info("Opening your browser to log in.");
+    log.info("If it doesn't open, visit:", authUrl);
+    open(authUrl);
+    try {
+        await spinPromise(Promise.race([
+            promisedCode,
+            new Promise((_resolve, reject) => setTimeout(() => {
+                reject(new Error(`Login timed out after ${Math.round(timeoutMs / 1000)} seconds.`));
+            }, timeoutMs)),
+        ]), "Waiting for you to login and authorize");
+    }
+    finally {
+        // Remove signal handlers
+        process.off("SIGINT", cleanup);
+        process.off("SIGTERM", cleanup);
+        // Close server with timeout and force-close connections if needed
+        await new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                log.info("Server close timed out, forcing connection shutdown...");
+                // Force close all connections
+                connections.forEach((conn) => conn.destroy());
+                resolve();
+            }, 1000); // 1 second timeout
+            server.close(() => {
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    }
+    log.info("Exchanging authorization code for tokens...");
+    const { data } = await api.post(`${ZAPIER_BASE}/oauth/token/`, {
+        grant_type: "authorization_code",
+        code: await promisedCode,
+        redirect_uri: redirectUri,
+        client_id: LOGIN_CLIENT_ID,
+        code_verifier: codeVerifier,
+    }, {
+        headers: {
+            [AUTH_MODE_HEADER]: "no",
+            "Content-Type": "application/x-www-form-urlencoded",
+        },
+    });
+    updateLogin(data);
+    log.info("Token exchange completed successfully");
+    return data.access_token;
+};
+export default login;

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,8 +80,8 @@ function analyzeZodField(name, schema) {
         description: schema.description,
         default: defaultValue,
         choices,
-        hasResolver: (0, zapier_sdk_1.hasResolver)(name),
-        isPositional: (0, zapier_sdk_1.isPositional)(schema),
+        hasResolver: hasResolver(name),
+        isPositional: isPositional(schema),
     };
 }
 // ============================================================================
@@ -110,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");
@@ -145,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
@@ -172,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}`));
                 }
             }
         }
@@ -182,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);
         }
@@ -294,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,
     });
@@ -304,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
@@ -320,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,
@@ -343,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
@@ -357,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/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/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;