@edgible-team/cli 1.0.1 → 1.0.2

package/dist/commands/application.d.ts

@@ -0,0 +1,6 @@
+import { Command } from 'commander';
+/**
+ * Application command group
+ */
+export declare function setupApplicationCommands(program: Command): void;
+//# sourceMappingURL=application.d.ts.map

package/dist/commands/application.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application.d.ts","sourceRoot":"","sources":["../../src/commands/application.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAsBpC;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA+1C/D"}

package/dist/commands/application.js

@@ -717,6 +717,382 @@ Examples:
         requireAuth: true,
         requireOrganization: true,
     }));
+    // Managed Process subcommand
+    const createManagedProcessCommand = new commander_1.Command('managed-process')
+        .description('Create application from a managed process (agent runs the command)')
+        .addHelpText('after', `
+Examples:
+  $ edgible application create managed-process --name myapp --command "node server.js" --port 3000
+  $ edgible application create managed-process --name myapp --command "python app.py" --port 8080 --working-dir /opt/myapp
+  $ edgible application create managed-process --no-interactive --name myapp --command "npm start" --port 3000
+  `)
+        .option('-n, --name <name>', 'Application name')
+        .option('-d, --description <description>', 'Application description')
+        .option('-c, --command <command>', 'Command to execute')
+        .option('-p, --port <port>', 'Port number the process will listen on')
+        .option('--working-dir <dir>', 'Working directory for the process')
+        .option('--env <vars>', 'Environment variables (format: KEY=VALUE,KEY2=VALUE2)')
+        .option('--log-file <path>', 'Path to log file for stdout/stderr')
+        .option('--protocol <protocol>', 'Protocol (http, https, tcp, udp)', 'http')
+        .option('--device-id <id>', 'Serving device ID')
+        .option('--gateway-ids <ids>', 'Comma-separated gateway device IDs')
+        .option('--hostnames <hostnames>', 'Comma-separated additional hostnames')
+        .option('--no-interactive', 'Run in non-interactive mode')
+        .action((0, command_wrapper_1.wrapCommand)(async (options) => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        const applicationService = container.get(types_1.TYPES.ApplicationService);
+        const gatewayService = container.get(types_1.TYPES.GatewayService);
+        const edgibleService = container.get(types_1.TYPES.EdgibleService);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+            requireOrganization: true,
+        });
+        // Application name
+        let appName = options.name;
+        if (!appName && !options.noInteractive) {
+            const { name } = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'name',
+                    message: 'Enter application name:',
+                    validate: (i) => !!i.trim() || 'Application name is required',
+                },
+            ]);
+            appName = name.trim();
+        }
+        if (!appName) {
+            throw new Error('Application name is required');
+        }
+        // Command
+        let command = options.command;
+        if (!command && !options.noInteractive) {
+            const { cmd } = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'cmd',
+                    message: 'Enter command to run:',
+                    validate: (i) => !!i.trim() || 'Command is required',
+                },
+            ]);
+            command = cmd.trim();
+        }
+        if (!command) {
+            throw new Error('Command is required');
+        }
+        // Port
+        let port = options.port ? (0, input_parser_1.parsePort)(options.port) : undefined;
+        if (!port && !options.noInteractive) {
+            const { portInput } = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'portInput',
+                    message: 'Enter port number the process will listen on:',
+                    default: '3000',
+                    validate: (i) => {
+                        const p = parseInt(i, 10);
+                        return (p > 0 && p <= 65535) || 'Port must be between 1 and 65535';
+                    },
+                },
+            ]);
+            port = (0, input_parser_1.parsePort)(portInput);
+        }
+        if (!port) {
+            throw new Error('Port is required');
+        }
+        // Working directory
+        let workingDirectory = options.workingDir;
+        if (!workingDirectory && !options.noInteractive) {
+            const { dir } = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'dir',
+                    message: 'Enter working directory (leave empty for current directory):',
+                    default: process.cwd(),
+                },
+            ]);
+            workingDirectory = dir.trim();
+        }
+        // Environment variables
+        let env = {};
+        if (options.env) {
+            // Parse format: KEY=VALUE,KEY2=VALUE2
+            const pairs = options.env.split(',');
+            for (const pair of pairs) {
+                const [key, value] = pair.split('=');
+                if (key && value) {
+                    env[key.trim()] = value.trim();
+                }
+            }
+        }
+        else if (!options.noInteractive) {
+            const { addEnv } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'addEnv',
+                    message: 'Add environment variables?',
+                    default: false,
+                },
+            ]);
+            if (addEnv) {
+                let continueAdding = true;
+                while (continueAdding) {
+                    const { key, value } = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'key',
+                            message: 'Environment variable name:',
+                        },
+                        {
+                            type: 'input',
+                            name: 'value',
+                            message: 'Environment variable value:',
+                        },
+                    ]);
+                    if (key && value) {
+                        env[key.trim()] = value.trim();
+                    }
+                    const { more } = await inquirer_1.default.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'more',
+                            message: 'Add another environment variable?',
+                            default: false,
+                        },
+                    ]);
+                    continueAdding = more;
+                }
+            }
+        }
+        // Log file
+        let logFile = options.logFile;
+        if (!logFile && !options.noInteractive) {
+            const { addLog } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'addLog',
+                    message: 'Capture logs to file?',
+                    default: false,
+                },
+            ]);
+            if (addLog) {
+                const { path: logPath } = await inquirer_1.default.prompt([
+                    {
+                        type: 'input',
+                        name: 'path',
+                        message: 'Log file path:',
+                        default: `/var/log/${appName}.log`,
+                    },
+                ]);
+                logFile = logPath.trim();
+            }
+        }
+        // Description
+        const description = options.description || `Managed process application for ${appName}`;
+        // Protocol
+        const protocol = (0, input_parser_1.parseProtocol)(options.protocol);
+        // Device IDs and Gateway IDs
+        let deviceId = options.deviceId;
+        let gatewayIds = (0, input_parser_1.parseGatewayIds)(options.gatewayIds);
+        let hostnames = Array.isArray(options.hostnames)
+            ? options.hostnames
+            : (typeof options.hostnames === 'string' && options.hostnames.trim().length > 0
+                ? options.hostnames.split(',').map(s => s.trim()).filter(Boolean)
+                : []);
+        let useManagedGateway = false;
+        if (!options.noInteractive) {
+            // Optional: prompt for additional hostnames
+            const { addHostnames } = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'addHostnames',
+                    message: 'Additional hostnames (comma-separated, optional):',
+                    when: () => hostnames.length === 0,
+                },
+            ]);
+            if (addHostnames && typeof addHostnames === 'string') {
+                hostnames = addHostnames.split(',').map((s) => s.trim()).filter((s) => s.length > 0);
+            }
+            // Prompt for managed gateway option
+            if (gatewayIds.length === 0) {
+                const { useManaged } = await inquirer_1.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'useManaged',
+                        message: 'Use Edgible managed gateway?',
+                        default: false,
+                    },
+                ]);
+                useManagedGateway = useManaged;
+                if (!useManagedGateway) {
+                    // Try to offer a list of gateways (via service), else fallback to manual input
+                    try {
+                        const gatewaysResp = await gatewayService.listGateways();
+                        const gatewayChoices = gatewaysResp.gateways.map((g) => ({
+                            name: `${g.device.name} (${g.device.id})`,
+                            value: g.device.id,
+                        }));
+                        if (gatewayChoices.length > 0) {
+                            const { selectedGateways } = await inquirer_1.default.prompt([
+                                {
+                                    type: 'checkbox',
+                                    name: 'selectedGateways',
+                                    message: 'Select gateway device(s):',
+                                    choices: gatewayChoices,
+                                    validate: (vals) => vals.length > 0 ? true : 'Select at least one gateway',
+                                },
+                            ]);
+                            gatewayIds = selectedGateways;
+                        }
+                    }
+                    catch (error) {
+                        logger.warn('Failed to list gateways', error);
+                    }
+                    if (gatewayIds.length === 0) {
+                        const ans2 = await inquirer_1.default.prompt([
+                            {
+                                type: 'input',
+                                name: 'gatewayIds',
+                                message: 'Enter comma-separated gateway device IDs:',
+                                validate: (v) => v && v.split(',').map((s) => s.trim()).filter(Boolean).length > 0
+                                    ? true
+                                    : 'At least one gateway ID is required',
+                            },
+                        ]);
+                        gatewayIds = (0, input_parser_1.parseGatewayIds)(ans2.gatewayIds);
+                    }
+                }
+            }
+            // Serving device selection
+            if (!deviceId) {
+                try {
+                    const servingDevicesResp = await edgibleService.listServingDevices();
+                    const servingDeviceChoices = Array.isArray(servingDevicesResp?.devices)
+                        ? servingDevicesResp.devices.map((d) => ({
+                            name: `${d.name || d.id}${d.description ? ` - ${d.description}` : ''}`,
+                            value: d.id,
+                        }))
+                        : [];
+                    if (servingDeviceChoices.length > 0) {
+                        const { selectedDeviceId } = await inquirer_1.default.prompt([
+                            {
+                                type: 'list',
+                                name: 'selectedDeviceId',
+                                message: 'Select serving device:',
+                                choices: servingDeviceChoices,
+                            },
+                        ]);
+                        deviceId = selectedDeviceId;
+                    }
+                    else {
+                        // Fallback to manual input if no serving devices found
+                        const ans = await inquirer_1.default.prompt([
+                            {
+                                type: 'input',
+                                name: 'deviceId',
+                                message: 'Enter serving device ID:',
+                                validate: (v) => v && v.trim().length > 0 ? true : 'Serving device ID is required',
+                            },
+                        ]);
+                        deviceId = String(ans.deviceId).trim();
+                    }
+                }
+                catch (error) {
+                    logger.warn('Failed to list serving devices', error);
+                    // Fallback to manual input if listing fails
+                    const ans = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'deviceId',
+                            message: 'Enter serving device ID:',
+                            validate: (v) => v && v.trim().length > 0 ? true : 'Serving device ID is required',
+                        },
+                    ]);
+                    deviceId = String(ans.deviceId).trim();
+                }
+            }
+        }
+        if (!deviceId) {
+            throw new Error('--device-id (serving) is required');
+        }
+        if (!useManagedGateway && gatewayIds.length === 0) {
+            throw new Error('--gateway-ids is required (at least one) or use --use-managed-gateway');
+        }
+        // Build configuration
+        const configuration = {
+            command,
+        };
+        if (workingDirectory) {
+            configuration.workingDirectory = workingDirectory;
+        }
+        if (Object.keys(env).length > 0) {
+            configuration.env = env;
+        }
+        if (logFile) {
+            configuration.logFile = logFile;
+        }
+        // Create application
+        logger.info('Creating managed process application', {
+            name: appName,
+            port,
+            protocol,
+            command,
+            deviceId,
+            gatewayIds,
+            subtype: 'managed-process',
+        });
+        console.log(chalk_1.default.blue(`\nCreating managed process application: ${appName}`));
+        console.log(chalk_1.default.gray(`Command: ${command}`));
+        console.log(chalk_1.default.gray(`Port: ${port}`));
+        console.log(chalk_1.default.gray(`Protocol: ${protocol.toUpperCase()}`));
+        if (workingDirectory) {
+            console.log(chalk_1.default.gray(`Working directory: ${workingDirectory}`));
+        }
+        if (Object.keys(env).length > 0) {
+            console.log(chalk_1.default.gray(`Environment variables: ${Object.keys(env).length} variable(s)`));
+        }
+        if (logFile) {
+            console.log(chalk_1.default.gray(`Log file: ${logFile}`));
+        }
+        console.log(chalk_1.default.gray(`Serving device: ${deviceId}`));
+        if (useManagedGateway) {
+            console.log(chalk_1.default.gray(`Using Edgible managed gateway`));
+        }
+        else {
+            console.log(chalk_1.default.gray(`Gateways: ${gatewayIds.join(', ')}`));
+        }
+        if (hostnames.length > 0) {
+            console.log(chalk_1.default.gray(`Additional hostnames: ${hostnames.join(', ')}`));
+        }
+        const result = await applicationService.createApplicationProgrammatically({
+            name: appName,
+            description,
+            port,
+            protocol,
+            hostnames,
+            deviceIds: [deviceId],
+            gatewayIds: useManagedGateway ? undefined : gatewayIds,
+            useManagedGateway,
+            subtype: 'managed-process',
+            configuration,
+        });
+        console.log(chalk_1.default.green('\n✓ Managed process application created successfully!'));
+        console.log(chalk_1.default.blue('\n📋 Application Details:'));
+        if (result && typeof result === 'object' && 'name' in result) {
+            const app = result;
+            console.log(chalk_1.default.white(`  Name: ${app.name}`));
+            console.log(chalk_1.default.white(`  ID: ${app.id}`));
+            if (app.url)
+                console.log(chalk_1.default.white(`  URL: ${chalk_1.default.cyan.bold(app.url)}`));
+            console.log(chalk_1.default.white(`  Status: ${app.status}`));
+        }
+        console.log(chalk_1.default.yellow('\n⚠ Note: The agent will start the process when it receives the configuration.'));
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+        requireOrganization: true,
+    }));
     // Stub subcommands for unimplemented workload types
     const createDockerCommand = new commander_1.Command('docker')
         .description('Create application from Docker container (not implemented)')
