@zapier/zapier-sdk-cli 0.0.1

package/bin/zapier-sdk.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+// Import the CLI from the compiled TypeScript
+require("../dist/cli.js");

package/bin/zsdk.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+// Import the CLI from the compiled TypeScript
+require("../dist/cli.js");

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const actions_sdk_1 = require("@zapier/actions-sdk");
+const cli_generator_1 = require("./utils/cli-generator");
+const program = new commander_1.Command();
+program
+    .name("zapier-sdk")
+    .description("CLI for Zapier SDK - Commands auto-generated from SDK schemas")
+    .version("1.0.0")
+    .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, actions_sdk_1.createActionsSDK)({
+    // Token will be picked up from ZAPIER_TOKEN env var or provided via options
+    debug: isDebugMode,
+});
+// Generate CLI commands from SDK schemas
+(0, cli_generator_1.generateCLICommands)(program, sdk);
+// Add enhanced help information
+(0, cli_generator_1.enhanceCommandHelp)(program);
+program.parse();

package/dist/commands/action.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const actionCommand: Command;

package/dist/commands/action.js

@@ -0,0 +1,295 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.actionCommand = void 0;
+const commander_1 = require("commander");
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const actions_sdk_1 = require("@zapier/actions-sdk");
+const auth_picker_1 = require("../utils/auth-picker");
+exports.actionCommand = new commander_1.Command('action')
+    .description('Execute Zapier actions with interactive field collection')
+    .argument('<app>', 'App slug (e.g., slack)')
+    .argument('<type>', 'Action type (e.g., search, read, write)')
+    .argument('<action>', 'Action key (e.g., user_by_email)')
+    .option('--auth <id>', 'Authentication ID', (value) => parseInt(value))
+    .option('--token <token>', 'Authentication token (JWT or Bearer) - can also use ZAPIER_TOKEN env var')
+    .option('--field <key=value>', 'Pre-supply field values', collectFields, [])
+    .option('--interactive', 'Force interactive mode even with all fields provided')
+    .option('--help-fields', 'Show field requirements without executing')
+    .option('--debug', 'Enable debug logging')
+    .action(executeAction);
+function collectFields(value, previous = []) {
+    return previous.concat([value]);
+}
+async function executeAction(app, type, action, options) {
+    try {
+        console.log(chalk_1.default.blue('🚀 Zapier Action Executor'));
+        console.log(chalk_1.default.gray(`App: ${app}, Type: ${type}, Action: ${action}\n`));
+        // Get token from option or environment variable
+        const token = options.token || process.env.ZAPIER_TOKEN;
+        // Validate required parameters early
+        if (!token) {
+            console.error(chalk_1.default.red('Authentication token is required'));
+            console.log(chalk_1.default.gray('Use --token <jwt-or-bearer-token> or set ZAPIER_TOKEN environment variable'));
+            return;
+        }
+        // Create SDK instance for browsing (without specific app auth)
+        const browseSdk = (0, actions_sdk_1.createActionsSDK)({
+            auth: {
+                token: token,
+                authentications: {}
+            },
+            debug: options.debug
+        });
+        let authId = options.auth;
+        if (!authId) {
+            console.log(chalk_1.default.yellow('No authentication ID provided. Let\'s select one...'));
+            const authResult = await (0, auth_picker_1.pickAuthentication)({
+                sdk: browseSdk,
+                appKey: app,
+                message: `Select an authentication for ${app} action execution:`
+            });
+            if (authResult.skipped) {
+                console.error(chalk_1.default.red('Authentication ID is required for action execution'));
+                return;
+            }
+            authId = authResult.authId;
+        }
+        // Create SDK instance with selected authentication
+        const sdk = (0, actions_sdk_1.createActionsSDK)({
+            auth: {
+                token: token,
+                authentications: {
+                    [app]: [{ id: authId }]
+                }
+            },
+            debug: options.debug
+        });
+        // Fetch action fields
+        const spinner = (0, ora_1.default)('Fetching action field requirements...').start();
+        let fields;
+        try {
+            fields = await sdk.fields.list({
+                app: app,
+                action: action,
+                type: type,
+                authId: authId
+            });
+            spinner.succeed('Field requirements loaded');
+        }
+        catch (error) {
+            spinner.fail('Failed to fetch field requirements');
+            if (error instanceof actions_sdk_1.AppNotFoundError) {
+                console.error(chalk_1.default.red(`❌ ${error.message}`));
+                console.log(chalk_1.default.gray('Use "zapier browse apps" to see available apps'));
+                return;
+            }
+            console.error(chalk_1.default.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+            return;
+        }
+        // Show field help if requested
+        if (options.helpFields) {
+            displayFieldHelp(fields);
+            return;
+        }
+        // Parse pre-supplied fields
+        const suppliedFields = parseSuppliedFields(options.field || []);
+        // Collect missing fields interactively
+        const allInputs = await collectAllFields(fields, suppliedFields, options.interactive);
+        // Validate required fields
+        const missingRequired = validateRequiredFields(fields, allInputs);
+        if (missingRequired.length > 0) {
+            console.error(chalk_1.default.red('Missing required fields:'), missingRequired.join(', '));
+            return;
+        }
+        // Execute action
+        console.log(chalk_1.default.yellow('\n📡 Executing action...'));
+        const executionSpinner = (0, ora_1.default)('Running action').start();
+        try {
+            const result = await sdk.actions.run[app][type][action]({
+                inputs: allInputs
+            });
+            executionSpinner.succeed('Action completed');
+            displayResults(result);
+        }
+        catch (error) {
+            executionSpinner.fail('Action execution failed');
+            console.error(chalk_1.default.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Unexpected error:'), error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+    }
+}
+function displayFieldHelp(fields) {
+    console.log(chalk_1.default.green('📋 Action Field Requirements\n'));
+    if (fields.length === 0) {
+        console.log(chalk_1.default.gray('No fields required for this action.'));
+        return;
+    }
+    const table = new cli_table3_1.default({
+        head: ['Field', 'Required', 'Type', 'Description'],
+        style: { head: ['cyan'] },
+        wordWrap: true,
+        colWidths: [20, 10, 15, 50]
+    });
+    fields.forEach(field => {
+        const description = [
+            field.helpText,
+            field.placeholder ? `Placeholder: ${field.placeholder}` : '',
+            field.default ? `Default: ${field.default}` : '',
+            field.choices && field.choices.length > 0 ?
+                `Choices: ${field.choices.map((c) => c.label || c.value).join(', ')}` : ''
+        ].filter(Boolean).join('\n');
+        table.push([
+            field.label || field.key,
+            field.required ? chalk_1.default.red('Yes') : chalk_1.default.gray('No'),
+            field.type || 'string',
+            description || chalk_1.default.gray('No description')
+        ]);
+    });
+    console.log(table.toString());
+}
+function parseSuppliedFields(fieldArgs) {
+    const fields = {};
+    fieldArgs.forEach(arg => {
+        const [key, ...valueParts] = arg.split('=');
+        if (key && valueParts.length > 0) {
+            const value = valueParts.join('='); // Handle values with = in them
+            fields[key] = value;
+        }
+    });
+    return fields;
+}
+async function collectAllFields(fields, suppliedFields, forceInteractive = false) {
+    const allInputs = { ...suppliedFields };
+    // Find missing required fields
+    const missingRequired = fields.filter(field => field.required && !(field.key in allInputs));
+    // Find optional fields that aren't supplied
+    const missingOptional = fields.filter(field => !field.required && !(field.key in allInputs));
+    // If we have all required fields and not forcing interactive, we're done
+    if (missingRequired.length === 0 && !forceInteractive) {
+        if (Object.keys(suppliedFields).length > 0) {
+            console.log(chalk_1.default.green('✅ Using pre-supplied field values'));
+        }
+        return allInputs;
+    }
+    console.log(chalk_1.default.yellow('📝 Interactive field collection'));
+    // Collect missing required fields
+    if (missingRequired.length > 0) {
+        console.log(chalk_1.default.red(`\nRequired fields (${missingRequired.length}):`));
+        for (const field of missingRequired) {
+            const value = await promptForField(field);
+            if (value !== undefined && value !== '') {
+                allInputs[field.key] = value;
+            }
+        }
+    }
+    // Ask if user wants to provide optional fields
+    if (missingOptional.length > 0) {
+        const { provideOptional } = await inquirer_1.default.prompt([{
+                type: 'confirm',
+                name: 'provideOptional',
+                message: `Would you like to provide any of the ${missingOptional.length} optional fields?`,
+                default: false
+            }]);
+        if (provideOptional) {
+            const { selectedOptional } = await inquirer_1.default.prompt([{
+                    type: 'checkbox',
+                    name: 'selectedOptional',
+                    message: 'Select optional fields to provide:',
+                    choices: missingOptional.map(field => ({
+                        name: `${field.label || field.key}${field.helpText ? ` - ${field.helpText}` : ''}`,
+                        value: field.key
+                    }))
+                }]);
+            for (const fieldKey of selectedOptional) {
+                const field = missingOptional.find(f => f.key === fieldKey);
+                const value = await promptForField(field);
+                if (value !== undefined && value !== '') {
+                    allInputs[field.key] = value;
+                }
+            }
+        }
+    }
+    return allInputs;
+}
+async function promptForField(field) {
+    const promptConfig = {
+        name: 'value',
+        message: `${field.label || field.key}${field.required ? ' (required)' : ''}:`,
+    };
+    if (field.helpText) {
+        promptConfig.message += chalk_1.default.gray(` ${field.helpText}`);
+    }
+    if (field.choices && field.choices.length > 0) {
+        promptConfig.type = 'list';
+        promptConfig.choices = field.choices.map((choice) => ({
+            name: choice.label,
+            value: choice.value
+        }));
+    }
+    else if (field.type === 'boolean') {
+        promptConfig.type = 'confirm';
+        promptConfig.default = field.default === 'true';
+    }
+    else {
+        promptConfig.type = 'input';
+        if (field.default) {
+            promptConfig.default = field.default;
+        }
+        if (field.placeholder) {
+            promptConfig.message += chalk_1.default.gray(` (${field.placeholder})`);
+        }
+    }
+    if (field.required) {
+        promptConfig.validate = (input) => {
+            if (!input && input !== false && input !== 0) {
+                return 'This field is required';
+            }
+            return true;
+        };
+    }
+    const result = await inquirer_1.default.prompt([promptConfig]);
+    return result.value;
+}
+function validateRequiredFields(fields, inputs) {
+    return fields
+        .filter(field => field.required && !(field.key in inputs))
+        .map(field => field.key);
+}
+function displayResults(result) {
+    console.log(chalk_1.default.green('\n🎉 Action Results\n'));
+    if (result.success) {
+        console.log(chalk_1.default.green('Status:'), 'SUCCESS');
+        if (result.data) {
+            console.log(chalk_1.default.blue('\nData:'));
+            if (Array.isArray(result.data)) {
+                result.data.forEach((item, index) => {
+                    console.log(chalk_1.default.gray(`[${index}]`), JSON.stringify(item, null, 2));
+                });
+            }
+            else {
+                console.log(JSON.stringify(result.data, null, 2));
+            }
+        }
+        if (result.metadata) {
+            console.log(chalk_1.default.gray('\nMetadata:'));
+            console.log(`Execution Time: ${result.metadata.executionTime}ms`);
+            console.log(`Request ID: ${result.metadata.requestId}`);
+        }
+    }
+    else {
+        console.log(chalk_1.default.red('Status:'), 'FAILED');
+        console.log(chalk_1.default.red('Error:'), result.error);
+        if (result.metadata) {
+            console.log(chalk_1.default.gray('\nRequest ID:'), result.metadata.requestId);
+        }
+    }
+}

package/dist/commands/browse.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const browseCommand: Command;

package/dist/commands/browse.js

@@ -0,0 +1,257 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browseCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const actions_sdk_1 = require("@zapier/actions-sdk");
+const pager_1 = require("../utils/pager");
+exports.browseCommand = new commander_1.Command('browse')
+    .description('Browse available apps and actions');
+// zapier browse apps
+exports.browseCommand
+    .command('apps')
+    .description('List all available apps')
+    .option('-c, --category <category>', 'Filter by category')
+    .option('-l, --limit <number>', 'Limit number of results', '20')
+    .option('--page', 'Enable interactive paging to load more results')
+    .option('--debug', 'Enable debug logging')
+    .action(async (options) => {
+    try {
+        const sdk = (0, actions_sdk_1.createActionsSDK)({
+            debug: options.debug
+        });
+        const limit = parseInt(options.limit);
+        console.log(chalk_1.default.blue('📱 Fetching available apps...'));
+        if (options.page) {
+            // Use interactive paging
+            const pager = (0, pager_1.createPager)({
+                pageSize: Math.min(limit, 20),
+                itemName: 'apps'
+            });
+            const displayApps = (apps, totalShown, totalAvailable) => {
+                console.clear();
+                console.log(chalk_1.default.blue('📱 Available Apps\n'));
+                if (apps.length === 0) {
+                    console.log(chalk_1.default.yellow('No apps found.'));
+                    return;
+                }
+                apps.forEach((app, index) => {
+                    console.log(`${chalk_1.default.gray(`${index + 1}.`)} ${chalk_1.default.cyan(app.name)} ${chalk_1.default.gray(`(${app.key})`)}`);
+                    if (app.description) {
+                        console.log(`   ${chalk_1.default.dim(app.description)}`);
+                    }
+                    if (app.category) {
+                        console.log(`   ${chalk_1.default.magenta(`Category: ${app.category}`)}`);
+                    }
+                    console.log();
+                });
+                const totalInfo = totalAvailable ? ` of ${totalAvailable.toLocaleString()} total` : '';
+                console.log(chalk_1.default.green(`\n✅ Showing ${totalShown}${totalInfo} apps`));
+            };
+            await pager.paginate((params) => sdk.apps.list({
+                category: options.category,
+                ...params
+            }), {}, displayApps);
+        }
+        else {
+            // Traditional single-page fetch
+            const allApps = await sdk.apps.list({
+                category: options.category,
+                limit: Math.max(limit, 50) // Fetch at least 50 to get pagination info
+            });
+            if (allApps.length === 0) {
+                console.log(chalk_1.default.yellow('No apps found.'));
+                return;
+            }
+            // Check for pagination metadata
+            const pagination = allApps.__pagination;
+            const totalCount = pagination?.count || allApps.length;
+            // Slice to requested limit (client-side limiting)
+            const apps = allApps.slice(0, limit);
+            console.log(chalk_1.default.green(`\n✅ Found ${totalCount.toLocaleString()} total apps, showing first ${apps.length}:\n`));
+            apps.forEach(app => {
+                console.log(`${chalk_1.default.cyan(app.name)} ${chalk_1.default.gray(`(${app.key})`)}`);
+                if (app.description) {
+                    console.log(`  ${chalk_1.default.dim(app.description)}`);
+                }
+                if (app.category) {
+                    console.log(`  ${chalk_1.default.magenta(`Category: ${app.category}`)}`);
+                }
+                console.log();
+            });
+            if (totalCount > limit) {
+                console.log(chalk_1.default.yellow(`\n📄 Showing first ${apps.length} of ${totalCount.toLocaleString()} total apps (limit: ${limit})`));
+                console.log(chalk_1.default.gray(`Use --limit to increase the limit, or add --page for interactive paging`));
+            }
+            else {
+                console.log(chalk_1.default.gray(`\n📄 Showing all ${apps.length} apps`));
+            }
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('❌ Error fetching apps:'), error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// zapier browse actions
+exports.browseCommand
+    .command('actions')
+    .description('List available actions for a specific app')
+    .argument('<app>', 'App key (e.g., slack, google-sheets)')
+    .option('-t, --type <type>', 'Filter by action type (create, read, update, delete, search)')
+    .option('--debug', 'Enable debug logging')
+    .action(async (app, options) => {
+    try {
+        const sdk = (0, actions_sdk_1.createActionsSDK)({
+            debug: options.debug
+        });
+        console.log(chalk_1.default.blue(`⚡ Fetching actions for ${app}...`));
+        // Get all actions for the specific app
+        let actions;
+        try {
+            actions = await sdk.actions.list({
+                appKey: app,
+                type: options.type
+            });
+        }
+        catch (error) {
+            if (error instanceof actions_sdk_1.AppNotFoundError) {
+                console.error(chalk_1.default.red(`❌ ${error.message}`));
+                console.log(chalk_1.default.gray('Use "zapier browse apps" to see available apps'));
+                return;
+            }
+            throw error;
+        }
+        if (actions.length === 0) {
+            const typeFilter = options.type ? ` of type "${options.type}"` : '';
+            console.log(chalk_1.default.yellow(`No actions found for ${app}${typeFilter}.`));
+            return;
+        }
+        const typeFilter = options.type ? ` (type: ${options.type})` : '';
+        console.log(chalk_1.default.green(`\n✅ Found ${actions.length} actions for ${app}${typeFilter}:\n`));
+        actions.forEach((action, index) => {
+            console.log(`${chalk_1.default.gray(`${index + 1}.`)} ${chalk_1.default.cyan(action.name)} ${chalk_1.default.gray(`(${action.key})`)}`);
+            console.log(`   ${chalk_1.default.magenta(`Type: ${action.type}`)}`);
+            if (action.description) {
+                console.log(`   ${chalk_1.default.dim(action.description)}`);
+            }
+            console.log();
+        });
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('❌ Error fetching actions:'), error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// zapier browse auths
+exports.browseCommand
+    .command('auths')
+    .description('List available authentications (optionally for a specific app)')
+    .argument('[app]', 'App key to filter by (e.g., slack, google-sheets)')
+    .option('--acct <account_id>', 'Filter by account ID')
+    .option('-o, --owner <owner>', 'Filter by owner (use "me" for current user)')
+    .option('-l, --limit <number>', 'Limit number of results', '20')
+    .option('--page', 'Enable interactive paging to load more results')
+    .option('--debug', 'Enable debug logging')
+    .action(async (app, options) => {
+    try {
+        const sdk = (0, actions_sdk_1.createActionsSDK)({
+            debug: options.debug
+        });
+        const limit = parseInt(options.limit);
+        console.log(chalk_1.default.blue('🔐 Fetching available authentications...'));
+        if (options.page) {
+            // Use interactive paging
+            const pager = (0, pager_1.createPager)({
+                pageSize: Math.min(limit, 20),
+                itemName: 'authentications'
+            });
+            const displayAuths = (auths, totalShown) => {
+                console.clear();
+                console.log(chalk_1.default.blue('🔐 Available Authentications\n'));
+                if (auths.length === 0) {
+                    const filterMsg = app ? ` for app "${app}"` : '';
+                    console.log(chalk_1.default.yellow(`No authentications found${filterMsg}.`));
+                    return;
+                }
+                auths.forEach((auth, index) => {
+                    console.log(`${chalk_1.default.gray(`${index + 1}.`)} ${chalk_1.default.cyan(`ID: ${auth.id}`)} ${chalk_1.default.gray(`(${auth.selected_api})`)}`);
+                    if (auth.label) {
+                        console.log(`    ${chalk_1.default.blue(`Label: ${auth.label}`)}`);
+                    }
+                    if (auth.identifier) {
+                        console.log(`    ${chalk_1.default.magenta(`Identifier: ${auth.identifier}`)}`);
+                    }
+                    if (auth.title) {
+                        console.log(`    ${chalk_1.default.white(`Title: ${auth.title}`)}`);
+                    }
+                    console.log(`    ${chalk_1.default.dim(`Account: ${auth.account_id} | Private: ${auth.is_private} | Shared: ${auth.shared_with_all}`)}`);
+                    if (auth.marked_stale_at) {
+                        console.log(`    ${chalk_1.default.red(`⚠️  Marked stale: ${new Date(auth.marked_stale_at).toLocaleDateString()}`)}`);
+                    }
+                    console.log();
+                });
+                const filterMsg = app ? ` for app "${app}"` : '';
+                console.log(chalk_1.default.green(`\n✅ Showing ${totalShown} authentications${filterMsg}`));
+            };
+            await pager.paginate((params) => sdk.auths.list({
+                account_id: options.acct,
+                owner: options.owner,
+                appKey: app,
+                ...params
+            }), {}, displayAuths);
+        }
+        else {
+            // Traditional single-page fetch
+            const allAuths = await sdk.auths.list({
+                account_id: options.acct,
+                owner: options.owner,
+                appKey: app,
+                limit: Math.max(limit, 50) // Fetch more than requested to ensure we have enough
+            });
+            if (allAuths.length === 0) {
+                const filterMsg = app ? ` for app "${app}"` : '';
+                console.log(chalk_1.default.yellow(`No authentications found${filterMsg}.`));
+                return;
+            }
+            // Check for pagination metadata
+            const pagination = allAuths.__pagination;
+            const totalCount = pagination?.count || allAuths.length;
+            // Slice to requested limit (client-side limiting)
+            const auths = allAuths.slice(0, limit);
+            const filterMsg = app ? ` for app "${app}"` : '';
+            console.log(chalk_1.default.green(`\n✅ Found ${totalCount.toLocaleString()} total authentications${filterMsg}, showing first ${auths.length}:\n`));
+            auths.forEach(auth => {
+                console.log(`${chalk_1.default.cyan(`ID: ${auth.id}`)} ${chalk_1.default.gray(`(${auth.selected_api})`)}`);
+                if (auth.label) {
+                    console.log(`  ${chalk_1.default.blue(`Label: ${auth.label}`)}`);
+                }
+                if (auth.identifier) {
+                    console.log(`  ${chalk_1.default.magenta(`Identifier: ${auth.identifier}`)}`);
+                }
+                if (auth.title) {
+                    console.log(`  ${chalk_1.default.white(`Title: ${auth.title}`)}`);
+                }
+                console.log(`  ${chalk_1.default.dim(`Account: ${auth.account_id} | Private: ${auth.is_private} | Shared: ${auth.shared_with_all}`)}`);
+                if (auth.marked_stale_at) {
+                    console.log(`  ${chalk_1.default.red(`⚠️  Marked stale: ${new Date(auth.marked_stale_at).toLocaleDateString()}`)}`);
+                }
+                console.log();
+            });
+            if (totalCount > limit) {
+                console.log(chalk_1.default.yellow(`\n📄 Showing first ${auths.length} of ${totalCount.toLocaleString()} total authentications (limit: ${limit})`));
+                console.log(chalk_1.default.gray(`Use --limit to increase the limit, or add --page for interactive paging`));
+            }
+            else {
+                console.log(chalk_1.default.gray(`\n📄 Showing all ${auths.length} authentications`));
+            }
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('❌ Error fetching authentications:'), error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});

package/dist/commands/bundle.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const bundleCommand: Command;