@edgible-team/cli 1.0.1

package/dist/commands/base/command-wrapper.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Command wrapper utilities
+ * Provides helpers for wrapping commands with standardized error handling
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapCommand = wrapCommand;
+exports.createCommandHandler = createCommandHandler;
+const errors_1 = require("../../utils/errors");
+/**
+ * Wrap a command action with standardized error handling and validation
+ */
+function wrapCommand(action, wrapperOptions = {}) {
+    return async (options) => {
+        try {
+            // Validate context if required
+            if (wrapperOptions.configRepository) {
+                const { requireAuth = false, requireOrganization = false } = wrapperOptions;
+                if (requireAuth) {
+                    const config = wrapperOptions.configRepository.getConfig();
+                    const hasTokens = !!(config.accessToken || config.idToken);
+                    const hasDeviceCreds = !!(config.deviceId && config.devicePassword);
+                    if (!hasTokens && !hasDeviceCreds) {
+                        throw new errors_1.ConfigError('Not authenticated. Please run "edgible login" first.');
+                    }
+                }
+                if (requireOrganization) {
+                    const config = wrapperOptions.configRepository.getConfig();
+                    if (!config.organizationId) {
+                        throw new errors_1.ConfigError('No organization found. Please login first.');
+                    }
+                }
+            }
+            // Execute the command
+            await action(options);
+        }
+        catch (error) {
+            // Ensure all errors go through ErrorHandler
+            errors_1.ErrorHandler.handleError(error);
+        }
+    };
+}
+/**
+ * Create a command handler that automatically handles errors
+ */
+function createCommandHandler(action, options = {}) {
+    const wrapped = wrapCommand(action, options);
+    return (opts) => {
+        // Commander expects synchronous handlers, but we need async
+        // So we'll handle the promise and let ErrorHandler exit if needed
+        wrapped(opts).catch((error) => {
+            // This should not happen as wrapCommand handles errors,
+            // but just in case:
+            errors_1.ErrorHandler.handleError(error);
+        });
+    };
+}
+//# sourceMappingURL=command-wrapper.js.map

package/dist/commands/base/middleware.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Built-in command middleware
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceMiddleware = exports.ValidationMiddleware = exports.LoggingMiddleware = void 0;
+/**
+ * Logging middleware - logs command execution
+ */
+class LoggingMiddleware {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async process(context, next) {
+        const commandName = context.command.name();
+        this.logger.debug(`Executing command: ${commandName}`, context.options);
+        const startTime = Date.now();
+        try {
+            await next();
+            const duration = Date.now() - startTime;
+            this.logger.debug(`Command completed: ${commandName} (${duration}ms)`);
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            this.logger.error(`Command failed: ${commandName} (${duration}ms)`, error);
+            throw error;
+        }
+    }
+}
+exports.LoggingMiddleware = LoggingMiddleware;
+/**
+ * Validation middleware - validates command context
+ */
+class ValidationMiddleware {
+    constructor(configRepository, requireAuth = false, requireOrganization = false) {
+        this.configRepository = configRepository;
+        this.requireAuth = requireAuth;
+        this.requireOrganization = requireOrganization;
+    }
+    async process(context, next) {
+        if (this.requireAuth) {
+            const config = this.configRepository.getConfig();
+            const hasTokens = !!(config.accessToken || config.idToken);
+            const hasDeviceCreds = !!(config.deviceId && config.devicePassword);
+            if (!hasTokens && !hasDeviceCreds) {
+                throw new Error('Not authenticated. Please run "edgible login" first.');
+            }
+        }
+        if (this.requireOrganization) {
+            const config = this.configRepository.getConfig();
+            if (!config.organizationId) {
+                throw new Error('No organization found. Please login first.');
+            }
+        }
+        await next();
+    }
+}
+exports.ValidationMiddleware = ValidationMiddleware;
+/**
+ * Performance monitoring middleware
+ */
+class PerformanceMiddleware {
+    constructor(logger, thresholdMs = 1000) {
+        this.logger = logger;
+        this.threshold = thresholdMs;
+    }
+    async process(context, next) {
+        const startTime = Date.now();
+        await next();
+        const duration = Date.now() - startTime;
+        if (duration > this.threshold) {
+            this.logger.warn(`Slow command execution: ${context.command.name()} took ${duration}ms`);
+        }
+    }
+}
+exports.PerformanceMiddleware = PerformanceMiddleware;
+//# sourceMappingURL=middleware.js.map