@@ -748,6 +1124,7 @@ Examples:
     // Add all subcommands to create command
     createCommand.addCommand(createExistingCommand);
     createCommand.addCommand(createDockerComposeCommand);
+    createCommand.addCommand(createManagedProcessCommand);
     createCommand.addCommand(createDockerCommand);
     createCommand.addCommand(createQemuCommand);
     createCommand.addCommand(createPodmanCommand);

package/dist/commands/auth.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function setupAuthCommands(program: Command): void;
+//# sourceMappingURL=auth.d.ts.map

package/dist/commands/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/commands/auth.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAepC,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAyNxD"}

package/dist/commands/base/BaseCommand.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Base command class
+ * Provides consistent command execution with middleware support
+ */
+import { CommandHandler, CommandContext, CommandMiddleware } from './CommandHandler';
+import { Logger } from '../../utils/logger';
+import { ConfigRepository } from '../../repositories/config-repository';
+export interface BaseCommandOptions {
+    logger: Logger;
+    configRepository: ConfigRepository;
+    requireAuth?: boolean;
+    requireOrganization?: boolean;
+}
+/**
+ * Base command implementation with error handling and middleware
+ */
+export declare class BaseCommand implements CommandHandler {
+    protected logger: Logger;
+    protected configRepository: ConfigRepository;
+    protected requireAuth: boolean;
+    protected requireOrganization: boolean;
+    private middlewares;
+    constructor(options: BaseCommandOptions);
+    /**
+     * Add middleware to the command
+     */
+    use(middleware: CommandMiddleware): void;
+    /**
+     * Execute the command with middleware chain
+     */
+    execute(context: CommandContext): Promise<void>;
+    /**
+     * Run middleware chain
+     */
+    private runMiddleware;
+    /**
+     * Override this method in subclasses to implement command logic
+     */
+    protected doExecute(context: CommandContext): Promise<void>;
+    /**
+     * Check if user is authenticated
+     */
+    protected ensureAuthenticated(): void;
+    /**
+     * Check if organization ID is available
+     */
+    protected ensureOrganization(): void;
+    /**
+     * Validate and ensure authentication and organization
+     */
+    protected validateContext(): void;
+}
+//# sourceMappingURL=BaseCommand.d.ts.map

