@chargebee/chargebee-apps 0.0.1

package/dist/api/routes.js

@@ -0,0 +1,339 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupServer = setupServer;
+exports.invokeEventHandler = invokeEventHandler;
+exports.setupApiRoutes = setupApiRoutes;
+exports.setupAppRoutes = setupAppRoutes;
+const chargebee_apps_libs_1 = require("@chargebee/chargebee-apps-libs");
+const chargebee_apps_shared_1 = require("@chargebee/chargebee-apps-shared");
+const express_1 = __importDefault(require("express"));
+const path_1 = __importDefault(require("path"));
+const registry_1 = require("../registry");
+const iparams_routes_1 = require("./iparams.routes");
+// Create a singleton instance of PathResolver
+const pathResolver = new chargebee_apps_shared_1.PathResolver();
+// Get UI directory paths using centralized path resolver
+const WEB_STATIC_DIR = pathResolver.getPublicLibsUiWebDir();
+// Configurable path variables
+const PATHS = {
+    WEB_STATIC_DIR,
+    MAIN_HTML_FILE: 'index.html',
+    HANDLER_FILE: 'handler/handler.js',
+    MANIFEST_FILE: 'manifest.json',
+    TEST_DATA_DIR: 'test_data',
+};
+const REGISTRY = registry_1.PublicCliRegistry.getInstance();
+const __logger = REGISTRY.logger;
+/**
+ * Sets up and start an Express server for the serverless app tester
+ * @param {number} port - The port number to run the server on
+ * @param {string} userCodeDir - The user code directory where logs should be stored
+ * @param {CBFileSystem} fileSystem - The filesystem implementation to use
+ * @param {CBProcess} processService - The process implementation to use
+ * @param {DependencyManager} dependencyManager - The dependency manager implementation to use
+ */
+function setupServer(port, userCodeDir, fileSystem = REGISTRY.fileSystem, processService = REGISTRY.process, dependencyManager = REGISTRY.dependencyManager) {
+    const app = (0, express_1.default)();
+    app.disable('x-powered-by');
+    // Create a single CBLogger instance for the entire server session
+    const sessionLogger = (0, chargebee_apps_libs_1.createCBPublicLogger)(fileSystem, processService, userCodeDir);
+    // CORS middleware
+    app.use((_req, res, next) => {
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.header('Access-Control-Allow-Headers', 'Content-Type');
+        next();
+    });
+    // JSON parsing 
+    app.use(express_1.default.json());
+    // Static files 
+    app.use(express_1.default.static(PATHS.WEB_STATIC_DIR));
+    // API Routes
+    setupApiRoutes(app, sessionLogger, userCodeDir, fileSystem, processService, dependencyManager);
+    // Iparams Routes
+    (0, iparams_routes_1.setupIparamsRoutes)(app, userCodeDir, fileSystem);
+    // App Routes
+    setupAppRoutes(app, fileSystem);
+    // Start server
+    const server = app.listen(port, () => {
+        __logger.info(`Server is running on \x1b[4mhttp://localhost:${port}\x1b[0m`);
+    });
+    // Graceful shutdown
+    processService.on('SIGINT', () => {
+        __logger.info('Shutting down server...');
+        server.close(() => {
+            __logger.info('Server stopped!');
+            processService.exit(0);
+        });
+    });
+    processService.on('uncaughtException', async (err) => {
+        __logger.error(`Uncaught exception thrown: ${err.message}`);
+        if (err && err.stack) {
+            __logger.error(`Stack Trace: ${err.stack}`);
+        }
+        processService.exit(1);
+    });
+    // Handle server errors
+    server.on('error', (error) => {
+        if (error.code === 'EADDRINUSE') {
+            __logger.error(`Port ${port} is already in use. Try a different port with --port option.`);
+        }
+        else {
+            __logger.error('Server error:', error);
+        }
+        processService.exit(1);
+    });
+    return server;
+}
+/**
+ * Invokes an event handler based on the event data
+ * @param {EventRecord} eventData - The event data containing event_type and payload
+ * @param {ICBLogger} sessionLogger - The logger instance for this server session
+ * @param {string} userCodeDir - The user code directory
+ * @param {CBFileSystem} fileSystem - The filesystem implementation to use
+ * @param {DependencyManager} dependencyManager - The dependency manager implementation to use
+ * @returns {Promise<any>} The result from the handler function
+ * @throws {Error} If handler file, manifest, or handler function is not found
+ */
+async function invokeEventHandler(eventData, sessionLogger, userCodeDir, fileSystem, dependencyManager) {
+    const iparamsService = new chargebee_apps_shared_1.IparamsService(fileSystem);
+    const hasIparamsFile = iparamsService.iparamsFileExists(userCodeDir);
+    let iparams;
+    if (hasIparamsFile) {
+        try {
+            iparams = iparamsService.validateAndGetInputsForExecution(userCodeDir);
+        }
+        catch (error) {
+            if (error instanceof chargebee_apps_shared_1.MissingRequiredParamsError) {
+                throw error;
+            }
+            const err = error;
+            return {
+                success: false,
+                error: `Parameters validation failed: ${err.message}`,
+                stack: err.stack
+            };
+        }
+    }
+    const configLoader = new chargebee_apps_libs_1.ConfigLoader(fileSystem);
+    const allowedModules = configLoader.loadAllowedModules();
+    const packageValidator = new chargebee_apps_shared_1.PackageValidator(fileSystem);
+    const manifestValidator = new chargebee_apps_shared_1.ManifestValidator(allowedModules, fileSystem);
+    const sandbox = new chargebee_apps_libs_1.PublicSandboxWrapper(allowedModules, fileSystem, packageValidator, dependencyManager, manifestValidator);
+    const payload = hasIparamsFile
+        ? { event: eventData, iparams: iparams ?? {} }
+        : { event: eventData };
+    return await sandbox.execute(userCodeDir, payload, sessionLogger);
+}
+/**
+ * Sets up all API routes for the serverless app tester
+ * @param {Application} app - Express application instance
+ * @param {ICBLogger} sessionLogger - The logger instance for this server session
+ * @param {string} userCodeDir - The user code directory
+ * @param {CBFileSystem} fileSystem - The filesystem implementation to use
+ * @param {CBProcess} process - The process implementation to use
+ * @param {DependencyManager} dependencyManager - The dependency manager implementation to use
+ */
+function setupApiRoutes(app, sessionLogger, userCodeDir, fileSystem, process, dependencyManager) {
+    // Get list of available test data files
+    app.get('/api/manifest', (_req, res, next) => {
+        const testDataDir = path_1.default.join(process.cwd(), PATHS.TEST_DATA_DIR);
+        const manifestPath = path_1.default.join(process.cwd(), PATHS.MANIFEST_FILE);
+        const handlerPath = path_1.default.join(process.cwd(), PATHS.HANDLER_FILE);
+        try {
+            // Check if manifest.json exists
+            const configLoader = new chargebee_apps_libs_1.ConfigLoader(fileSystem);
+            const allowedModules = configLoader.loadAllowedModules();
+            const manifestValidator = new chargebee_apps_shared_1.ManifestValidator(allowedModules, fileSystem);
+            const manifestData = manifestValidator.validateAndGetManifestFile(manifestPath);
+            // Load manifest to get configured events
+            const configuredEvents = Object.keys(manifestData.events || {});
+            // Check if handler.js exists
+            const handlerExists = fileSystem.existsSync(handlerPath);
+            // Check if test data directory exists
+            const testDataExists = fileSystem.existsSync(testDataDir);
+            let testDataFiles = [];
+            if (testDataExists) {
+                testDataFiles = fileSystem.readdirSync(testDataDir)
+                    .filter((file) => file.endsWith('.json'))
+                    .map((file) => file.replace('.json', ''));
+            }
+            // Analyze each configured event
+            const events = configuredEvents.map(eventType => {
+                const eventConfig = manifestData.events[eventType];
+                const handlerName = eventConfig ? eventConfig.handler : null;
+                const hasTestData = testDataFiles.includes(eventType);
+                // Check if handler function exists in handler.js
+                let hasHandlerFunction = false;
+                if (handlerExists && handlerName) {
+                    try {
+                        delete require.cache[require.resolve(handlerPath)];
+                        const handlerModule = require(handlerPath);
+                        hasHandlerFunction = typeof handlerModule[handlerName] === 'function';
+                    }
+                    catch (error) {
+                        __logger.error(`Error checking handler function ${handlerName}:`, error.message);
+                        hasHandlerFunction = false;
+                    }
+                }
+                else {
+                    __logger.info(`Handler check skipped for ${eventType}: handlerExists=${handlerExists}, handlerName=${handlerName}`);
+                }
+                return {
+                    event_type: eventType,
+                    handler: {
+                        name: handlerName,
+                        exists: hasHandlerFunction,
+                    },
+                    has_test_data: hasTestData,
+                };
+            });
+            // Return all configured events with their status
+            const response = {
+                events: events,
+                dependencies: manifestData.dependencies || {}
+            };
+            res.json(response);
+        }
+        catch (error) {
+            __logger.error('Error: Failed to get manifest', error);
+            if (error instanceof Error && error.message && error.message.includes('manifest.json not found')) {
+                __logger.error(`Manifest file not found: ${manifestPath}`);
+                res.status(404).json({
+                    error: 'Manifest file not found',
+                    message: error.message
+                });
+            }
+            else {
+                res.status(500).json({
+                    error: 'Internal server error',
+                    message: error instanceof Error && error.message ? error.message : error
+                });
+            }
+            next(error);
+            res.status(500).json({ error: 'Failed to read test data directory' });
+        }
+    });
+    // Get specific test data file
+    app.get('/api/test-data/:eventType', (req, res) => {
+        const { eventType } = req.params;
+        if (!eventType) {
+            res.status(400).json({ error: 'Event type is required' });
+            return;
+        }
+        const sanitizedEventType = path_1.default.basename(eventType);
+        // Validate: ensure eventType doesn't contain path separators
+        if (sanitizedEventType !== eventType || /[\/\\]/.test(eventType)) {
+            res.status(400).json({
+                error: 'Invalid event type',
+                message: 'Event type must not contain path separators'
+            });
+            return;
+        }
+        // Construct paths
+        const testDataDir = path_1.default.resolve(process.cwd(), PATHS.TEST_DATA_DIR);
+        const testDataFile = path_1.default.resolve(testDataDir, `${sanitizedEventType}.json`);
+        // Security check: Verify the resolved path is within the test_data directory
+        if (!testDataFile.startsWith(testDataDir + path_1.default.sep)) {
+            res.status(400).json({
+                error: 'Invalid event type',
+                message: 'Access denied'
+            });
+            return;
+        }
+        try {
+            if (fileSystem.existsSync(testDataFile)) {
+                const data = fileSystem.readFileSync(testDataFile, 'utf8');
+                res.json(JSON.parse(data));
+            }
+            else {
+                res.status(404).json({
+                    error: `Test data for event '${sanitizedEventType}' not found`,
+                    path: testDataFile,
+                    message: 'Check if the test_data directory exists in your app directory'
+                });
+            }
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to read test data file' });
+        }
+    });
+    // Invoke serverless function
+    app.post('/api/invoke', async (req, res) => {
+        try {
+            const eventData = req.body;
+            const result = await invokeEventHandler(eventData, sessionLogger, userCodeDir, fileSystem, dependencyManager);
+            if (result.success) {
+                return res.json({ status: 'success' });
+            }
+            __logger.error(`✗ Handler execution failed: ${result.error}`);
+            return res.status(500).json({ error: 'Uncaught exception thrown while invoking function', message: result.error, stack: result.stack });
+        }
+        catch (error) {
+            if (error instanceof chargebee_apps_shared_1.MissingRequiredParamsError) {
+                const paramText = error.missing.length > 1 ? 'parameters' : 'parameter';
+                __logger.error(`✗ Missing required ${paramText}: ${error.missing.join(', ')}. Please provide values for these parameters in iparams.local.json`);
+                return res.status(400).json({
+                    error: 'Parameters validation failed',
+                    message: error.message,
+                    missingParams: error.missing,
+                    showPopup: true
+                });
+            }
+            __logger.error('Error: Failed to invoke event handler', error);
+            const errMsg = error instanceof Error ? error.message : '';
+            const errorMap = {
+                'Handler function': { status: 400, error: 'Handler function not found' },
+                'No handler configured': { status: 400, error: 'No handler configured' },
+                'handler.js not found': { status: 404, error: 'Handler file not found' },
+                'manifest.json not found': { status: 404, error: 'Manifest file not found' }
+            };
+            for (const [key, { status, error: errorMsg }] of Object.entries(errorMap)) {
+                if (errMsg.includes(key)) {
+                    return res.status(status).json({ error: errorMsg, message: errMsg });
+                }
+            }
+            return res.status(500).json({
+                error: 'Internal server error',
+                message: errMsg || error
+            });
+        }
+    });
+    // Handle 404 for API routes
+    app.all('/api', (_req, res) => {
+        __logger.info('API endpoint not found');
+        res.status(404).json({ error: 'API endpoint not found' });
+    });
+}
+/**
+ * Sets up application routes for serving the web UI
+ * @param {Application} app - Express application instance
+ * @param {CBFileSystem} fileSystem - The filesystem implementation to use
+ */
+function setupAppRoutes(app, fileSystem) {
+    // Serve index.html for all other routes (SPA support)
+    app.get('/', (_req, res) => {
+        const indexPath = path_1.default.join(PATHS.WEB_STATIC_DIR, PATHS.MAIN_HTML_FILE);
+        if (fileSystem.existsSync(indexPath)) {
+            res.sendFile(indexPath);
+        }
+        else {
+            res.status(404).send('Web UI not found. Please check the file path.');
+        }
+    });
+    // Error handling middleware
+    app.use((error, _req, res, _next) => {
+        // Only log and respond if headers haven't been sent yet
+        if (!res.headersSent) {
+            __logger.error('Error: Failed to handle middleware', error);
+            res.status(500).json({
+                error: 'Internal server error',
+                message: error.message
+            });
+        }
+        // If headers already sent, error was already handled - don't log again
+    });
+}