package/dist/commands/config.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupConfigCommands = setupConfigCommands;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const command_wrapper_1 = require("./base/command-wrapper");
+const container_1 = require("../di/container");
+const types_1 = require("../di/types");
+const errors_1 = require("../utils/errors");
+function setupConfigCommands(program) {
+    const configCommand = program
+        .command('config')
+        .description('Manage CLI configuration');
+    configCommand
+        .command('set <key> <value>')
+        .description('Set a configuration value')
+        .action(async (key, value) => {
+        try {
+            const container = (0, container_1.getContainer)();
+            const logger = container.get(types_1.TYPES.Logger);
+            const configRepository = container.get(types_1.TYPES.ConfigRepository);
+            const config = configRepository.getConfig();
+            if (!(key in config)) {
+                throw new Error(`Invalid config key: ${key}`);
+            }
+            configRepository.updateConfig({ [key]: value });
+            logger.info('Configuration updated', { key, value });
+            console.log(chalk_1.default.green(`✓ ${key} has been set.`));
+        }
+        catch (error) {
+            errors_1.ErrorHandler.handleError(error);
+        }
+    });
+    configCommand
+        .command('get <key>')
+        .description('Get a configuration value')
+        .action(async (key) => {
+        try {
+            const container = (0, container_1.getContainer)();
+            const logger = container.get(types_1.TYPES.Logger);
+            const configRepository = container.get(types_1.TYPES.ConfigRepository);
+            const config = configRepository.getConfig();
+            if (!(key in config)) {
+                throw new Error(`Invalid config key: ${key}`);
+            }
+            const value = config[key];
+            if (value) {
+                console.log(value);
+            }
+            else {
+                logger.debug('Configuration key not found', { key });
+                console.log(chalk_1.default.yellow('⚠ Key not found.'));
+            }
+        }
+        catch (error) {
+            errors_1.ErrorHandler.handleError(error);
+        }
+    });
+    configCommand
+        .command('list')
+        .description('List all configuration values')
+        .alias('ls')
+        .action((0, command_wrapper_1.wrapCommand)(async () => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        const config = configRepository.getConfig();
+        logger.debug('Listing configuration');
+        console.log(JSON.stringify(config, null, 2));
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+    configCommand
+        .command('reset')
+        .description('Reset the CLI configuration')
+        .option('--non-interactive', 'Run in non-interactive mode (skip confirmation)')
+        .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);
+        if (options.nonInteractive) {
+            // Non-interactive mode: reset without confirmation
+            configRepository.clearConfig();
+            logger.info('Configuration reset (non-interactive)');
+            console.log(chalk_1.default.green('✓ CLI state has been reset'));
+            console.log(chalk_1.default.gray('Run "edgible login" to start fresh'));
+        }
+        else {
+            // Interactive mode: ask for confirmation
+            const confirm = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'reset',
+                    message: 'Are you sure you want to reset all CLI settings?',
+                    default: false,
+                },
+            ]);
+            if (confirm.reset) {
+                configRepository.clearConfig();
+                logger.info('Configuration reset (interactive)');
+                console.log(chalk_1.default.green('✓ CLI state has been reset'));
+                console.log(chalk_1.default.gray('Run "edgible login" to start fresh'));
+            }
+            else {
+                logger.debug('Configuration reset cancelled');
+                console.log(chalk_1.default.gray('Reset cancelled'));
+            }
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+}
+//# sourceMappingURL=config.js.map