package/dist/commands/base/BaseCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseCommand.d.ts","sourceRoot":"","sources":["../../../src/commands/base/BaseCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErF,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAExE,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;GAEG;AACH,qBAAa,WAAY,YAAW,cAAc;IAChD,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IAC7C,SAAS,CAAC,WAAW,EAAE,OAAO,CAAC;IAC/B,SAAS,CAAC,mBAAmB,EAAE,OAAO,CAAC;IACvC,OAAO,CAAC,WAAW,CAA2B;gBAElC,OAAO,EAAE,kBAAkB;IAOvC;;OAEG;IACH,GAAG,CAAC,UAAU,EAAE,iBAAiB,GAAG,IAAI;IAIxC;;OAEG;IACG,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAYrD;;OAEG;YACW,aAAa;IAW3B;;OAEG;cACa,SAAS,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjE;;OAEG;IACH,SAAS,CAAC,mBAAmB,IAAI,IAAI;IAcrC;;OAEG;IACH,SAAS,CAAC,kBAAkB,IAAI,IAAI;IAWpC;;OAEG;IACH,SAAS,CAAC,eAAe,IAAI,IAAI;CAIlC"}

package/dist/commands/base/CommandHandler.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Command handler interface
+ * Defines the contract for command execution
+ */
+import { Command } from 'commander';
+export interface CommandContext {
+    command: Command;
+    args: Record<string, unknown>;
+    options: Record<string, unknown>;
+}
+export interface CommandHandler {
+    /**
+     * Execute the command
+     * @param context - Command context with args and options
+     * @returns Promise that resolves when command completes
+     */
+    execute(context: CommandContext): Promise<void>;
+}
+export interface CommandMiddleware {
+    /**
+     * Process the command before or after execution
+     * @param context - Command context
+     * @param next - Next middleware or handler
+     * @returns Promise that resolves when processing completes
+     */
+    process(context: CommandContext, next: () => Promise<void>): Promise<void>;
+}
+//# sourceMappingURL=CommandHandler.d.ts.map