package/dist/commands/create.d.ts

@@ -0,0 +1,30 @@
+import { CBFileSystem, CBProcess, CreateOptions } from '@chargebee/chargebee-apps-shared';
+/**
+ * Main create command class
+ */
+export declare class CreateCommand {
+    private templateService;
+    private fileSystem;
+    private process;
+    constructor(fileSystem?: CBFileSystem, process?: CBProcess);
+    /**
+     * Creates a new serverless application from a template
+     * @param {CreateOptions} options - The options for the create command
+     * @param {string} appDir - The directory where the app will be created
+     */
+    execute(options: CreateOptions, appDir: string): void;
+    /**
+     * Validates the app directory
+     * @param targetDir - The directory where the app will be created
+     * @param appDir - The original app directory argument
+     * @param template - The template name to use for scaffolding
+     */
+    private validate;
+    /**
+     * Creates a new serverless application from a template
+     * @param targetDir - The directory where the app will be created
+     * @param template - The template name to use for scaffolding
+     */
+    private createProject;
+}
+export declare const createCommand: CreateCommand;

package/dist/commands/create.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommand = exports.CreateCommand = void 0;
+const chargebee_apps_shared_1 = require("@chargebee/chargebee-apps-shared");
+const path_1 = __importDefault(require("path"));
+const registry_1 = require("../registry");
+// Create a singleton instance of PathResolver
+const pathResolver = new chargebee_apps_shared_1.PathResolver();
+/**
+ * Main create command class
+ */
+class CreateCommand {
+    constructor(fileSystem, process) {
+        const registry = registry_1.PublicCliRegistry.getInstance();
+        this.fileSystem = fileSystem || registry.fileSystem;
+        this.process = process || registry.process;
+        // Get templates directory path using centralized path resolver
+        const templatesPath = pathResolver.getPublicLibsTemplatesDir();
+        this.templateService = new chargebee_apps_shared_1.TemplateService(this.fileSystem, templatesPath);
+    }
+    /**
+     * Creates a new serverless application from a template
+     * @param {CreateOptions} options - The options for the create command
+     * @param {string} appDir - The directory where the app will be created
+     */
+    execute(options, appDir) {
+        const template = options.template;
+        chargebee_apps_shared_1.__logger.info('Creating new application...');
+        const targetDir = path_1.default.resolve(appDir);
+        // Validate app directory
+        this.validate(targetDir, appDir, template);
+        // Create project
+        this.createProject(targetDir, template);
+    }
+    /**
+     * Validates the app directory
+     * @param targetDir - The directory where the app will be created
+     * @param appDir - The original app directory argument
+     * @param template - The template name to use for scaffolding
+     */
+    validate(targetDir, appDir, template) {
+        const defaultTemplate = 'serverless-node-starter-app';
+        // Show which template is being used
+        if (template === defaultTemplate) {
+            chargebee_apps_shared_1.__logger.info(`Using default template: ${template}`);
+        }
+        else {
+            chargebee_apps_shared_1.__logger.info(`Using template: ${template}`);
+        }
+        // Validate template
+        if (!this.templateService.validateTemplate(template)) {
+            const availableTemplates = this.templateService.getAvailableTemplates();
+            chargebee_apps_shared_1.__logger.error(`Error: Template '${template}' not found.`);
+            chargebee_apps_shared_1.__logger.error(`Available templates: ${availableTemplates.join(', ')}`);
+            this.process.exit(1);
+        }
+        // Validate app directory
+        try {
+            const conflicts = this.templateService.validateAppDirectory(targetDir, appDir, template);
+            if (conflicts.length > 0) {
+                chargebee_apps_shared_1.__logger.error(`Error: The following files already exist in the current directory:`);
+                conflicts.forEach(file => chargebee_apps_shared_1.__logger.error(`  - ${file}`));
+                chargebee_apps_shared_1.__logger.error(`Please remove these files or use a different directory.`);
+                this.process.exit(1);
+            }
+        }
+        catch (error) {
+            chargebee_apps_shared_1.__logger.error(`Error: ${error.message}`);
+            chargebee_apps_shared_1.__logger.error(`Use a different directory name or clear the existing directory first.`);
+            this.process.exit(1);
+        }
+    }
+    /**
+     * Creates a new serverless application from a template
+     * @param targetDir - The directory where the app will be created
+     * @param template - The template name to use for scaffolding
+     */
+    createProject(targetDir, template) {
+        try {
+            if (!this.fileSystem.existsSync(targetDir)) {
+                this.fileSystem.mkdirSync(targetDir, { recursive: true });
+            }
+            // Copy template files
+            const templatePath = this.templateService.getTemplatePath(template);
+            this.templateService.copyTemplateFiles(templatePath, targetDir);
+            chargebee_apps_shared_1.__logger.success(`Successfully created app in '${targetDir}' using template '${template}'`);
+            chargebee_apps_shared_1.__logger.info(`Directory: ${targetDir}`);
+            chargebee_apps_shared_1.__logger.info('Project structure:');
+            this.templateService.printProjectStructure(targetDir);
+        }
+        catch (error) {
+            chargebee_apps_shared_1.__logger.error(`Error creating app: ${error}`);
+            this.process.exit(1);
+        }
+    }
+}
+exports.CreateCommand = CreateCommand;
+// Export for use in commands/index.ts
+exports.createCommand = new CreateCommand();

