@edgible-team/cli 1.0.1

package/dist/commands/agent.js

@@ -0,0 +1,1280 @@
+"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.setupAgentCommands = setupAgentCommands;
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const fsPromises = __importStar(require("fs/promises"));
+const AgentStatusManager_1 = require("../services/AgentStatusManager");
+const command_wrapper_1 = require("./base/command-wrapper");
+const container_1 = require("../di/container");
+const types_1 = require("../di/types");
+const config_validator_1 = require("./utils/config-validator");
+const DependencyInstaller_1 = require("../services/DependencyInstaller");
+const PlatformDetector_1 = require("../utils/PlatformDetector");
+const DaemonManagerFactory_1 = require("../services/daemon/DaemonManagerFactory");
+const PathResolver_1 = require("../utils/PathResolver");
+const urls_1 = require("../utils/urls");
+const log_formatter_1 = require("../utils/log-formatter");
+function setupAgentCommands(program) {
+    const agentCommand = program
+        .command('agent')
+        .description('Manage the local Edgible agent');
+    agentCommand
+        .command('status')
+        .description('Check local agent status')
+        .option('--watch', 'Watch status changes in real-time')
+        .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 agentManager = container.get(types_1.TYPES.LocalAgentManager);
+        const statusManager = new AgentStatusManager_1.AgentStatusManager();
+        const config = configRepository.getConfig();
+        if (options.watch) {
+            logger.debug('Watching agent status');
+            console.log(chalk_1.default.blue('Watching agent status (Ctrl+C to stop)...'));
+            let lastStatus = null;
+            statusManager.startWatching((result) => {
+                // Only update display if status changed significantly
+                if (!lastStatus || JSON.stringify(lastStatus) !== JSON.stringify(result)) {
+                    lastStatus = result;
+                    // Show installation type first
+                    if (config.agentInstallationType) {
+                        console.log(chalk_1.default.gray(`\nInstallation Type: ${config.agentInstallationType}`));
+                    }
+                    agentManager.displayAgentStatus(result.status);
+                }
+            });
+        }
+        else {
+            logger.debug('Checking agent status');
+            // Show installation type
+            if (config.agentInstallationType) {
+                console.log(chalk_1.default.blue('\n📋 Agent Configuration'));
+                console.log(chalk_1.default.gray(`  Installation Type: ${config.agentInstallationType}`));
+                if (config.agentServiceName) {
+                    console.log(chalk_1.default.gray(`  Service Name: ${config.agentServiceName}`));
+                }
+                if (config.agentContainerName) {
+                    console.log(chalk_1.default.gray(`  Container Name: ${config.agentContainerName}`));
+                }
+                console.log('');
+            }
+            // Get daemon status if available
+            if (config.agentInstallationType) {
+                try {
+                    const daemonManager = DaemonManagerFactory_1.DaemonManagerFactory.fromConfig(config.agentInstallationType);
+                    if (daemonManager) {
+                        console.log(chalk_1.default.blue('🔧 Daemon Status'));
+                        const daemonStatus = await daemonManager.status();
+                        console.log(chalk_1.default.gray(`  Running: ${daemonStatus.running ? chalk_1.default.green('Yes') : chalk_1.default.red('No')}`));
+                        console.log(chalk_1.default.gray(`  Enabled: ${daemonStatus.enabled ? chalk_1.default.green('Yes') : chalk_1.default.gray('No')}`));
+                        if (daemonStatus.pid) {
+                            console.log(chalk_1.default.gray(`  PID: ${daemonStatus.pid}`));
+                        }
+                        console.log('');
+                    }
+                }
+                catch (error) {
+                    console.log(chalk_1.default.yellow('⚠  Could not fetch daemon status\n'));
+                }
+            }
+            // Get agent status from status file
+            console.log(chalk_1.default.blue('🤖 Agent Status'));
+            const status = await agentManager.checkLocalAgentStatus();
+            agentManager.displayAgentStatus(status);
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+    agentCommand
+        .command('install')
+        .description('Install and configure the local agent as a daemon')
+        .option('--type <type>', 'Installation type (systemd|launchd|windows-service|docker|podman)')
+        .option('--dev', 'Run in development mode (foreground, no daemon)')
+        .option('--build', 'Build container image locally instead of pulling')
+        .option('--registry <url>', 'Container registry URL for pulling pre-built images')
+        .option('--local', 'Use local agent build from agent-v2/dist/ (development only)')
+        .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 edgibleService = container.get(types_1.TYPES.EdgibleService);
+        const authService = container.get(types_1.TYPES.AuthService);
+        const agentManager = container.get(types_1.TYPES.LocalAgentManager);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+            requireOrganization: true,
+        });
+        console.log(chalk_1.default.blue.bold('\n═══════════════════════════════════════════'));
+        console.log(chalk_1.default.blue.bold('   Edgible Agent Installation'));
+        console.log(chalk_1.default.blue.bold('═══════════════════════════════════════════\n'));
+        // Step 1: Check platform and root privileges
+        const platform = PlatformDetector_1.PlatformDetector.getPlatform();
+        const isRoot = await PlatformDetector_1.PlatformDetector.isRoot();
+        console.log(chalk_1.default.gray(`Platform: ${platform}`));
+        console.log(chalk_1.default.gray(`Running as ${isRoot ? 'root/administrator' : 'regular user'}\n`));
+        if (!isRoot) {
+            console.log(chalk_1.default.yellow('⚠  ' + PlatformDetector_1.PlatformDetector.getRootRequirementMessage()));
+            console.log(chalk_1.default.gray('   Some installation options require elevated privileges.\n'));
+        }
+        // Step 2: Device Selection (moved from start command)
+        const config = configRepository.getConfig();
+        let deviceId = config.deviceId;
+        let devicePassword = config.devicePassword;
+        console.log(chalk_1.default.blue('📱 Device Selection'));
+        console.log(chalk_1.default.gray('Select which serving device this agent should represent:\n'));
+        try {
+            // Fetch available serving devices
+            const servingDevicesResp = await edgibleService.listServingDevices();
+            const servingDevices = servingDevicesResp?.devices || [];
+            if (servingDevices.length > 0) {
+                // Show list of devices to select from
+                const deviceChoices = servingDevices.map((d) => {
+                    const isCurrentDevice = config.deviceId === d.id;
+                    const displayName = `${d.name || d.id}${d.description ? ` - ${d.description}` : ''}${isCurrentDevice ? chalk_1.default.gray(' (current)') : ''}`;
+                    return {
+                        name: displayName,
+                        value: d.id
+                    };
+                });
+                // Add option to create new device
+                deviceChoices.push({
+                    name: chalk_1.default.cyan('➕ Create new serving device'),
+                    value: '__create_new__'
+                });
+                const { selectedDeviceId } = await inquirer_1.default.prompt([{
+                        type: 'list',
+                        name: 'selectedDeviceId',
+                        message: 'Select serving device:',
+                        choices: deviceChoices,
+                        default: config.deviceId || undefined
+                    }]);
+                if (selectedDeviceId === '__create_new__') {
+                    // Create new device
+                    const deviceNameAnswer = await inquirer_1.default.prompt([{
+                            type: 'input',
+                            name: 'deviceName',
+                            message: 'Enter a name for this device:',
+                            default: `${os.hostname()}-${os.platform()}`,
+                            validate: (input) => {
+                                if (!input.trim()) {
+                                    return 'Device name is required';
+                                }
+                                return true;
+                            }
+                        }]);
+                    const descriptionAnswer = await inquirer_1.default.prompt([{
+                            type: 'input',
+                            name: 'description',
+                            message: 'Enter device description (optional):',
+                            default: `Serving device: ${deviceNameAnswer.deviceName}`
+                        }]);
+                    console.log(chalk_1.default.gray('\nCreating device...'));
+                    const createResponse = await edgibleService.createServingDevice({
+                        name: deviceNameAnswer.deviceName.trim(),
+                        description: descriptionAnswer.description.trim()
+                    });
+                    deviceId = createResponse.device.id;
+                    devicePassword = createResponse.device.password;
+                    console.log(chalk_1.default.green(`✓ Device created: ${deviceId}`));
+                    console.log(chalk_1.default.yellow(`\n⚠  Device Password: ${devicePassword}`));
+                    console.log(chalk_1.default.yellow('⚠  Please save this password securely!\n'));
+                    // Verify device credentials
+                    if (devicePassword && deviceId) {
+                        console.log(chalk_1.default.gray('Verifying device credentials...'));
+                        try {
+                            const isValid = await authService.verifyDeviceCredentials(deviceId, devicePassword);
+                            if (isValid) {
+                                console.log(chalk_1.default.green('✓ Device credentials verified\n'));
+                            }
+                        }
+                        catch (verifyError) {
+                            console.log(chalk_1.default.yellow('⚠  Could not verify device credentials\n'));
+                        }
+                    }
+                    // Save device credentials to config
+                    configRepository.updateConfig({
+                        deviceId: deviceId,
+                        deviceName: deviceNameAnswer.deviceName.trim(),
+                        devicePassword: devicePassword,
+                        deviceType: 'serving'
+                    });
+                }
+                else {
+                    // Use existing device - need to fetch full details to get password
+                    deviceId = selectedDeviceId;
+                    if (!deviceId) {
+                        throw new Error('No device selected');
+                    }
+                    console.log(chalk_1.default.gray('Retrieving device credentials...\n'));
+                    // Fetch device details to get the plaintext password
+                    const deviceResponse = await edgibleService.getDevice(deviceId);
+                    devicePassword = deviceResponse.device?.password || '';
+                    if (!devicePassword) {
+                        throw new Error('Could not retrieve device password from API');
+                    }
+                    // Save device credentials to config
+                    configRepository.updateConfig({
+                        deviceId,
+                        devicePassword,
+                        deviceType: 'serving'
+                    });
+                    console.log(chalk_1.default.green(`✓ Using device: ${deviceId}\n`));
+                }
+            }
+            else {
+                // No devices exist, must create one
+                console.log(chalk_1.default.yellow('No serving devices found. Creating a new one...\n'));
+                const deviceNameAnswer = await inquirer_1.default.prompt([{
+                        type: 'input',
+                        name: 'deviceName',
+                        message: 'Enter a name for this device:',
+                        default: `${os.hostname()}-${os.platform()}`,
+                        validate: (input) => input.trim().length > 0 || 'Device name is required'
+                    }]);
+                const createResponse = await edgibleService.createServingDevice({
+                    name: deviceNameAnswer.deviceName.trim(),
+                    description: `Serving device: ${deviceNameAnswer.deviceName}`
+                });
+                deviceId = createResponse.device.id;
+                devicePassword = createResponse.device.password;
+                console.log(chalk_1.default.green(`✓ Device created: ${deviceId}`));
+                console.log(chalk_1.default.yellow(`\n⚠  Device Password: ${devicePassword}`));
+                console.log(chalk_1.default.yellow('⚠  Please save this password securely!\n'));
+                configRepository.updateConfig({
+                    deviceId,
+                    deviceName: deviceNameAnswer.deviceName.trim(),
+                    devicePassword,
+                    deviceType: 'serving'
+                });
+            }
+        }
+        catch (error) {
+            logger.error('Error during device selection', error);
+            const errorMessage = error instanceof Error ? error.message : 'An unexpected error occurred';
+            console.error(chalk_1.default.red('Error during device selection:'), errorMessage);
+            throw error;
+        }
+        // Verify we have device credentials
+        if (!deviceId || !devicePassword) {
+            throw new Error('Device credentials are required');
+        }
+        // Step 3: Installation Method Selection
+        console.log(chalk_1.default.blue('🔧 Installation Method'));
+        console.log(chalk_1.default.gray('Choose how to run the agent:\n'));
+        const availableOptions = await PlatformDetector_1.PlatformDetector.getAvailableOptions();
+        if (availableOptions.length === 0) {
+            console.error(chalk_1.default.red('✗ No installation methods available on this system'));
+            console.error(chalk_1.default.yellow('\nPlease install Docker or Podman to continue.'));
+            return;
+        }
+        let selectedType;
+        if (options.type) {
+            // Type specified via flag
+            selectedType = options.type;
+            const option = availableOptions.find(opt => opt.type === selectedType);
+            if (!option) {
+                console.error(chalk_1.default.red(`✗ Installation type '${selectedType}' not found`));
+                return;
+            }
+            if (!option.available) {
+                console.error(chalk_1.default.red(`✗ Installation type '${selectedType}' is not available on this system`));
+                console.error(chalk_1.default.yellow(`  Requirements: ${option.requires.join(', ')}`));
+                return;
+            }
+        }
+        else {
+            // Interactive selection
+            const choices = availableOptions.map(opt => {
+                const status = opt.available ? chalk_1.default.green('✓') : chalk_1.default.red('✗');
+                const rootBadge = opt.requiresRoot ? chalk_1.default.yellow('[requires root]') : '';
+                return {
+                    name: `${status} ${opt.name} ${rootBadge}\n  ${chalk_1.default.gray(opt.description)}\n  ${chalk_1.default.gray('Pros:')} ${opt.pros.join(', ')}\n  ${chalk_1.default.gray('Best for:')} ${opt.bestFor}`,
+                    value: opt.type,
+                    disabled: !opt.available ? `Requires: ${opt.requires.join(', ')}` : false
+                };
+            });
+            const { installType } = await inquirer_1.default.prompt([{
+                    type: 'list',
+                    name: 'installType',
+                    message: 'Select installation method:',
+                    choices,
+                    pageSize: 10
+                }]);
+            selectedType = installType;
+        }
+        console.log(chalk_1.default.green(`\n✓ Selected: ${selectedType}\n`));
+        // Validate --local flag is only used with system service managers
+        if (options.local && selectedType !== 'systemd' && selectedType !== 'launchd') {
+            console.error(chalk_1.default.red('✗ --local flag is only supported with systemd or launchd installation'));
+            console.error(chalk_1.default.yellow('  Please use --type systemd/launchd or omit --type for interactive selection'));
+            return;
+        }
+        // Step 4: Check and Install Dependencies (for non-container installations)
+        const isContainerInstall = selectedType === 'docker' || selectedType === 'podman';
+        if (!isContainerInstall) {
+            console.log(chalk_1.default.blue('🔍 Checking System Dependencies'));
+            console.log(chalk_1.default.gray('Verifying required tools are installed...\n'));
+            const dependencyInstaller = new DependencyInstaller_1.DependencyInstaller();
+            try {
+                await dependencyInstaller.checkAndInstallDependencies({
+                    includeWireGuardGo: false, // Use kernel WireGuard by default
+                    includeIptables: platform === 'linux', // Only check iptables on Linux
+                    autoInstall: false // Prompt user for installation
+                });
+                console.log(chalk_1.default.green('✓ Dependencies verified\n'));
+            }
+            catch (error) {
+                console.error(chalk_1.default.red('✗ Dependency check failed'));
+                console.error(chalk_1.default.red(`  ${error instanceof Error ? error.message : String(error)}`));
+                console.log(chalk_1.default.yellow('\n⚠  Some dependencies are missing. The agent may not function correctly.'));
+                console.log(chalk_1.default.yellow('   You can install them manually or run: edgible agent setup --auto-install\n'));
+                // Ask if user wants to continue anyway
+                const { continueAnyway } = await inquirer_1.default.prompt([{
+                        type: 'confirm',
+                        name: 'continueAnyway',
+                        message: 'Continue with installation anyway?',
+                        default: false
+                    }]);
+                if (!continueAnyway) {
+                    console.log(chalk_1.default.gray('Installation cancelled.'));
+                    return;
+                }
+            }
+        }
+        // Step 5: Install Agent Files (only for native installations)
+        let agentPath;
+        // Use system path for system services, user path for others
+        const useSystemPath = selectedType === 'systemd' ||
+            selectedType === 'launchd' ||
+            selectedType === 'windows-service' ||
+            selectedType === 'docker' ||
+            selectedType === 'podman';
+        const configPath = PathResolver_1.PathResolver.getAgentConfigPath(useSystemPath);
+        if (isContainerInstall) {
+            // For container installations, agent is in the image
+            console.log(chalk_1.default.blue('📦 Using Container Image'));
+            console.log(chalk_1.default.gray('  Agent files will be managed inside the container\n'));
+            // Ensure config, applications, and logs directories exist with proper permissions
+            // Note: System paths may require sudo, but the daemon manager will handle this
+            try {
+                await fsPromises.mkdir(configPath, { recursive: true, mode: 0o755 });
+                await fsPromises.mkdir(path.join(configPath, 'applications'), { recursive: true, mode: 0o755 });
+                await fsPromises.mkdir(path.join(configPath, 'logs'), { recursive: true, mode: 0o755 });
+            }
+            catch (mkdirError) {
+                // If directory creation fails (e.g., needs sudo), that's okay
+                // The daemon manager or container will create it with proper permissions
+                console.log(chalk_1.default.yellow(`⚠ Could not create directory ${configPath} (may need sudo)`));
+                console.log(chalk_1.default.gray('  The directory will be created by the daemon manager\n'));
+            }
+            agentPath = configPath; // Config path for daemon manager
+        }
+        else {
+            // For native installations, download/install agent files
+            console.log(chalk_1.default.blue('📦 Installing Agent Files'));
+            const installResult = await agentManager.installLocalAgent({
+                installationType: selectedType,
+                installFromLocal: options.local
+            });
+            if (!installResult.success) {
+                console.error(chalk_1.default.red('✗ Failed to install agent files'));
+                console.error(chalk_1.default.red(`  ${installResult.error}`));
+                return;
+            }
+            agentPath = installResult.path || configPath;
+            console.log(chalk_1.default.green('✓ Agent files installed\n'));
+        }
+        // Step 6: Configure Daemon
+        console.log(chalk_1.default.blue('⚙️  Configuring Daemon'));
+        // Create agent config at the correct path for this installation type
+        await agentManager.updateAgentConfig(configPath);
+        const daemonConfig = {
+            deviceId,
+            devicePassword,
+            deviceType: 'serving',
+            apiBaseUrl: (0, urls_1.getApiBaseUrl)(),
+            organizationId: config.organizationId,
+            configPath,
+            agentPath
+        };
+        const daemonManager = DaemonManagerFactory_1.DaemonManagerFactory.create(selectedType);
+        try {
+            await daemonManager.install(daemonConfig);
+            console.log(chalk_1.default.green('✓ Daemon configured\n'));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('✗ Failed to configure daemon'));
+            console.error(chalk_1.default.red(`  ${error instanceof Error ? error.message : String(error)}`));
+            return;
+        }
+        // Save installation type to config
+        configRepository.updateConfig({
+            agentInstallationType: selectedType,
+            agentServiceName: 'edgible-agent',
+            agentContainerName: selectedType === 'docker' || selectedType === 'podman' ? 'edgible-agent' : undefined,
+            agentDataPath: configPath
+        });
+        // Step 7: Enable and Start
+        console.log(chalk_1.default.blue('🚀 Starting Agent'));
+        try {
+            await daemonManager.enable();
+            console.log(chalk_1.default.green('✓ Enabled for startup\n'));
+        }
+        catch (error) {
+            console.warn(chalk_1.default.yellow(`⚠  Could not enable auto-start: ${error instanceof Error ? error.message : String(error)}`));
+        }
+        try {
+            await daemonManager.start();
+            console.log(chalk_1.default.green('✓ Agent started\n'));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('✗ Failed to start agent'));
+            console.error(chalk_1.default.red(`  ${error instanceof Error ? error.message : String(error)}`));
+            return;
+        }
+        // Wait a moment for agent to initialize
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        // Show status
+        console.log(chalk_1.default.blue('📊 Agent Status'));
+        try {
+            const status = await daemonManager.status();
+            console.log(`  Running: ${status.running ? chalk_1.default.green('Yes') : chalk_1.default.red('No')}`);
+            console.log(`  Enabled: ${status.enabled ? chalk_1.default.green('Yes') : chalk_1.default.gray('No')}`);
+            if (status.pid) {
+                console.log(`  PID: ${status.pid}`);
+            }
+        }
+        catch (error) {
+            console.warn(chalk_1.default.yellow('  Could not fetch status'));
+        }
+        console.log(chalk_1.default.blue.bold('\n═══════════════════════════════════════════'));
+        console.log(chalk_1.default.green.bold('  ✓ Installation Complete!'));
+        console.log(chalk_1.default.blue.bold('═══════════════════════════════════════════\n'));
+        console.log(chalk_1.default.gray('Next steps:'));
+        console.log(chalk_1.default.gray(`  • View status: ${chalk_1.default.white('edgible agent status')}`));
+        console.log(chalk_1.default.gray(`  • View logs: ${chalk_1.default.white('edgible agent logs --follow')}`));
+        console.log(chalk_1.default.gray(`  • Stop agent: ${chalk_1.default.white('edgible agent stop')}`));
+        console.log(chalk_1.default.gray(`  • Restart agent: ${chalk_1.default.white('edgible agent restart')}\n`));
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+    agentCommand
+        .command('start')
+        .description('Start the local agent')
+        .option('--passthrough', 'Run agent with interactive output (required for sudo password prompt)')
+        .option('--debug', 'Enable debug logging')
+        .option('--docker', 'Run agent in Docker container')
+        .option('--root', 'Run agent with sudo/root privileges (required for WireGuard and iptables management)')
+        .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 edgibleService = container.get(types_1.TYPES.EdgibleService);
+        const authService = container.get(types_1.TYPES.AuthService);
+        const agentManager = container.get(types_1.TYPES.LocalAgentManager);
+        (0, config_validator_1.validateConfig)(configRepository, {
+            requireAuth: true,
+            requireOrganization: true,
+        });
+        const config = configRepository.getConfig();
+        let deviceId = config.deviceId;
+        let devicePassword = config.devicePassword;
+        // Always ask user to select or create a device
+        console.log(chalk_1.default.blue('\n🔧 Device Selection'));
+        console.log(chalk_1.default.gray('Select which serving device this agent should represent:\n'));
+        try {
+            // Fetch available serving devices
+            const servingDevicesResp = await edgibleService.listServingDevices();
+            const servingDevices = servingDevicesResp?.devices || [];
+            if (servingDevices.length > 0) {
+                // Show list of devices to select from
+                const deviceChoices = servingDevices.map((d) => {
+                    const isCurrentDevice = config.deviceId === d.id;
+                    const displayName = `${d.name || d.id}${d.description ? ` - ${d.description}` : ''}${isCurrentDevice ? chalk_1.default.gray(' (current)') : ''}`;
+                    return {
+                        name: displayName,
+                        value: d.id
+                    };
+                });
+                // Add option to create new device
+                deviceChoices.push({
+                    name: chalk_1.default.cyan('➕ Create new serving device'),
+                    value: '__create_new__'
+                });
+                const { selectedDeviceId } = await inquirer_1.default.prompt([{
+                        type: 'list',
+                        name: 'selectedDeviceId',
+                        message: 'Select serving device:',
+                        choices: deviceChoices,
+                        default: config.deviceId || undefined
+                    }]);
+                if (selectedDeviceId === '__create_new__') {
+                    // Create new device
+                    const deviceNameAnswer = await inquirer_1.default.prompt([{
+                            type: 'input',
+                            name: 'deviceName',
+                            message: 'Enter a name for this device:',
+                            default: `${os.hostname()}-${os.platform()}`,
+                            validate: (input) => {
+                                if (!input.trim()) {
+                                    return 'Device name is required';
+                                }
+                                return true;
+                            }
+                        }]);
+                    const descriptionAnswer = await inquirer_1.default.prompt([{
+                            type: 'input',
+                            name: 'description',
+                            message: 'Enter device description (optional):',
+                            default: `Serving device: ${deviceNameAnswer.deviceName}`
+                        }]);
+                    console.log(chalk_1.default.gray('\nCreating device...'));
+                    // Create device via API - password will be generated and returned by the API
+                    const createResponse = await edgibleService.createServingDevice({
+                        name: deviceNameAnswer.deviceName.trim(),
+                        description: descriptionAnswer.description.trim()
+                    });
+                    deviceId = createResponse.device.id;
+                    devicePassword = createResponse.device.password; // Get password from API response
+                    console.log(chalk_1.default.green(`✓ Device created: ${deviceId}`));
+                    console.log(chalk_1.default.yellow(`\n⚠ Device Password: ${devicePassword}`));
+                    console.log(chalk_1.default.yellow('⚠ Please save this password securely! You will need it to login as this device.\n'));
+                    // Verify device credentials (don't login as device - CLI should use user credentials)
+                    if (devicePassword && deviceId) {
+                        const password = devicePassword;
+                        const id = deviceId;
+                        console.log(chalk_1.default.gray('Verifying device credentials...'));
+                        try {
+                            const isValid = await authService.verifyDeviceCredentials(id, password);
+                            if (isValid) {
+                                console.log(chalk_1.default.green('✓ Device credentials verified'));
+                            }
+                            else {
+                                console.log(chalk_1.default.yellow('⚠ Device credentials verification failed, but continuing anyway.'));
+                                console.log(chalk_1.default.gray('The agent will use these credentials when it starts.'));
+                            }
+                        }
+                        catch (verifyError) {
+                            console.log(chalk_1.default.yellow('⚠ Could not verify device credentials. The agent will use these credentials when it starts.'));
+                            // Continue anyway - credentials are stored and agent will use them
+                        }
+                    }
+                    // Save device credentials to config
+                    logger.info('Saving device credentials to config', { deviceId });
+                    configRepository.updateConfig({
+                        deviceId: deviceId,
+                        deviceName: deviceNameAnswer.deviceName.trim(),
+                        devicePassword: devicePassword,
+                        deviceType: 'serving'
+                    });
+                }
+                else {
+                    // Use existing device - need to get password
+                    deviceId = selectedDeviceId;
+                    let passwordVerified = false;
+                    // Check if we have password for this device in config
+                    if (config.deviceId === deviceId && config.devicePassword) {
+                        devicePassword = config.devicePassword;
+                        // Verify the stored password is still valid (without overwriting user tokens)
+                        console.log(chalk_1.default.gray('Verifying device credentials...'));
+                        if (!deviceId || !devicePassword) {
+                            throw new Error('Device ID or password is missing');
+                        }
+                        const isValid = await authService.verifyDeviceCredentials(deviceId, devicePassword);
+                        if (isValid) {
+                            console.log(chalk_1.default.green('✓ Device credentials verified'));
+                            // Update config with current device info (password already stored)
+                            const selectedDevice = servingDevices.find((d) => d.id === deviceId);
+                            logger.info('Updating device config', { deviceId });
+                            configRepository.updateConfig({
+                                deviceId: deviceId,
+                                deviceName: selectedDevice?.name || deviceId,
+                                devicePassword: devicePassword,
+                                deviceType: 'serving'
+                            });
+                            passwordVerified = true;
+                        }
+                        else {
+                            console.log(chalk_1.default.yellow('⚠ Stored password is invalid, please enter the device password'));
+                            devicePassword = undefined; // Clear invalid password
+                        }
+                    }
+                    // If we don't have a valid password yet, prompt for it
+                    if (!devicePassword) {
+                        const passwordAnswer = await inquirer_1.default.prompt([{
+                                type: 'password',
+                                name: 'password',
+                                message: 'Enter device password:',
+                                validate: (input) => {
+                                    if (!input.trim()) {
+                                        return 'Device password is required';
+                                    }
+                                    return true;
+                                }
+                            }]);
+                        devicePassword = passwordAnswer.password;
+                    }
+                    // Verify password (in case it was newly entered or verification failed)
+                    if (!passwordVerified && devicePassword && deviceId) {
+                        console.log(chalk_1.default.gray('Verifying device credentials...'));
+                        if (!deviceId || !devicePassword) {
+                            throw new Error('Device ID or password is missing');
+                        }
+                        const isValid = await authService.verifyDeviceCredentials(deviceId, devicePassword);
+                        if (isValid) {
+                            console.log(chalk_1.default.green('✓ Device credentials verified'));
+                            // Save device credentials to config
+                            const selectedDevice = servingDevices.find((d) => d.id === deviceId);
+                            logger.info('Saving device credentials to config', { deviceId });
+                            configRepository.updateConfig({
+                                deviceId: deviceId,
+                                deviceName: selectedDevice?.name || deviceId,
+                                devicePassword: devicePassword,
+                                deviceType: 'serving'
+                            });
+                        }
+                        else {
+                            console.error(chalk_1.default.red('✗ Invalid device password'));
+                            console.log(chalk_1.default.gray('Please check your password and try again'));
+                            return;
+                        }
+                    }
+                }
+            }
+            else {
+                // No devices available, offer to create one
+                console.log(chalk_1.default.yellow('⚠ No serving devices found in your organization.\n'));
+                const { createNew } = await inquirer_1.default.prompt([{
+                        type: 'confirm',
+                        name: 'createNew',
+                        message: 'Would you like to create a new serving device?',
+                        default: true
+                    }]);
+                if (!createNew) {
+                    console.log(chalk_1.default.gray('Agent start cancelled'));
+                    return;
+                }
+                // Create new device
+                const deviceNameAnswer = await inquirer_1.default.prompt([{
+                        type: 'input',
+                        name: 'deviceName',
+                        message: 'Enter a name for this device:',
+                        default: `${os.hostname()}-${os.platform()}`,
+                        validate: (input) => {
+                            if (!input.trim()) {
+                                return 'Device name is required';
+                            }
+                            return true;
+                        }
+                    }]);
+                const descriptionAnswer = await inquirer_1.default.prompt([{
+                        type: 'input',
+                        name: 'description',
+                        message: 'Enter device description (optional):',
+                        default: `Serving device: ${deviceNameAnswer.deviceName}`
+                    }]);
+                console.log(chalk_1.default.gray('\nCreating device...'));
+                // Create device via API - password will be generated and returned by the API
+                const createResponse = await edgibleService.createServingDevice({
+                    name: deviceNameAnswer.deviceName.trim(),
+                    description: descriptionAnswer.description.trim()
+                });
+                deviceId = createResponse.device.id;
+                devicePassword = createResponse.device.password; // Get password from API response
+                console.log(chalk_1.default.green(`✓ Device created: ${deviceId}`));
+                console.log(chalk_1.default.yellow(`\n⚠ Device Password: ${devicePassword}`));
+                console.log(chalk_1.default.yellow('⚠ Please save this password securely! You will need it to login as this device.\n'));
+                // Verify device credentials (don't login as device - CLI should use user credentials)
+                if (devicePassword && deviceId) {
+                    const password = devicePassword;
+                    const id = deviceId;
+                    console.log(chalk_1.default.gray('Verifying device credentials...'));
+                    try {
+                        const isValid = await edgibleService.verifyDeviceCredentials(id, password);
+                        if (isValid) {
+                            console.log(chalk_1.default.green('✓ Device credentials verified'));
+                        }
+                        else {
+                            console.log(chalk_1.default.yellow('⚠ Device credentials verification failed, but continuing anyway.'));
+                            console.log(chalk_1.default.gray('The agent will use these credentials when it starts.'));
+                        }
+                    }
+                    catch (verifyError) {
+                        console.log(chalk_1.default.yellow('⚠ Could not verify device credentials. The agent will use these credentials when it starts.'));
+                        // Continue anyway - credentials are stored and agent will use them
+                    }
+                }
+                // Save device credentials to config
+                logger.info('Saving device credentials to config', { deviceId });
+                configRepository.updateConfig({
+                    deviceId: deviceId,
+                    deviceName: deviceNameAnswer.deviceName.trim(),
+                    devicePassword: devicePassword,
+                    deviceType: 'serving'
+                });
+            }
+        }
+        catch (error) {
+            logger.error('Error selecting device', error);
+            const errorMessage = error instanceof Error ? error.message : 'An unexpected error occurred';
+            console.error(chalk_1.default.red('Error selecting device:'), errorMessage);
+            throw error;
+        }
+        // Now start the agent with the selected/created device
+        logger.info('Starting local agent', { passthrough: options.passthrough, debug: options.debug, docker: options.docker, root: options.root });
+        if (options.docker) {
+            console.log(chalk_1.default.blue('\n🐳 Starting agent in Docker...'));
+        }
+        else {
+            console.log(chalk_1.default.blue('\n🚀 Starting agent...'));
+        }
+        await agentManager.startLocalAgent({
+            passthrough: options.passthrough || false,
+            debug: options.debug || false,
+            docker: options.docker || false,
+            root: options.root || false,
+        });
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+        requireAuth: true,
+        requireOrganization: true,
+    }));
+    agentCommand
+        .command('stop')
+        .description('Stop the local agent')
+        .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();
+        if (!config.agentInstallationType) {
+            console.log(chalk_1.default.yellow('⚠  Agent installation type not found in config'));
+            console.log(chalk_1.default.gray('  Run "edgible agent install" to install the agent\n'));
+            return;
+        }
+        logger.info('Stopping local agent');
+        console.log(chalk_1.default.blue('Stopping agent...\n'));
+        const daemonManager = DaemonManagerFactory_1.DaemonManagerFactory.fromConfig(config.agentInstallationType);
+        if (!daemonManager) {
+            console.error(chalk_1.default.red('✗ Could not create daemon manager'));
+            return;
+        }
+        try {
+            await daemonManager.stop();
+            console.log(chalk_1.default.green('✓ Agent stopped successfully\n'));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('✗ Failed to stop agent'));
+            console.error(chalk_1.default.red(`  ${error instanceof Error ? error.message : String(error)}\n`));
+            throw error;
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+    agentCommand
+        .command('restart')
+        .description('Restart the local agent')
+        .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();
+        if (!config.agentInstallationType) {
+            console.log(chalk_1.default.yellow('⚠  Agent installation type not found in config'));
+            console.log(chalk_1.default.gray('  Run "edgible agent install" to install the agent\n'));
+            return;
+        }
+        logger.info('Restarting local agent');
+        console.log(chalk_1.default.blue('Restarting agent...\n'));
+        const daemonManager = DaemonManagerFactory_1.DaemonManagerFactory.fromConfig(config.agentInstallationType);
+        if (!daemonManager) {
+            console.error(chalk_1.default.red('✗ Could not create daemon manager'));
+            return;
+        }
+        try {
+            await daemonManager.restart();
+            console.log(chalk_1.default.green('✓ Agent restarted successfully\n'));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('✗ Failed to restart agent'));
+            console.error(chalk_1.default.red(`  ${error instanceof Error ? error.message : String(error)}\n`));
+            throw error;
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+    agentCommand
+        .command('logs')
+        .description('View agent logs')
+        .option('-f, --follow', 'Follow log output in real-time')
+        .option('-n, --lines <number>', 'Number of lines to show', '100')
+        .option('-l, --level <level>', 'Log level filter (error, warn, info, debug, all)', 'all')
+        .option('-m, --module <module>', 'Filter logs by module name (comma-separated for multiple modules, e.g., "agent,caddy")')
+        .option('-c, --comprehensive', 'Show comprehensive diagnostics (raw output without filtering)')
+        .option('--single-line', 'Exclude data and error traces from output (single line per log entry)')
+        .action((0, command_wrapper_1.wrapCommand)(async (options) => {
+        const container = (0, container_1.getContainer)();
+        const configRepository = container.get(types_1.TYPES.ConfigRepository);
+        const config = configRepository.getConfig();
+        if (!config.agentInstallationType) {
+            console.log(chalk_1.default.yellow('⚠  Agent installation type not found in config'));
+            console.log(chalk_1.default.gray('  Run "edgible agent install" to install the agent\n'));
+            return;
+        }
+        const daemonManager = DaemonManagerFactory_1.DaemonManagerFactory.fromConfig(config.agentInstallationType);
+        if (!daemonManager) {
+            console.error(chalk_1.default.red('✗ Could not create daemon manager'));
+            return;
+        }
+        const lines = options.lines ? parseInt(options.lines, 10) : 100;
+        const follow = options.follow || false;
+        const level = options.level || 'all';
+        const module = options.module;
+        const comprehensive = options.comprehensive || false;
+        const singleLine = options.singleLine || false;
+        try {
+            const rawLogs = await daemonManager.logs(follow, lines);
+            // For follow mode, logs are streamed directly and rawLogs will be empty
+            if (follow) {
+                return;
+            }
+            // For comprehensive mode, just output raw logs
+            if (comprehensive) {
+                console.log(rawLogs);
+            }
+            else {
+                // For launchd, logs are plain text, not JSON - output directly
+                // unless filtering is requested
+                const isLaunchd = config.agentInstallationType === 'launchd';
+                if (isLaunchd && !module && level === 'all') {
+                    // Plain text logs without filtering - just output them
+                    console.log(rawLogs);
+                }
+                else if (isLaunchd) {
+                    // Launchd with filtering requested - try to parse JSON but fall back to raw
+                    const formattedLogs = (0, log_formatter_1.processLogs)(rawLogs, {
+                        module: module,
+                        level: level,
+                        singleLine: singleLine
+                    });
+                    // If no formatted logs, it means either no matches or non-JSON logs
+                    if (formattedLogs.trim()) {
+                        console.log(formattedLogs);
+                    }
+                    else {
+                        // No JSON found, just output raw logs
+                        console.log(chalk_1.default.yellow('Note: Filtering not available for plain text logs. Showing all logs:\n'));
+                        console.log(rawLogs);
+                    }
+                }
+                else {
+                    // Systemd/Docker/Podman - parse and format JSON logs
+                    const formattedLogs = (0, log_formatter_1.processLogs)(rawLogs, {
+                        module: module,
+                        level: level,
+                        singleLine: singleLine
+                    });
+                    if (formattedLogs.trim()) {
+                        console.log(formattedLogs);
+                    }
+                    else {
+                        if (module) {
+                            console.log(chalk_1.default.yellow(`No logs found for module(s): ${module}`));
+                        }
+                        else {
+                            console.log(chalk_1.default.yellow('No logs found'));
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('✗ Failed to read logs'));
+            console.error(chalk_1.default.red(`  ${error instanceof Error ? error.message : String(error)}\n`));
+            throw error;
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+    agentCommand
+        .command('uninstall')
+        .description('Uninstall the agent daemon')
+        .option('--remove-files', 'Also remove agent files and configuration')
+        .option('--force', 'Skip confirmation prompts')
+        .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 config = configRepository.getConfig();
+        if (!config.agentInstallationType) {
+            console.log(chalk_1.default.yellow('⚠  Agent installation type not found in config'));
+            console.log(chalk_1.default.gray('  No agent installation detected.\n'));
+            return;
+        }
+        console.log(chalk_1.default.blue.bold('\n═══════════════════════════════════════════'));
+        console.log(chalk_1.default.blue.bold('   Edgible Agent Uninstallation'));
+        console.log(chalk_1.default.blue.bold('═══════════════════════════════════════════\n'));
+        console.log(chalk_1.default.gray(`Installation Type: ${config.agentInstallationType}`));
+        if (config.agentServiceName) {
+            console.log(chalk_1.default.gray(`Service Name: ${config.agentServiceName}`));
+        }
+        if (config.agentContainerName) {
+            console.log(chalk_1.default.gray(`Container Name: ${config.agentContainerName}`));
+        }
+        if (config.agentDataPath) {
+            console.log(chalk_1.default.gray(`Data Path: ${config.agentDataPath}`));
+        }
+        console.log('');
+        // Confirm uninstallation unless --force is used
+        if (!options.force) {
+            const { confirm } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: 'Are you sure you want to uninstall the agent?',
+                    default: false
+                }
+            ]);
+            if (!confirm) {
+                console.log(chalk_1.default.gray('\nUninstallation cancelled.\n'));
+                return;
+            }
+        }
+        logger.info('Uninstalling agent', { installationType: config.agentInstallationType });
+        // Get daemon manager
+        const daemonManager = DaemonManagerFactory_1.DaemonManagerFactory.fromConfig(config.agentInstallationType);
+        if (!daemonManager) {
+            console.error(chalk_1.default.red('✗ Could not create daemon manager'));
+            console.error(chalk_1.default.red(`  Invalid installation type: ${config.agentInstallationType}\n`));
+            return;
+        }
+        // Step 1: Uninstall daemon
+        console.log(chalk_1.default.blue('🔧 Uninstalling Daemon'));
+        try {
+            await daemonManager.uninstall();
+            console.log(chalk_1.default.green('✓ Daemon uninstalled successfully\n'));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('✗ Failed to uninstall daemon'));
+            console.error(chalk_1.default.red(`  ${error instanceof Error ? error.message : String(error)}\n`));
+            // Continue with cleanup even if daemon uninstall partially failed
+        }
+        // Step 2: Optionally remove agent files and configuration
+        let removeFiles = options.removeFiles;
+        if (removeFiles === undefined && !options.force) {
+            const { removeFilesAnswer } = await inquirer_1.default.prompt([
+                {
+                    type: 'confirm',
+                    name: 'removeFilesAnswer',
+                    message: 'Do you want to remove agent files and configuration?',
+                    default: false
+                }
+            ]);
+            removeFiles = removeFilesAnswer;
+        }
+        if (removeFiles) {
+            console.log(chalk_1.default.blue('🗑️  Removing Agent Files'));
+            const agentDataPath = config.agentDataPath || PathResolver_1.PathResolver.resolveAgentConfigPath(config.agentInstallationType);
+            const agentConfigPath = PathResolver_1.PathResolver.resolveAgentConfigPath(config.agentInstallationType);
+            try {
+                // Remove agent data directory if it exists
+                if (agentDataPath && fs.existsSync(agentDataPath)) {
+                    await fsPromises.rm(agentDataPath, { recursive: true, force: true });
+                    console.log(chalk_1.default.green(`✓ Removed agent data directory: ${agentDataPath}`));
+                }
+                // Also try removing config path if different
+                if (agentConfigPath !== agentDataPath && fs.existsSync(agentConfigPath)) {
+                    await fsPromises.rm(agentConfigPath, { recursive: true, force: true });
+                    console.log(chalk_1.default.green(`✓ Removed agent config directory: ${agentConfigPath}`));
+                }
+                console.log('');
+            }
+            catch (error) {
+                console.warn(chalk_1.default.yellow('⚠  Could not remove all agent files'));
+                console.warn(chalk_1.default.yellow(`  ${error instanceof Error ? error.message : String(error)}`));
+                console.warn(chalk_1.default.gray('  You may need to remove them manually with appropriate permissions\n'));
+            }
+        }
+        else {
+            console.log(chalk_1.default.gray('  Agent files and configuration preserved\n'));
+        }
+        // Step 3: Clean up CLI config
+        console.log(chalk_1.default.blue('🧹 Cleaning Up Configuration'));
+        try {
+            // Note: ConfigManager filters out undefined values, so fields may remain in config.json
+            // However, the daemon is uninstalled which is the important part
+            // The installation type check will fail if agentInstallationType is undefined,
+            // effectively treating it as uninstalled
+            console.log(chalk_1.default.green('✓ CLI configuration cleaned up\n'));
+            console.log(chalk_1.default.gray('  Note: Agent installation fields may remain in config.json'));
+            console.log(chalk_1.default.gray('  but the agent is uninstalled and will not be used.\n'));
+        }
+        catch (error) {
+            console.warn(chalk_1.default.yellow('⚠  Could not clean up CLI configuration'));
+            console.warn(chalk_1.default.yellow(`  ${error instanceof Error ? error.message : String(error)}\n`));
+        }
+        console.log(chalk_1.default.blue.bold('═══════════════════════════════════════════'));
+        console.log(chalk_1.default.green.bold('  ✓ Uninstallation Complete!'));
+        console.log(chalk_1.default.blue.bold('═══════════════════════════════════════════\n'));
+        if (!removeFiles) {
+            console.log(chalk_1.default.gray('Note: Agent files and configuration were preserved.'));
+            console.log(chalk_1.default.gray('To remove them, run: edgible agent uninstall --remove-files\n'));
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+    agentCommand
+        .command('set-log-level')
+        .description('Set the agent log level')
+        .option('-l, --level <level>', 'Log level: debug, info, warn, or error')
+        .option('--no-restart', 'Do not restart the agent after updating log level')
+        .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 agentManager = container.get(types_1.TYPES.LocalAgentManager);
+        const validLevels = ['debug', 'info', 'warn', 'error'];
+        let logLevel;
+        if (options.level) {
+            const level = options.level.toLowerCase();
+            if (!validLevels.includes(level)) {
+                console.error(chalk_1.default.red(`✗ Invalid log level: ${options.level}`));
+                console.error(chalk_1.default.red(`  Valid levels are: ${validLevels.join(', ')}\n`));
+                return;
+            }
+            logLevel = level;
+        }
+        else {
+            // Interactive selection
+            const { selectedLevel } = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'selectedLevel',
+                    message: 'Select log level:',
+                    choices: validLevels.map(level => ({
+                        name: level.charAt(0).toUpperCase() + level.slice(1),
+                        value: level
+                    })),
+                    default: 'info'
+                }
+            ]);
+            logLevel = selectedLevel;
+        }
+        try {
+            // Determine the correct config file path based on installation type
+            const userConfig = configRepository.getConfig();
+            const configFilePath = PathResolver_1.PathResolver.resolveAgentConfigFilePath(userConfig.agentInstallationType);
+            if (!fs.existsSync(configFilePath)) {
+                console.error(chalk_1.default.red('✗ Agent configuration file not found'));
+                console.error(chalk_1.default.red(`  Expected at: ${configFilePath}`));
+                console.error(chalk_1.default.red('  Run "edgible agent install" to install the agent first\n'));
+                return;
+            }
+            const configData = await fsPromises.readFile(configFilePath, 'utf8');
+            const agentConfig = JSON.parse(configData);
+            // Check if log level is already set to this value
+            if (agentConfig.logLevel === logLevel) {
+                console.log(chalk_1.default.yellow(`⚠ Log level is already set to: ${logLevel}\n`));
+                return;
+            }
+            // Update log level
+            agentConfig.logLevel = logLevel;
+            // Write back to file
+            await fsPromises.writeFile(configFilePath, JSON.stringify(agentConfig, null, 2), 'utf8');
+            logger.info('Agent log level updated', { logLevel, configFilePath });
+            console.log(chalk_1.default.green(`✓ Log level set to: ${logLevel}`));
+            console.log(chalk_1.default.gray(`  Updated: ${configFilePath}\n`));
+            // Restart agent if it's installed and running (unless --no-restart is specified)
+            const shouldRestart = options.restart !== false && userConfig.agentInstallationType;
+            if (shouldRestart && userConfig.agentInstallationType) {
+                try {
+                    const daemonManager = DaemonManagerFactory_1.DaemonManagerFactory.fromConfig(userConfig.agentInstallationType);
+                    if (daemonManager) {
+                        const status = await daemonManager.status();
+                        if (status.running) {
+                            console.log(chalk_1.default.gray('\nRestarting agent to apply new log level...'));
+                            await daemonManager.restart();
+                            console.log(chalk_1.default.green('✓ Agent restarted\n'));
+                        }
+                        else {
+                            console.log(chalk_1.default.gray('\nAgent is not running. Start it with "edgible agent start" to apply the new log level.\n'));
+                        }
+                    }
+                }
+                catch (restartError) {
+                    console.warn(chalk_1.default.yellow('⚠ Could not restart agent automatically'));
+                    console.warn(chalk_1.default.yellow(`  ${restartError instanceof Error ? restartError.message : String(restartError)}`));
+                    console.log(chalk_1.default.gray('\nPlease restart the agent manually for the log level change to take effect.\n'));
+                }
+            }
+            else {
+                console.log(chalk_1.default.gray('\nRestart the agent for the log level change to take effect:\n'));
+                console.log(chalk_1.default.gray('  edgible agent restart\n'));
+            }
+        }
+        catch (error) {
+            logger.error('Failed to update log level', error);
+            console.error(chalk_1.default.red('✗ Failed to update log level'));
+            console.error(chalk_1.default.red(`  ${error instanceof Error ? error.message : String(error)}\n`));
+            throw error;
+        }
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+    agentCommand
+        .command('setup')
+        .description('Setup agent dependencies and configure the agent')
+        .option('--wireguard-mode <mode>', 'WireGuard mode: kernel or userspace', 'kernel')
+        .option('--wireguard-go-binary <path>', 'Path to wireguard-go binary (only used with userspace mode)', 'wireguard-go')
+        .option('--auto-install', 'Automatically install missing dependencies without prompting')
+        .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 agentManager = container.get(types_1.TYPES.LocalAgentManager);
+        logger.info('Setting up agent dependencies and configuration');
+        console.log(chalk_1.default.blue('\n🔧 Agent Setup'));
+        console.log(chalk_1.default.gray('This will check and install dependencies, then configure the agent.\n'));
+        // Step 1: Check and install dependencies
+        console.log(chalk_1.default.blue('Step 1: Checking dependencies...\n'));
+        const dependencyInstaller = new DependencyInstaller_1.DependencyInstaller();
+        // Determine if we should check for wireguard-go based on mode
+        const wireguardMode = (options.wireguardMode || 'kernel').toLowerCase();
+        const includeWireGuardGo = wireguardMode === 'userspace';
+        await dependencyInstaller.checkAndInstallDependencies({
+            includeWireGuardGo,
+            includeIptables: true,
+            autoInstall: options.autoInstall || false
+        });
+        console.log(chalk_1.default.green('\n✓ Dependencies check complete\n'));
+        // Step 2: Configure WireGuard mode
+        let selectedMode = wireguardMode;
+        if (!options.wireguardMode) {
+            // Prompt user for WireGuard mode if not provided
+            const { mode } = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'mode',
+                    message: 'Select WireGuard implementation mode:',
+                    choices: [
+                        {
+                            name: 'Kernel (default, requires kernel module support)',
+                            value: 'kernel'
+                        },
+                        {
+                            name: 'Userspace (wireguard-go, works without kernel module)',
+                            value: 'userspace'
+                        }
+                    ],
+                    default: 'kernel'
+                }
+            ]);
+            selectedMode = mode;
+        }
+        // Step 3: Update CLI config with WireGuard settings
+        const currentConfig = configRepository.getConfig();
+        configRepository.updateConfig({
+            wireguardMode: selectedMode,
+            wireguardGoBinary: options.wireguardGoBinary || 'wireguard-go'
+        });
+        console.log(chalk_1.default.green(`✓ WireGuard mode set to: ${selectedMode}`));
+        if (selectedMode === 'userspace') {
+            console.log(chalk_1.default.gray(`  wireguard-go binary: ${options.wireguardGoBinary || 'wireguard-go'}`));
+        }
+        // Step 4: Update agent config
+        console.log(chalk_1.default.blue('\nStep 2: Updating agent configuration...\n'));
+        // Check if device credentials exist
+        if (!currentConfig.deviceId || !currentConfig.devicePassword) {
+            console.log(chalk_1.default.yellow('⚠ No device credentials found in CLI config.'));
+            console.log(chalk_1.default.yellow('⚠ You will need to run "edgible agent start" to set up device credentials.'));
+            console.log(chalk_1.default.yellow('⚠ The agent config will be created with default values.\n'));
+        }
+        try {
+            await agentManager.updateAgentConfig();
+            console.log(chalk_1.default.green('✓ Agent configuration updated\n'));
+        }
+        catch (error) {
+            // If update fails due to missing credentials, create a basic config
+            if (error instanceof Error && error.message.includes('No device credentials')) {
+                console.log(chalk_1.default.yellow('⚠ Creating agent config with default values (device credentials will be set when you start the agent)\n'));
+                // Create a basic config file
+                const agentConfigPath = path.join(os.homedir(), '.edgible', 'agent', 'agent.config.json');
+                const defaultConfig = {
+                    deviceId: 'your-device-id',
+                    devicePassword: 'your-device-password',
+                    deviceType: 'serving',
+                    apiBaseUrl: (0, urls_1.getApiBaseUrl)(),
+                    organizationId: currentConfig.organizationId,
+                    firewallEnabled: true,
+                    pollingInterval: 60000,
+                    healthCheckTimeout: 5000,
+                    maxRetries: 3,
+                    logLevel: 'info',
+                    updateEnabled: true,
+                    updateCheckInterval: 3600000,
+                    wireguardMode: selectedMode,
+                    wireguardGoBinary: options.wireguardGoBinary || 'wireguard-go'
+                };
+                const configDir = path.dirname(agentConfigPath);
+                await fsPromises.mkdir(configDir, { recursive: true });
+                await fsPromises.writeFile(agentConfigPath, JSON.stringify(defaultConfig, null, 2));
+                console.log(chalk_1.default.green('✓ Agent configuration file created\n'));
+            }
+            else {
+                throw error;
+            }
+        }
+        console.log(chalk_1.default.green('✓ Agent setup complete!\n'));
+        console.log(chalk_1.default.blue('Next steps:'));
+        console.log(chalk_1.default.gray('  1. Run "edgible agent start" to start the agent'));
+        console.log(chalk_1.default.gray('  2. The agent will use the configured WireGuard mode'));
+        if (selectedMode === 'userspace') {
+            console.log(chalk_1.default.gray('  3. Ensure wireguard-go is available in your PATH'));
+        }
+        console.log('');
+    }, {
+        configRepository: (0, container_1.getContainer)().get(types_1.TYPES.ConfigRepository),
+    }));
+}
+//# sourceMappingURL=agent.js.map