package/dist/commands/base/CommandHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CommandHandler.d.ts","sourceRoot":"","sources":["../../../src/commands/base/CommandHandler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACjD;AAED,MAAM,WAAW,iBAAiB;IAChC;;;;;OAKG;IACH,OAAO,CAAC,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5E"}

package/dist/commands/base/command-wrapper.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Command wrapper utilities
+ * Provides helpers for wrapping commands with standardized error handling
+ */
+import { Logger } from '../../utils/logger';
+import { ConfigRepository } from '../../repositories/config-repository';
+export interface CommandWrapperOptions {
+    logger?: Logger;
+    configRepository?: ConfigRepository;
+    requireAuth?: boolean;
+    requireOrganization?: boolean;
+}
+/**
+ * Wrap a command action with standardized error handling and validation
+ */
+export declare function wrapCommand(action: (options: Record<string, unknown>) => Promise<void>, wrapperOptions?: CommandWrapperOptions): (options: Record<string, unknown>) => Promise<void>;
+/**
+ * Create a command handler that automatically handles errors
+ */
+export declare function createCommandHandler(action: (options: Record<string, unknown>) => Promise<void>, options?: CommandWrapperOptions): (options: Record<string, unknown>) => void;
+//# sourceMappingURL=command-wrapper.d.ts.map