package/dist/commands/index.d.ts

@@ -0,0 +1,7 @@
+import { Command } from 'commander';
+/**
+ * Sets up the CLI program with all available commands
+ * @returns {Command} The configured CLI program
+ */
+declare function setupCLI(): Command;
+export { setupCLI };

package/dist/commands/index.js

@@ -0,0 +1,93 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupCLI = setupCLI;
+const commander_1 = require("commander");
+const package_json_1 = __importDefault(require("../../package.json"));
+const create_1 = require("./create");
+const package_1 = require("./package");
+const run_1 = require("./run");
+const chargebee_apps_shared_1 = require("@chargebee/chargebee-apps-shared");
+const registry_1 = require("../registry");
+/**
+ * Sets up the CLI program with all available commands
+ * @returns {Command} The configured CLI program
+ */
+function setupCLI() {
+    const registry = registry_1.PublicCliRegistry.getInstance();
+    const pathResolver = new chargebee_apps_shared_1.PathResolver();
+    const templatesPath = pathResolver.getPublicLibsTemplatesDir();
+    const templateService = new chargebee_apps_shared_1.TemplateService(registry.fileSystem, templatesPath);
+    const availableTemplates = templateService.getAvailableTemplates();
+    const program = new commander_1.Command();
+    program
+        .name('chargebee-apps')
+        .description('Chargebee Apps CLI - Create, test, and package serverless applications')
+        .version(package_json_1.default.version)
+        .usage('<command> <directory> [options]')
+        .showHelpAfterError()
+        .showSuggestionAfterError()
+        .addHelpCommand()
+        .configureHelp({
+        sortSubcommands: true,
+        sortOptions: true,
+        subcommandTerm: (cmd) => {
+            const args = cmd.registeredArguments.map(arg => {
+                return arg.required ? `<${arg.name()}>` : `[${arg.name()}]`;
+            }).join(' ');
+            const hasOptions = cmd.options.length > 0;
+            return `${cmd.name()}${args ? ' ' + args : ''}${hasOptions ? ' [options]' : ''}`;
+        }
+    });
+    program
+        .command('create')
+        .usage('<directory> [options]')
+        .summary('Create a new application')
+        .description('Create a new application from a template')
+        .argument('<directory>', 'Path where the new application will be created')
+        .option('--template <template>', 'Template to scaffold from', package_json_1.default.config.defaultTemplate)
+        .addHelpText('after', '\n' + [
+        'Available Templates:',
+        ...availableTemplates.map(t => `  - ${t}`),
+        '',
+        'Examples:',
+        '  chargebee-apps create my-app',
+        '  chargebee-apps create ./projects/new-app --template serverless-node-starter-app',
+        '  chargebee-apps create ./projects/my-app-with-iparams --template serverless-node-starter-app-with-iparams'
+    ].join('\n'))
+        .action((directory, options) => create_1.createCommand.execute(options, directory));
+    program
+        .command('run')
+        .usage('<directory> [options]')
+        .summary('Start a local development server')
+        .description('Start a local development server to test your serverless application')
+        .argument('<directory>', 'Path to the application directory to run')
+        .option('-p, --port <port>', 'Port to run the server on', package_json_1.default.config.defaultPort.toString())
+        .addHelpText('after', '\n' + [
+        'Examples:',
+        '  chargebee-apps run .',
+        '  chargebee-apps run ./my-app',
+        '  chargebee-apps run ./my-app --port 15001',
+        '  chargebee-apps run ./my-app -p 15001'
+    ].join('\n'))
+        .action(async (directory, options) => {
+        await run_1.runCommand.execute(options, directory);
+    });
+    program
+        .command('package')
+        .usage('<directory> [options]')
+        .summary('Package an application')
+        .description('Package a serverless application into a zip file')
+        .argument('<directory>', 'Path to the application directory to package')
+        .option('--name <name>', 'Custom name for the package (without extension)', package_json_1.default.config.defaultPackageName)
+        .addHelpText('after', '\n' + [
+        'Examples:',
+        '  chargebee-apps package .',
+        '  chargebee-apps package ./my-app',
+        '  chargebee-apps package ./my-app --name my-app-v1.0.0'
+    ].join('\n'))
+        .action(async (directory, options) => await package_1.packageCommand.execute(directory, options));
+    return program;
+}

package/dist/commands/package.d.ts

@@ -0,0 +1,20 @@
+import { ArchiveService, CBFileSystem, CBProcess, FileManagementService, PackageOptions, PackageValidator } from '@chargebee/chargebee-apps-shared';
+/**
+ * Main package command class
+ */
+export declare class PackageCommand {
+    private fileSystem;
+    private process;
+    private fileManagementService;
+    private packageValidator;
+    private archiveService;
+    constructor(fileSystem?: CBFileSystem, process?: CBProcess, fileManagementService?: FileManagementService, packageValidator?: PackageValidator, archiveService?: ArchiveService);
+    /**
+     * Packages a serverless application into a zip file
+     * @param {string} appDir - The application directory to package
+     * @param {string} packageName - The name of the package
+     */
+    execute(appDir: string, options: PackageOptions): Promise<void>;
+    private validate;
+}
+export declare const packageCommand: PackageCommand;