package/dist/commands/connectivity.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupConnectivityCommands = setupConnectivityCommands;
+const chalk_1 = __importDefault(require("chalk"));
+const command_wrapper_1 = require("./base/command-wrapper");
+const container_1 = require("../di/container");
+const types_1 = require("../di/types");
+const input_parser_1 = require("./utils/input-parser");
+function setupConnectivityCommands(program) {
+    const connectivityCommand = program
+        .command('connectivity')
+        .description('Test network connectivity');
+    connectivityCommand
+        .command('test')
+        .description('Test connectivity for an application')
+        .option('-a, --application <id>', 'Application ID to test')
+        .option('-h, --host <host>', 'Host to test')
+        .option('-p, --port <port>', 'Port to test')
+        .option('-t, --timeout <timeout>', 'Timeout in milliseconds', '5000')
+        .action((0, command_wrapper_1.wrapCommand)(async (options) => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        const connectivityTester = container.get(types_1.TYPES.ConnectivityTester);
+        if (options.application) {
+            // Test specific application
+            logger.info('Testing connectivity for application', { applicationId: options.application });
+            console.log(chalk_1.default.blue(`Testing connectivity for application: ${options.application}`));
+            // Get application details (this would need to be implemented)
+            console.log(chalk_1.default.yellow('Application testing not yet implemented'));
+        }
+        else if (options.host && options.port) {
+            // Test specific host and port
+            const port = (0, input_parser_1.parsePort)(options.port);
+            const timeout = (0, input_parser_1.parseNumber)(options.timeout, 1, 60000) || 5000;
+            logger.info('Testing port connectivity', { host: options.host, port, timeout });
+            console.log(chalk_1.default.blue(`Testing connectivity to ${options.host}:${port}`));
+            const result = await connectivityTester.testPortConnectivity(options.host, port, 'tcp', timeout);
+            if (result.success) {
+                logger.info('Connection successful', { latency: result.latency });
+                console.log(chalk_1.default.green('✓ Connection successful'));
+                console.log(chalk_1.default.white(`  Latency: ${result.latency}ms`));
+            }
+            else {
+                logger.warn('Connection failed', { error: result.error });
+                console.log(chalk_1.default.red('✗ Connection failed'));
+                console.log(chalk_1.default.red(`  Error: ${result.error}`));
+            }
+        }
+        else {
+            throw new Error('Please provide either --application or --host and --port');
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+}
+//# sourceMappingURL=connectivity.js.map

package/dist/commands/debug.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupDebugCommands = setupDebugCommands;
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+const command_wrapper_1 = require("./base/command-wrapper");
+const container_1 = require("../di/container");
+const types_1 = require("../di/types");
+function setupDebugCommands(program) {
+    const debugCommand = program
+        .command('debug')
+        .description('Debugging commands (not for production)');
+    debugCommand
+        .command('get-start-command')
+        .description('Get the command used to start the agent')
+        .action((0, command_wrapper_1.wrapCommand)(async () => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        const agentManager = container.get(types_1.TYPES.LocalAgentManager);
+        logger.debug('Getting agent start command');
+        const startCommand = await agentManager.getStartCommand();
+        console.log(chalk_1.default.green('Agent start command:'));
+        console.log(startCommand);
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+    debugCommand
+        .command('logs')
+        .description('Show agent logs')
+        .option('--watch', 'Watch for new logs')
+        .action((0, command_wrapper_1.wrapCommand)(async (options) => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        const agentManager = container.get(types_1.TYPES.LocalAgentManager);
+        const logFilePath = agentManager.getLogFilePath();
+        if (!fs.existsSync(logFilePath)) {
+            logger.debug('Log file does not exist', { logFilePath });
+            console.log(chalk_1.default.yellow('Log file does not exist yet.'));
+            return;
+        }
+        if (options.watch) {
+            logger.debug('Watching agent logs');
+            console.log(chalk_1.default.blue('Watching agent logs (Ctrl+C to stop)...'));
+            const tail = (0, child_process_1.spawn)('tail', ['-f', logFilePath]);
+            tail.stdout.on('data', (data) => {
+                process.stdout.write(data);
+            });
+            tail.stderr.on('data', (data) => {
+                process.stderr.write(data);
+            });
+        }
+        else {
+            logger.debug('Reading agent logs');
+            const logs = fs.readFileSync(logFilePath, 'utf8');
+            console.log(logs);
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+}
+//# sourceMappingURL=debug.js.map

package/dist/commands/discover.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupDiscoverCommands = setupDiscoverCommands;
+const chalk_1 = __importDefault(require("chalk"));
+const ToolDetector_1 = require("../detection/ToolDetector");
+const WorkloadDetector_1 = require("../detection/WorkloadDetector");
+const SystemCapabilityDetector_1 = require("../detection/SystemCapabilityDetector");
+const command_wrapper_1 = require("./base/command-wrapper");
+const container_1 = require("../di/container");
+const types_1 = require("../di/types");
+function setupDiscoverCommands(program) {
+    const discoverCommand = program
+        .command('discover')
+        .description('Discover local resources');
+    discoverCommand
+        .command('tools')
+        .description('Check available container/VM/workload management tools')
+        .action((0, command_wrapper_1.wrapCommand)(async () => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        logger.debug('Detecting infrastructure tools');
+        console.log(chalk_1.default.blue('Detecting available infrastructure tools...\n'));
+        const detectedTools = await ToolDetector_1.ToolDetector.detectTools();
+        ToolDetector_1.ToolDetector.displayDetectedTools(detectedTools);
+        const summary = ToolDetector_1.ToolDetector.getToolSummary(detectedTools);
+        console.log(chalk_1.default.gray(`\n📊 Summary: ${summary}`));
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+    discoverCommand
+        .command('workloads')
+        .description('List all running workloads and applications')
+        .option('--json', 'Output as JSON')
+        .action((0, command_wrapper_1.wrapCommand)(async (options) => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        logger.debug('Detecting workloads', { json: options.json });
+        if (options.json) {
+            const workloads = await WorkloadDetector_1.WorkloadDetector.detectWorkloads();
+            const running = workloads.filter((w) => w.status === 'running');
+            console.log(JSON.stringify({
+                workloads: running.map((w) => ({
+                    id: w.id,
+                    name: w.name,
+                    type: w.type,
+                    description: w.description,
+                    port: w.ports?.[0]?.containerPort,
+                    status: w.status,
+                })),
+            }, null, 2));
+        }
+        else {
+            console.log(chalk_1.default.blue('Detecting running workloads...\n'));
+            const workloads = await WorkloadDetector_1.WorkloadDetector.detectWorkloads();
+            WorkloadDetector_1.WorkloadDetector.displayWorkloads(workloads);
+            const summary = WorkloadDetector_1.WorkloadDetector.getWorkloadSummary(workloads);
+            console.log(chalk_1.default.gray(`\n📊 Summary: ${summary}`));
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+    discoverCommand
+        .command('capabilities')
+        .description('Detect system capabilities (CPU, RAM, GPU) and recommend LLM models')
+        .alias('caps')
+        .option('--json', 'Output as JSON')
+        .action((0, command_wrapper_1.wrapCommand)(async (options) => {
+        const container = (0, container_1.getContainer)();
+        const logger = container.get(types_1.TYPES.Logger);
+        logger.debug('Detecting system capabilities', { json: options.json });
+        if (options.json) {
+            const capabilities = await SystemCapabilityDetector_1.SystemCapabilityDetector.detectCapabilities();
+            console.log(JSON.stringify({
+                cpu: {
+                    model: capabilities.cpu.model,
+                    cores: capabilities.cpu.cores,
+                    threads: capabilities.cpu.threads,
+                    architecture: capabilities.cpu.architecture,
+                    speedGHz: capabilities.cpu.speed,
+                },
+                memory: {
+                    totalGB: capabilities.memory.totalGB,
+                    freeGB: capabilities.memory.freeGB,
+                    usedGB: capabilities.memory.usedGB,
+                },
+                gpu: capabilities.gpu ? {
+                    name: capabilities.gpu.name,
+                    vendor: capabilities.gpu.vendor,
+                    vramGB: capabilities.gpu.vramGB,
+                    driverVersion: capabilities.gpu.driverVersion,
+                    available: capabilities.gpu.available,
+                } : null,
+                platform: capabilities.platform,
+                hasEnoughResources: capabilities.hasEnoughResources,
+                recommendedModels: capabilities.recommendedModels.map((m) => ({
+                    modelName: m.modelName,
+                    size: m.size,
+                    parameters: m.parameters,
+                    minRamGB: m.minRamGB,
+                    minVramGB: m.minVramGB,
+                    recommendedRamGB: m.recommendedRamGB,
+                    recommendedVramGB: m.recommendedVramGB,
+                    suitability: m.suitability,
+                    reasoning: m.reasoning,
+                })),
+                gpuDriverSupport: {
+                    cuda: {
+                        available: capabilities.gpuDriverSupport.cuda.available,
+                        version: capabilities.gpuDriverSupport.cuda.version,
+                        toolkitAvailable: capabilities.gpuDriverSupport.cuda.toolkitAvailable,
+                    },
+                    rocm: {
+                        available: capabilities.gpuDriverSupport.rocm.available,
+                        version: capabilities.gpuDriverSupport.rocm.version,
+                    },
+                    metal: {
+                        available: capabilities.gpuDriverSupport.metal.available,
+                    },
+                    dockerGpuSupport: {
+                        available: capabilities.gpuDriverSupport.dockerGpuSupport.available,
+                        runtime: capabilities.gpuDriverSupport.dockerGpuSupport.runtime,
+                        nvidiaContainerRuntime: capabilities.gpuDriverSupport.dockerGpuSupport.nvidiaContainerRuntime,
+                        nvidiaDocker: capabilities.gpuDriverSupport.dockerGpuSupport.nvidiaDocker,
+                    },
+                    ollamaGpuReady: capabilities.gpuDriverSupport.ollamaGpuReady,
+                    ollamaGpuReason: capabilities.gpuDriverSupport.ollamaGpuReason,
+                },
+            }, null, 2));
+        }
+        else {
+            console.log(chalk_1.default.blue('Detecting system capabilities...\n'));
+            const capabilities = await SystemCapabilityDetector_1.SystemCapabilityDetector.detectCapabilities();
+            SystemCapabilityDetector_1.SystemCapabilityDetector.displayCapabilities(capabilities);
+            const summary = SystemCapabilityDetector_1.SystemCapabilityDetector.getCapabilitySummary(capabilities);
+            console.log(chalk_1.default.gray(`\n📊 Summary: ${summary}`));
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+}
+//# sourceMappingURL=discover.js.map