package/dist/commands/base/command-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-wrapper.d.ts","sourceRoot":"","sources":["../../../src/commands/base/command-wrapper.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAExE,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;GAEG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,EAC3D,cAAc,GAAE,qBAA0B,GACzC,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAgCrD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,EAC3D,OAAO,GAAE,qBAA0B,GAClC,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAW5C"}

package/dist/commands/base/middleware.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Built-in command middleware
+ */
+import { CommandContext, CommandMiddleware } from './CommandHandler';
+import { Logger } from '../../utils/logger';
+import { ConfigRepository } from '../../repositories/config-repository';
+/**
+ * Logging middleware - logs command execution
+ */
+export declare class LoggingMiddleware implements CommandMiddleware {
+    private logger;
+    constructor(logger: Logger);
+    process(context: CommandContext, next: () => Promise<void>): Promise<void>;
+}
+/**
+ * Validation middleware - validates command context
+ */
+export declare class ValidationMiddleware implements CommandMiddleware {
+    private configRepository;
+    private requireAuth;
+    private requireOrganization;
+    constructor(configRepository: ConfigRepository, requireAuth?: boolean, requireOrganization?: boolean);
+    process(context: CommandContext, next: () => Promise<void>): Promise<void>;
+}
+/**
+ * Performance monitoring middleware
+ */
+export declare class PerformanceMiddleware implements CommandMiddleware {
+    private logger;
+    private threshold;
+    constructor(logger: Logger, thresholdMs?: number);
+    process(context: CommandContext, next: () => Promise<void>): Promise<void>;
+}
+//# sourceMappingURL=middleware.d.ts.map

package/dist/commands/base/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../../src/commands/base/middleware.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrE,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAExE;;GAEG;AACH,qBAAa,iBAAkB,YAAW,iBAAiB;IAC7C,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAE5B,OAAO,CAAC,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CAejF;AAED;;GAEG;AACH,qBAAa,oBAAqB,YAAW,iBAAiB;IAE1D,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,mBAAmB;gBAFnB,gBAAgB,EAAE,gBAAgB,EAClC,WAAW,GAAE,OAAe,EAC5B,mBAAmB,GAAE,OAAe;IAGxC,OAAO,CAAC,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CAoBjF;AAED;;GAEG;AACH,qBAAa,qBAAsB,YAAW,iBAAiB;IAGjD,OAAO,CAAC,MAAM;IAF1B,OAAO,CAAC,SAAS,CAAS;gBAEN,MAAM,EAAE,MAAM,EAAE,WAAW,GAAE,MAAa;IAIxD,OAAO,CAAC,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CASjF"}

package/dist/commands/config.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function setupConfigCommands(program: Command): void;
+//# sourceMappingURL=config.d.ts.map

package/dist/commands/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/commands/config.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAqH1D"}

package/dist/commands/connectivity.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function setupConnectivityCommands(program: Command): void;
+//# sourceMappingURL=connectivity.d.ts.map

package/dist/commands/connectivity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectivity.d.ts","sourceRoot":"","sources":["../../src/commands/connectivity.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAUpC,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAgEhE"}

package/dist/commands/debug.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function setupDebugCommands(program: Command): void;
+//# sourceMappingURL=debug.d.ts.map

package/dist/commands/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../src/commands/debug.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA+bzD"}