@edgible-team/cli 1.0.1

package/dist/services/LocalAgentManager.js

@@ -0,0 +1,2216 @@
+"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.LocalAgentManager = void 0;
+const DependencyInstaller_1 = require("./DependencyInstaller");
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const PathResolver_1 = require("../utils/PathResolver");
+const util_1 = require("util");
+const chalk_1 = __importDefault(require("chalk"));
+const find_process_1 = __importDefault(require("find-process"));
+const fs_1 = require("fs");
+const urls_1 = require("../utils/urls");
+const config_1 = require("../state/config");
+const AgentStatusManager_1 = require("./AgentStatusManager");
+const DaemonManagerFactory_1 = require("./daemon/DaemonManagerFactory");
+const writeFile = (0, util_1.promisify)(fs.writeFile);
+const readFile = (0, util_1.promisify)(fs.readFile);
+const mkdir = (0, util_1.promisify)(fs.mkdir);
+class LocalAgentManager {
+    constructor() {
+        this.agentProcess = null;
+        // Get user config to determine installation type
+        const tempConfigManager = new config_1.ConfigManager();
+        const userConfig = tempConfigManager.getConfig();
+        // Resolve agent config path based on installation type
+        this.configPath = PathResolver_1.PathResolver.resolveAgentConfigPath(userConfig.agentInstallationType);
+        // Check for the actual agent binary location
+        const possibleAgentPaths = [
+            path.join(this.configPath, 'index.js'), // S3 distribution location
+            path.join(this.configPath, 'dist/index.js'), // Alternative build location
+            path.join(this.configPath, 'agent') // Legacy location
+        ];
+        this.agentPath = possibleAgentPaths.find(p => fs.existsSync(p)) || possibleAgentPaths[0];
+        this.serviceName = 'edgible-agent';
+        this.statePath = path.join(this.configPath, 'state.json');
+        this.configManager = new config_1.ConfigManager();
+        this.statusManager = new AgentStatusManager_1.AgentStatusManager();
+    }
+    /**
+     * Update agent configuration with current CLI device credentials
+     * @param configPath Optional config path to use. If not provided, uses the instance's configPath.
+     */
+    async updateAgentConfig(configPath) {
+        try {
+            // Get current device credentials from CLI config
+            const cliConfig = this.configManager.getConfig();
+            if (!cliConfig.deviceId || !cliConfig.devicePassword) {
+                throw new Error('No device credentials found in CLI config');
+            }
+            // Create updated agent-v2 configuration
+            const agentV2Config = {
+                deviceId: cliConfig.deviceId,
+                devicePassword: cliConfig.devicePassword,
+                deviceType: cliConfig.deviceType || 'serving',
+                apiBaseUrl: (0, urls_1.getApiBaseUrl)(),
+                organizationId: cliConfig.organizationId,
+                firewallEnabled: true,
+                pollingInterval: 60000,
+                healthCheckTimeout: 5000,
+                maxRetries: 3,
+                logLevel: 'info',
+                updateEnabled: true,
+                updateCheckInterval: 3600000,
+                wireguardMode: cliConfig.wireguardMode || 'kernel',
+                wireguardGoBinary: cliConfig.wireguardGoBinary || 'wireguard-go'
+            };
+            // Use provided configPath or fall back to instance configPath
+            const targetConfigPath = configPath || this.configPath;
+            // Ensure the config directory exists
+            if (!fs.existsSync(targetConfigPath)) {
+                await mkdir(targetConfigPath, { recursive: true });
+            }
+            const agentV2ConfigPath = path.join(targetConfigPath, 'agent.config.json');
+            await writeFile(agentV2ConfigPath, JSON.stringify(agentV2Config, null, 2));
+            console.log('✓ Agent configuration updated with current device credentials');
+        }
+        catch (error) {
+            console.error('Failed to update agent configuration:', error);
+            throw error;
+        }
+    }
+    /**
+     * Check if agent is running in Docker
+     */
+    async isDockerAgentRunning(deviceId) {
+        try {
+            const status = await this.checkDockerAgentStatus(deviceId);
+            return status.running;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Check if local agent is installed and running using file-based status
+     */
+    async checkLocalAgentStatus() {
+        try {
+            // First check if agent is running in Docker
+            const cliConfig = this.configManager.getConfig();
+            if (cliConfig.deviceId) {
+                const dockerStatus = await this.checkDockerAgentStatus(cliConfig.deviceId);
+                if (dockerStatus.running) {
+                    return {
+                        pid: 0,
+                        running: true,
+                        health: 'healthy',
+                        lastPoll: new Date().toISOString(),
+                        uptime: 0,
+                        version: 'docker',
+                        timestamp: Date.now(),
+                        deviceId: cliConfig.deviceId,
+                        deviceType: cliConfig.deviceType || 'serving',
+                        apiConnected: false,
+                        apiAuthenticated: false,
+                        applications: [],
+                        configurationValid: true,
+                        installed: true,
+                        lastError: ''
+                    };
+                }
+            }
+            // Check if agent binary exists
+            const installed = fs.existsSync(this.agentPath);
+            if (!installed) {
+                return {
+                    pid: 0,
+                    running: false,
+                    health: 'unknown',
+                    lastPoll: new Date().toISOString(),
+                    uptime: 0,
+                    version: 'unknown',
+                    timestamp: Date.now(),
+                    deviceId: '',
+                    deviceType: 'serving',
+                    apiConnected: false,
+                    apiAuthenticated: false,
+                    applications: [],
+                    configurationValid: false,
+                    installed: false,
+                    lastError: 'Agent not installed'
+                };
+            }
+            // Get status from file-based status manager
+            const statusResult = await this.statusManager.getStatus();
+            if (!statusResult.isValid) {
+                // Fallback to process-based checking if file status is invalid
+                const processRunning = await this.isProcessRunning();
+                return {
+                    pid: 0,
+                    running: processRunning,
+                    health: 'unknown',
+                    lastPoll: new Date().toISOString(),
+                    uptime: 0,
+                    version: 'unknown',
+                    timestamp: Date.now(),
+                    deviceId: '',
+                    deviceType: 'serving',
+                    apiConnected: false,
+                    apiAuthenticated: false,
+                    applications: [],
+                    configurationValid: false,
+                    installed: true,
+                    lastError: statusResult.error || 'Status file invalid'
+                };
+            }
+            const fileStatus = statusResult.status;
+            // Return the unified status directly
+            return fileStatus;
+        }
+        catch (error) {
+            // Fallback to basic process checking
+            const processRunning = await this.isProcessRunning();
+            return {
+                pid: 0,
+                running: processRunning,
+                health: 'unknown',
+                lastPoll: new Date().toISOString(),
+                uptime: 0,
+                version: 'unknown',
+                timestamp: Date.now(),
+                deviceId: '',
+                deviceType: 'serving',
+                apiConnected: false,
+                apiAuthenticated: false,
+                applications: [],
+                configurationValid: false,
+                installed: fs.existsSync(this.agentPath),
+                lastError: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Check if agent process is running (cross-platform method)
+     * Prioritizes status file PID validation over process detection
+     */
+    async isProcessRunning() {
+        try {
+            if (this.agentProcess && !this.agentProcess.killed) {
+                return true;
+            }
+            // First, try to get PID from status file and validate it's actually running
+            try {
+                const statusResult = await this.statusManager.getStatus();
+                if (statusResult.isValid && statusResult.status?.pid) {
+                    const pid = statusResult.status.pid;
+                    // Validate that this PID is actually a running process
+                    const list = await (0, find_process_1.default)('pid', pid);
+                    if (list.length > 0) {
+                        return true;
+                    }
+                }
+            }
+            catch (error) {
+                // Status file check failed, continue to fallback detection
+            }
+            // Fallback to process detection
+            const list = await (0, find_process_1.default)('name', this.agentPath, true);
+            return list.length > 0;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Check if a specific PID is currently running
+     */
+    async isPidRunning(pid) {
+        try {
+            const list = await (0, find_process_1.default)('pid', pid);
+            return list.length > 0;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Validate agent configuration before starting
+     */
+    async validateAgentConfig() {
+        const errors = [];
+        const cliConfig = this.configManager.getConfig();
+        // Check required fields
+        if (!cliConfig.deviceId) {
+            errors.push('Device ID is required');
+        }
+        if (!cliConfig.devicePassword) {
+            errors.push('Device password is required');
+        }
+        // Check API URL
+        // API base URL is now hardcoded based on stage, no validation needed
+        // Check agent binary exists
+        if (!fs.existsSync(this.agentPath)) {
+            errors.push('Agent binary not found. Run "edgible agent install" first.');
+        }
+        // Note: Ports are handled dynamically by the agent, no need to check specific ports
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+    /**
+     * Install local serving agent
+     */
+    async installLocalAgent(options = {}) {
+        try {
+            const warnings = [];
+            // Determine correct config path based on installation type
+            const targetConfigPath = options.installationType
+                ? PathResolver_1.PathResolver.resolveAgentConfigPath(options.installationType)
+                : this.configPath;
+            // Create agent directory
+            await mkdir(targetConfigPath, { recursive: true });
+            // Determine platform
+            const platform = options.platform || this.detectPlatform();
+            // Download and install agent based on platform
+            const installResult = await this.installAgentForPlatform(platform, options, targetConfigPath);
+            if (!installResult.success) {
+                return {
+                    success: false,
+                    error: installResult.error,
+                    warnings
+                };
+            }
+            // Update instance paths to reflect the new installation location
+            this.configPath = targetConfigPath;
+            this.agentPath = path.join(targetConfigPath, 'index.js');
+            this.statePath = path.join(targetConfigPath, 'state.json');
+            // Create default configuration
+            try {
+                await this.createDefaultConfig();
+            }
+            catch (error) {
+                warnings.push('Failed to create default configuration');
+            }
+            // Set up service (if not Docker)
+            if (platform !== 'docker') {
+                const serviceResult = await this.setupService(options);
+                if (!serviceResult.success) {
+                    warnings.push('Failed to set up service');
+                }
+            }
+            // Start agent if autoStart is enabled
+            if (options.autoStart !== false) {
+                const startResult = await this.startLocalAgent();
+                if (!startResult) {
+                    warnings.push('Failed to start agent automatically');
+                }
+            }
+            return {
+                success: true,
+                version: installResult.version,
+                path: targetConfigPath,
+                warnings
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Installation failed',
+                warnings: []
+            };
+        }
+    }
+    /**
+     * Start local agent service
+     */
+    async startLocalAgent(options = {}) {
+        try {
+            // If Docker mode is requested, use Docker instead
+            if (options.docker) {
+                return await this.spawnDockerAgent(options);
+            }
+            // Check if agent is installed as a daemon (systemd, launchd, etc.)
+            const userConfig = this.configManager.getConfig();
+            const daemonManager = DaemonManagerFactory_1.DaemonManagerFactory.fromConfig(userConfig.agentInstallationType);
+            if (daemonManager) {
+                // Agent is installed as a daemon, use daemon manager to start it
+                if (options.debug) {
+                    console.log(chalk_1.default.cyan(`🐛 DEBUG: Using daemon manager for installation type: ${userConfig.agentInstallationType}`));
+                }
+                // Update agent config with current CLI credentials before starting
+                await this.updateAgentConfig();
+                // Check if already running
+                try {
+                    const status = await daemonManager.status();
+                    if (status.running) {
+                        console.log(chalk_1.default.yellow('Agent is already running'));
+                        return true;
+                    }
+                }
+                catch (error) {
+                    // Status check failed, continue with start attempt
+                    if (options.debug) {
+                        console.log(chalk_1.default.cyan(`🐛 DEBUG: Status check failed, continuing: ${error instanceof Error ? error.message : String(error)}`));
+                    }
+                }
+                // Start using daemon manager
+                try {
+                    await daemonManager.start();
+                    console.log(chalk_1.default.green('✓ Agent started via daemon'));
+                    // Wait a moment for agent to initialize
+                    await new Promise(resolve => setTimeout(resolve, 2000));
+                    // Verify it's actually running
+                    try {
+                        const status = await daemonManager.status();
+                        if (!status.running) {
+                            console.log(chalk_1.default.yellow('⚠ Agent service started but may not be running yet'));
+                            if (userConfig.agentInstallationType === 'systemd') {
+                                console.log(chalk_1.default.gray('  Check logs with: journalctl -u edgible-agent -n 50'));
+                            }
+                        }
+                    }
+                    catch (statusError) {
+                        // Status check failed, but start succeeded, so continue
+                        if (options.debug) {
+                            console.log(chalk_1.default.cyan(`🐛 DEBUG: Status check after start failed: ${statusError instanceof Error ? statusError.message : String(statusError)}`));
+                        }
+                    }
+                    return true;
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                    // Provide helpful error messages for systemd
+                    if (userConfig.agentInstallationType === 'systemd') {
+                        console.error(chalk_1.default.red(`\n✗ Failed to start systemd service: ${errorMessage}`));
+                        console.log(chalk_1.default.yellow('\nTroubleshooting:'));
+                        console.log(chalk_1.default.gray('  1. Check service status: sudo systemctl status edgible-agent'));
+                        console.log(chalk_1.default.gray('  2. Check service logs: sudo journalctl -u edgible-agent -n 50'));
+                        console.log(chalk_1.default.gray('  3. Verify service file: cat /etc/systemd/system/edgible-agent.service'));
+                    }
+                    throw new Error(`Failed to start agent via daemon: ${errorMessage}`);
+                }
+            }
+            // Fall back to direct process spawning for non-daemon installations
+            // Warn if running without root on Linux/Unix (WireGuard and iptables typically require root)
+            const platform = os.platform();
+            if (!options.root && platform !== 'win32') {
+                console.log(chalk_1.default.yellow('⚠ Warning: Running without root privileges.'));
+                console.log(chalk_1.default.yellow('⚠ WireGuard and iptables management may not work without sudo.'));
+                console.log(chalk_1.default.yellow('⚠ Use --root flag if you need these features.'));
+                console.log('');
+            }
+            const dependencyInstaller = new DependencyInstaller_1.DependencyInstaller();
+            await dependencyInstaller.checkAndInstallDependencies();
+            // Validate configuration first
+            const validation = await this.validateAgentConfig();
+            if (!validation.valid) {
+                throw new Error(`Configuration validation failed:\n${validation.errors.map(e => `  - ${e}`).join('\n')}`);
+            }
+            // Check if already running
+            const isRunning = await this.isProcessRunning();
+            if (isRunning) {
+                console.log(chalk_1.default.yellow('Agent is already running'));
+                return true;
+            }
+            // Log debug information
+            await this.logDebugInfo(options);
+            // Start agent with better error handling
+            const started = await this.spawnAgentProcess(options);
+            if (!started) {
+                throw new Error('Failed to start agent process - check logs for details');
+            }
+            // Wait for status with better timeout handling
+            await this.waitForAgentReady(options.debug);
+            return true;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk_1.default.red('Failed to start agent:'), errorMessage);
+            // Provide specific troubleshooting steps
+            this.provideTroubleshootingSteps(errorMessage);
+            return false;
+        }
+    }
+    /**
+     * Spawn the agent process
+     */
+    async spawnAgentProcess(options) {
+        try {
+            // Check if agent is already running
+            if (this.agentProcess && !this.agentProcess.killed) {
+                return true;
+            }
+            // Check if agent binary exists
+            if (!fs.existsSync(this.agentPath)) {
+                throw new Error('Agent not installed. Run "edgible agent install" first.');
+            }
+            // Update agent configuration with current CLI credentials
+            await this.updateAgentConfig();
+            if (options.debug) {
+                console.log(chalk_1.default.cyan('🐛 DEBUG: Agent configuration updated'));
+            }
+            // Clean up any existing agent processes first
+            if (options.debug) {
+                console.log(chalk_1.default.cyan('🐛 DEBUG: About to clean up existing agents'));
+            }
+            try {
+                await this.cleanupExistingAgents(options.debug);
+                if (options.debug) {
+                    console.log(chalk_1.default.cyan('🐛 DEBUG: Cleaned up existing agents'));
+                }
+            }
+            catch (error) {
+                if (options.debug) {
+                    console.log(chalk_1.default.red('🐛 DEBUG: Error during cleanup:'), error);
+                }
+                throw error;
+            }
+            // Get device credentials from CLI config
+            const cliConfig = this.configManager.getConfig();
+            if (options.debug) {
+                console.log(chalk_1.default.cyan('🐛 DEBUG: CLI Configuration:'));
+                console.log(chalk_1.default.cyan(`  Device ID: ${cliConfig.deviceId || 'unknown'}`));
+                console.log(chalk_1.default.cyan(`  Device Type: ${cliConfig.deviceType || 'serving'}`));
+                console.log(chalk_1.default.cyan(`  API URL: ${(0, urls_1.getApiBaseUrl)()}`));
+                console.log(chalk_1.default.cyan(`  Organization ID: ${cliConfig.organizationId || 'not set'}`));
+                console.log(chalk_1.default.cyan(`  Agent Path: ${this.agentPath}`));
+                console.log(chalk_1.default.cyan(`  Config Path: ${path.join(this.configPath, 'agent.config.json')}`));
+            }
+            // Start the agent process as detached to prevent blocking
+            const { spawn } = require('child_process');
+            const configPath = path.join(this.configPath, 'agent.config.json');
+            if (options.debug) {
+                console.log(chalk_1.default.cyan(`🐛 DEBUG: About to spawn agent process`));
+                console.log(chalk_1.default.cyan(`🐛 DEBUG: Agent binary exists: ${fs.existsSync(this.agentPath)}`));
+                console.log(chalk_1.default.cyan(`🐛 DEBUG: Config file exists: ${fs.existsSync(configPath)}`));
+            }
+            // Build command arguments - pass both config file and individual arguments
+            const args = [
+                this.agentPath,
+                'start',
+                '-c', configPath,
+                '--device-id', cliConfig.deviceId || 'unknown',
+                '--device-type', cliConfig.deviceType || 'serving',
+                '--api-url', (0, urls_1.getApiBaseUrl)()
+            ];
+            // Add organization ID if available
+            if (cliConfig.organizationId) {
+                args.push('--organization-id', cliConfig.organizationId);
+            }
+            // Add debug flag if enabled
+            if (options.debug) {
+                args.push('--debug');
+            }
+            if (options.debug) {
+                console.log(chalk_1.default.cyan('🐛 DEBUG: Spawn Arguments:'));
+                console.log(chalk_1.default.cyan(`  Command: node`));
+                console.log(chalk_1.default.cyan(`  Args: ${JSON.stringify(args, null, 2)}`));
+                console.log(chalk_1.default.cyan(`  Passthrough: ${options.passthrough}`));
+                console.log(chalk_1.default.cyan(`  Debug: ${options.debug}`));
+            }
+            // Use sudo only if --root flag is explicitly passed
+            // On Windows, we would need administrator privileges (handled differently)
+            const platform = os.platform();
+            const useSudo = options.root === true && platform !== 'win32';
+            if (useSudo) {
+                console.log(chalk_1.default.gray('Starting agent with sudo privileges (required for WireGuard and iptables)...'));
+                if (options.debug) {
+                    console.log(chalk_1.default.cyan(`🐛 DEBUG: Using sudo to start agent (platform: ${platform})`));
+                }
+            }
+            else if (options.root && platform === 'win32') {
+                console.log(chalk_1.default.yellow('⚠ Windows platform detected. Root privileges are handled differently on Windows.'));
+                if (options.debug) {
+                    console.log(chalk_1.default.cyan(`🐛 DEBUG: Platform: ${platform}, Not using sudo (Windows)`));
+                }
+            }
+            else if (options.debug) {
+                console.log(chalk_1.default.cyan(`🐛 DEBUG: Platform: ${platform}, Not using sudo (--root flag not provided)`));
+            }
+            // Determine stdio configuration based on options
+            // When using sudo, we need to capture stderr to see password prompts or errors
+            const logFilePath = this.getLogFilePath();
+            const logFile = fs.openSync(logFilePath, 'a');
+            let stdioConfig;
+            if (options.passthrough) {
+                // In passthrough mode, inherit all stdio (user can enter sudo password)
+                stdioConfig = 'inherit';
+            }
+            else if (useSudo) {
+                // When using sudo, pipe stderr to see errors/password prompts
+                // stdin is 'ignore' since we can't interact in non-passthrough mode
+                stdioConfig = ['ignore', logFile, 'pipe']; // stdin: ignore, stdout: log, stderr: pipe to catch errors
+            }
+            else {
+                // Normal mode without sudo - redirect everything to log file
+                stdioConfig = ['ignore', logFile, logFile];
+            }
+            // Build the command - use sudo on Unix/Linux systems
+            const command = useSudo ? 'sudo' : 'node';
+            const commandArgs = useSudo ? ['node', ...args] : args;
+            if (options.debug) {
+                console.log(chalk_1.default.cyan(`🐛 DEBUG: Command: ${command}`));
+                console.log(chalk_1.default.cyan(`🐛 DEBUG: Command Args: ${JSON.stringify(commandArgs)}`));
+                console.log(chalk_1.default.cyan(`🐛 DEBUG: Using sudo: ${useSudo}, Passthrough: ${options.passthrough}`));
+            }
+            this.agentProcess = spawn(command, commandArgs, {
+                detached: !options.passthrough, // Don't detach if passthrough is enabled
+                stdio: stdioConfig,
+                windowsHide: true // Hide window on Windows
+            });
+            if (options.debug) {
+                console.log(chalk_1.default.cyan(`🐛 DEBUG: Agent process spawned with PID: ${this.agentProcess.pid}`));
+                console.log(chalk_1.default.cyan(`🐛 DEBUG: Process stdio config: ${JSON.stringify(stdioConfig)}`));
+                console.log(chalk_1.default.cyan(`🐛 DEBUG: Process detached: ${!options.passthrough}`));
+            }
+            // Unref the process so it doesn't keep the parent alive (unless passthrough is enabled)
+            if (!options.passthrough) {
+                this.agentProcess.unref();
+                if (options.debug) {
+                    console.log(chalk_1.default.cyan('🐛 DEBUG: Process unref() called'));
+                }
+            }
+            // Handle process events (non-blocking)
+            this.agentProcess.on('error', (error) => {
+                if (options.debug) {
+                    console.log(chalk_1.default.red('🐛 DEBUG: Agent process error:'), error);
+                }
+                console.error('Agent process error:', error);
+                this.agentProcess = null;
+            });
+            this.agentProcess.on('exit', (code, signal) => {
+                if (options.debug) {
+                    console.log(chalk_1.default.yellow(`🐛 DEBUG: Agent process exited with code ${code}${signal ? ` and signal ${signal}` : ''}`));
+                }
+                if (code !== 0) {
+                    console.error(chalk_1.default.red(`Agent process exited with code ${code}`));
+                    if (useSudo && !options.passthrough && code === 1) {
+                        console.error(chalk_1.default.yellow('\n⚠ Sudo may require a password. Try running with:'));
+                        console.error(chalk_1.default.cyan('  edgible agent start --passthrough'));
+                        console.error(chalk_1.default.gray('Or configure passwordless sudo for this command.'));
+                    }
+                }
+                else {
+                    console.log(chalk_1.default.gray(`Agent process exited with code ${code}`));
+                }
+                this.agentProcess = null;
+            });
+            // Capture stderr when using sudo (to see password prompts or errors)
+            if (useSudo && !options.passthrough && this.agentProcess.stderr) {
+                let errorBuffer = '';
+                this.agentProcess.stderr.on('data', (data) => {
+                    const errorText = data.toString();
+                    errorBuffer += errorText;
+                    // If we see sudo password prompt or common errors, display them
+                    if (errorText.includes('password for') ||
+                        errorText.includes('sudo:') ||
+                        errorText.includes('Permission denied') ||
+                        errorText.includes('command not found')) {
+                        console.error(chalk_1.default.red('Sudo error:'), errorText.trim());
+                    }
+                    // Also write to log file
+                    try {
+                        fs.appendFileSync(logFilePath, errorText);
+                    }
+                    catch (err) {
+                        // Ignore log file errors
+                    }
+                });
+                // On process exit, if there was an error, show the full error buffer
+                this.agentProcess.on('exit', (code) => {
+                    if (code !== 0 && errorBuffer.trim()) {
+                        if (options.debug) {
+                            console.log(chalk_1.default.red('🐛 DEBUG: Full stderr output:'), errorBuffer);
+                        }
+                    }
+                });
+            }
+            // Add debug logging for stdout/stderr if not in passthrough mode
+            if (options.debug && !options.passthrough) {
+                this.agentProcess.stdout?.on('data', (data) => {
+                    console.log(chalk_1.default.blue('🐛 DEBUG: Agent stdout:'), data.toString());
+                });
+                if (!useSudo) {
+                    // Only capture stderr in debug if not using sudo (sudo stderr is handled above)
+                    this.agentProcess.stderr?.on('data', (data) => {
+                        console.log(chalk_1.default.red('🐛 DEBUG: Agent stderr:'), data.toString());
+                    });
+                }
+            }
+            // Use a shorter, non-blocking check
+            return new Promise(async (resolve) => {
+                // Quick check after a short delay
+                const delay = options.debug ? 2000 : 100; // Longer delay in debug mode to see error output
+                if (options.debug) {
+                    console.log(chalk_1.default.cyan(`🐛 DEBUG: Setting timeout for ${delay}ms to check process status`));
+                }
+                setTimeout(async () => {
+                    if (this.agentProcess && !this.agentProcess.killed) {
+                        if (options.debug) {
+                            console.log(chalk_1.default.cyan('🐛 DEBUG: Agent process started, waiting for status file...'));
+                        }
+                        // Wait for status file to be created and valid
+                        try {
+                            await this.waitForStatusFile(options.debug);
+                            if (options.debug) {
+                                console.log(chalk_1.default.green('🐛 DEBUG: Status file validated, agent is running'));
+                            }
+                            resolve(true);
+                        }
+                        catch (error) {
+                            if (options.debug) {
+                                console.log(chalk_1.default.red('🐛 DEBUG: Failed to wait for status file:'), error);
+                                // In debug mode, also check if the process is still running
+                                if (this.agentProcess && !this.agentProcess.killed) {
+                                    console.log(chalk_1.default.yellow('🐛 DEBUG: Process is still running but status file not created - agent may have failed to initialize'));
+                                }
+                                else {
+                                    console.log(chalk_1.default.red('🐛 DEBUG: Process has exited - check stderr output above for error details'));
+                                }
+                            }
+                            console.error('Failed to wait for status file:', error);
+                            resolve(false);
+                        }
+                    }
+                    else {
+                        if (options.debug) {
+                            console.log(chalk_1.default.red('🐛 DEBUG: Agent process failed to start or was killed'));
+                        }
+                        resolve(false);
+                    }
+                }, delay);
+            });
+        }
+        catch (error) {
+            console.error('Failed to start agent:', error);
+            this.agentProcess = null;
+            return false;
+        }
+    }
+    /**
+     * Wait for agent to be ready
+     */
+    async waitForAgentReady(debug = false) {
+        try {
+            await this.waitForStatusFile(debug);
+        }
+        catch (error) {
+            throw new Error(`Agent failed to become ready: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Provide troubleshooting steps based on error message
+     */
+    provideTroubleshootingSteps(errorMessage) {
+        console.log(chalk_1.default.yellow('\nTroubleshooting steps:'));
+        if (errorMessage.includes('Device ID')) {
+            console.log('  1. Run "edgible login" to authenticate');
+            console.log('  2. Run "edgible device-login" if using device credentials');
+        }
+        if (errorMessage.includes('Agent binary not found')) {
+            console.log('  1. Run "edgible agent install" to install the agent');
+        }
+        console.log('  2. Run "edgible agent start --debug" for detailed logs');
+    }
+    /**
+     * Log debug information
+     */
+    async logDebugInfo(options) {
+        if (!options.debug)
+            return;
+        console.log(chalk_1.default.cyan('🐛 DEBUG: System Information:'));
+        console.log(chalk_1.default.cyan(`  Platform: ${os.platform()} ${os.arch()}`));
+        console.log(chalk_1.default.cyan(`  Node Version: ${process.version}`));
+        console.log(chalk_1.default.cyan(`  CLI PID: ${process.pid}`));
+        console.log(chalk_1.default.cyan(`  Agent Path: ${this.agentPath}`));
+        console.log(chalk_1.default.cyan(`  Config Path: ${this.configPath}`));
+        // Check environment
+        console.log(chalk_1.default.cyan('🐛 DEBUG: Environment:'));
+        console.log(chalk_1.default.cyan(`  API_BASE_URL: ${(0, urls_1.getApiBaseUrl)()}`));
+        console.log(chalk_1.default.cyan(`  NODE_ENV: ${process.env.NODE_ENV || 'not set'}`));
+        // Check file permissions
+        try {
+            await fs.promises.access(this.configPath, fs.constants.W_OK);
+            console.log(chalk_1.default.cyan('  Config directory: writable'));
+        }
+        catch {
+            console.log(chalk_1.default.red('  Config directory: not writable'));
+        }
+    }
+    /**
+     * Wait for status file to be created and valid
+     */
+    async waitForStatusFile(debug = false) {
+        const maxWait = 15000; // 15 seconds
+        const checkInterval = 500; // 500ms
+        let waited = 0;
+        if (debug) {
+            console.log(chalk_1.default.cyan(`🐛 DEBUG: Waiting for status file (max ${maxWait}ms, checking every ${checkInterval}ms)`));
+        }
+        while (waited < maxWait) {
+            const statusResult = await this.statusManager.getStatus();
+            if (debug) {
+                console.log(chalk_1.default.cyan(`🐛 DEBUG: Status check ${waited}ms: isValid=${statusResult.isValid}, running=${statusResult.status?.running}`));
+            }
+            if (statusResult.isValid && statusResult.status?.running) {
+                if (debug) {
+                    console.log(chalk_1.default.green(`🐛 DEBUG: Status file validated after ${waited}ms`));
+                }
+                return;
+            }
+            await new Promise(resolve => setTimeout(resolve, checkInterval));
+            waited += checkInterval;
+        }
+        if (debug) {
+            console.log(chalk_1.default.red(`🐛 DEBUG: Timeout reached after ${waited}ms - status file not created or invalid`));
+        }
+        throw new Error('Agent failed to start within timeout - status file not created');
+    }
+    /**
+     * Stop local agent service using hybrid approach
+     */
+    async stopLocalAgent() {
+        try {
+            // First check if agent is running in Docker
+            const cliConfig = this.configManager.getConfig();
+            if (cliConfig.deviceId) {
+                const dockerRunning = await this.isDockerAgentRunning(cliConfig.deviceId);
+                if (dockerRunning) {
+                    console.log(chalk_1.default.blue('Agent is running in Docker, stopping container...'));
+                    return await this.stopDockerAgent(cliConfig.deviceId);
+                }
+            }
+            let processStopped = false;
+            // Method 1: Stop the current process if it exists
+            if (this.agentProcess && !this.agentProcess.killed) {
+                console.log('Stopping agent process from current CLI session...');
+                this.agentProcess.kill('SIGTERM');
+                // Wait for process to exit
+                await new Promise((resolve) => {
+                    const timeout = setTimeout(() => {
+                        if (this.agentProcess && !this.agentProcess.killed) {
+                            this.agentProcess.kill('SIGKILL');
+                        }
+                        resolve(true);
+                    }, 5000);
+                    this.agentProcess.on('exit', () => {
+                        clearTimeout(timeout);
+                        resolve(true);
+                    });
+                });
+                this.agentProcess = null;
+                processStopped = true;
+            }
+            // Method 2: Try to stop agent using PID from status file (prioritize this)
+            if (!processStopped) {
+                try {
+                    const statusResult = await this.statusManager.getStatus();
+                    if (statusResult.isValid && statusResult.status?.pid) {
+                        console.log(`Attempting to stop agent process (PID: ${statusResult.status.pid}) from status file...`);
+                        const killed = await this.killProcessByPid(statusResult.status.pid);
+                        if (killed) {
+                            processStopped = true;
+                        }
+                    }
+                }
+                catch (error) {
+                    console.log('Could not read status file for PID:', error instanceof Error ? error.message : 'Unknown error');
+                }
+            }
+            // Method 3: Search for and kill any running agent processes (fallback)
+            if (!processStopped) {
+                console.log('Searching for running agent processes...');
+                const killed = await this.findAndKillAgentProcess();
+                if (killed) {
+                    processStopped = true;
+                }
+            }
+            // Method 4: Clean up any existing agent processes from previous sessions
+            await this.cleanupExistingAgents();
+            // Wait for status file to show stopped (with increased timeout)
+            await this.waitForStoppedStatus();
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to stop agent:', error);
+            return false;
+        }
+    }
+    /**
+     * Wait for status file to show agent is stopped
+     */
+    async waitForStoppedStatus() {
+        const maxWait = 30000; // 30 seconds (increased from 10)
+        const checkInterval = 1000; // 1 second (increased from 500ms)
+        let waited = 0;
+        console.log('Waiting for agent to update status file...');
+        while (waited < maxWait) {
+            const statusResult = await this.statusManager.getStatus();
+            if (!statusResult.isValid || !statusResult.status?.running) {
+                console.log('Agent status updated - stopped');
+                return;
+            }
+            // Show progress every 5 seconds
+            if (waited > 0 && waited % 5000 === 0) {
+                console.log(`Still waiting for agent to stop... (${waited / 1000}s elapsed)`);
+            }
+            await new Promise(resolve => setTimeout(resolve, checkInterval));
+            waited += checkInterval;
+        }
+        // If timeout, continue anyway - the process is likely stopped
+        console.warn(`Timeout waiting for status file to show stopped state (${maxWait / 1000}s)`);
+    }
+    /**
+     * Restart local agent service
+     */
+    async restartLocalAgent() {
+        const stopped = await this.stopLocalAgent();
+        if (!stopped) {
+            return false;
+        }
+        // Wait a moment before restarting
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        return await this.startLocalAgent();
+    }
+    /**
+     * Update local agent to latest version
+     */
+    async updateLocalAgent(options = {}) {
+        try {
+            const currentStatus = await this.checkLocalAgentStatus();
+            if (!currentStatus.installed) {
+                return {
+                    success: false,
+                    error: 'Agent not installed',
+                    requiresRestart: false
+                };
+            }
+            const previousVersion = currentStatus.version;
+            const wasRunning = currentStatus.running;
+            // Stop agent if running
+            if (wasRunning) {
+                await this.stopLocalAgent();
+            }
+            // Backup current installation if requested
+            if (options.backup) {
+                await this.backupCurrentInstallation();
+            }
+            // Install new version
+            const installResult = await this.installLocalAgent({
+                version: options.version,
+                autoStart: false
+            });
+            if (!installResult.success) {
+                return {
+                    success: false,
+                    error: installResult.error,
+                    requiresRestart: false
+                };
+            }
+            // Migrate configuration if requested
+            if (options.configMigration) {
+                await this.migrateConfiguration();
+            }
+            // Restart agent if it was running or if requested
+            if (wasRunning || options.restart) {
+                await this.startLocalAgent();
+            }
+            return {
+                success: true,
+                previousVersion,
+                newVersion: installResult.version,
+                requiresRestart: !wasRunning && !options.restart
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Update failed',
+                requiresRestart: false
+            };
+        }
+    }
+    /**
+     * Configure local agent for specific applications
+     */
+    async configureAgentForApplication(application) {
+        try {
+            const configPath = path.join(this.configPath, 'config.json');
+            let config;
+            // Load existing config or create new one
+            if (fs.existsSync(configPath)) {
+                const configData = await readFile(configPath, 'utf8');
+                config = JSON.parse(configData);
+            }
+            else {
+                config = await this.createDefaultConfig();
+            }
+            // Add application to config
+            if (!application.workloadId) {
+                throw new Error(`Application ${application.id} does not have a workloadId`);
+            }
+            const appConfig = {
+                applicationId: application.id,
+                workloadId: application.workloadId,
+                localPort: application.localPort || application.port,
+                targetPort: application.port,
+                protocol: application.protocol,
+                healthCheck: {
+                    enabled: true,
+                    interval: 30,
+                    timeout: 5,
+                    retries: 3,
+                    expectedStatus: 200
+                },
+                enabled: true
+            };
+            // Check if application already exists
+            const existingIndex = config.applications.findIndex((app) => app.applicationId === application.id);
+            if (existingIndex >= 0) {
+                config.applications[existingIndex] = appConfig;
+            }
+            else {
+                config.applications.push(appConfig);
+            }
+            // Save updated config
+            await writeFile(configPath, JSON.stringify(config, null, 2));
+            return {
+                success: true,
+                configPath,
+                warnings: []
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Configuration failed',
+                warnings: []
+            };
+        }
+    }
+    /**
+     * Monitor local agent health
+     */
+    async monitorAgentHealth() {
+        const checks = [];
+        const startTime = Date.now();
+        // Check if agent is running
+        const isRunning = await this.isAgentRunning();
+        checks.push({
+            name: 'agent_running',
+            status: isRunning ? 'pass' : 'fail',
+            message: isRunning ? 'Agent is running' : 'Agent is not running',
+            timestamp: new Date()
+        });
+        // Check agent process health
+        if (isRunning) {
+            const pid = await this.getAgentPID();
+            const processHealth = await this.checkProcessHealth(pid);
+            checks.push({
+                name: 'process_health',
+                status: processHealth ? 'pass' : 'fail',
+                message: processHealth ? 'Process is healthy' : 'Process is unhealthy',
+                timestamp: new Date()
+            });
+        }
+        // Check configuration
+        const configValid = await this.validateConfiguration();
+        checks.push({
+            name: 'configuration',
+            status: configValid ? 'pass' : 'warn',
+            message: configValid ? 'Configuration is valid' : 'Configuration has issues',
+            timestamp: new Date()
+        });
+        // Check network connectivity
+        const networkHealth = await this.checkNetworkHealth();
+        checks.push({
+            name: 'network',
+            status: networkHealth ? 'pass' : 'warn',
+            message: networkHealth ? 'Network connectivity is good' : 'Network issues detected',
+            timestamp: new Date()
+        });
+        const overall = this.determineOverallHealth(checks);
+        const version = await this.getAgentVersion();
+        const uptime = await this.getAgentUptime();
+        return {
+            overall,
+            checks,
+            lastChecked: new Date(),
+            uptime,
+            version: version || 'unknown'
+        };
+    }
+    // Private helper methods
+    async saveAgentState(state) {
+        // Make this non-blocking by not awaiting
+        this.loadAgentState().then(currentState => {
+            const newState = { ...currentState, ...state, timestamp: new Date() };
+            return writeFile(this.statePath, JSON.stringify(newState, null, 2));
+        }).catch(() => {
+            // Ignore errors saving state
+        });
+    }
+    async loadAgentState() {
+        try {
+            if (fs.existsSync(this.statePath)) {
+                const data = await readFile(this.statePath, 'utf8');
+                return JSON.parse(data);
+            }
+        }
+        catch (error) {
+            // Ignore errors loading state
+        }
+        return {
+            installed: false,
+            running: false,
+            health: 'unknown',
+            version: undefined,
+            pid: undefined,
+            uptime: 0,
+            lastHealthCheck: undefined,
+            error: undefined
+        };
+    }
+    detectPlatform() {
+        const platform = os.platform();
+        if (platform === 'darwin')
+            return 'macos';
+        if (platform === 'linux')
+            return 'linux';
+        if (platform === 'win32')
+            return 'windows';
+        return 'linux'; // Default fallback
+    }
+    async isAgentRunning() {
+        try {
+            const platform = this.detectPlatform();
+            switch (platform) {
+                case 'macos':
+                    return await this.isMacOSServiceRunning();
+                case 'linux':
+                    return await this.isLinuxServiceRunning();
+                case 'windows':
+                    return await this.isWindowsServiceRunning();
+                case 'docker':
+                    return await this.isDockerServiceRunning();
+                default:
+                    return false;
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    async getAgentVersion() {
+        try {
+            const result = (0, child_process_1.execSync)(`${this.agentPath} --version`, { encoding: 'utf8' });
+            return result.trim();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async getAgentPID() {
+        try {
+            const platform = this.detectPlatform();
+            switch (platform) {
+                case 'macos':
+                    return await this.getMacOSServicePID();
+                case 'linux':
+                    return await this.getLinuxServicePID();
+                case 'windows':
+                    return await this.getWindowsServicePID();
+                default:
+                    return undefined;
+            }
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async getAgentUptime() {
+        try {
+            const pid = await this.getAgentPID();
+            if (!pid)
+                return 0;
+            const platform = this.detectPlatform();
+            switch (platform) {
+                case 'macos':
+                    return await this.getMacOSProcessUptime(pid);
+                case 'linux':
+                    return await this.getLinuxProcessUptime(pid);
+                case 'windows':
+                    return await this.getWindowsProcessUptime(pid);
+                default:
+                    return 0;
+            }
+        }
+        catch {
+            return 0;
+        }
+    }
+    async performHealthCheck() {
+        try {
+            // Try to connect to agent health endpoint
+            const healthUrl = 'http://localhost:8080/health';
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 5000);
+            const response = await fetch(healthUrl, { signal: controller.signal });
+            clearTimeout(timeoutId);
+            return { overall: response.ok ? 'healthy' : 'unhealthy' };
+        }
+        catch {
+            return { overall: 'unknown' };
+        }
+    }
+    async copyDirectory(src, dest) {
+        const { execSync } = require('child_process');
+        // Use rsync for efficient directory copying (cross-platform)
+        try {
+            execSync(`rsync -av --exclude=node_modules/.cache --exclude=.git "${src}/" "${dest}/"`, { stdio: 'inherit' });
+        }
+        catch (error) {
+            // Fallback to manual copying if rsync is not available
+            await this.copyDirectoryManual(src, dest);
+        }
+    }
+    async copyDirectoryManual(src, dest) {
+        const readdir = (0, util_1.promisify)(fs.readdir);
+        const stat = (0, util_1.promisify)(fs.stat);
+        const copyFile = (0, util_1.promisify)(fs.copyFile);
+        const items = await readdir(src);
+        for (const item of items) {
+            const srcPath = path.join(src, item);
+            const destPath = path.join(dest, item);
+            const statResult = await stat(srcPath);
+            if (statResult.isDirectory()) {
+                // Skip certain directories that we don't need
+                if (['.git', 'coverage', '__tests__', 'src'].includes(item)) {
+                    continue;
+                }
+                await mkdir(destPath, { recursive: true });
+                await this.copyDirectoryManual(srcPath, destPath);
+            }
+            else {
+                // Skip certain files we don't need
+                if (['.gitignore', 'tsconfig.json', 'jest.config.js', 'package-lock.json'].includes(item)) {
+                    continue;
+                }
+                await copyFile(srcPath, destPath);
+            }
+        }
+    }
+    async installAgentForPlatform(platform, options, targetConfigPath) {
+        try {
+            // Install from local build if requested
+            if (options.installFromLocal) {
+                return await this.installFromLocalBuild(targetConfigPath);
+            }
+            // Download agent from S3 (primary distribution method)
+            return await this.installFromS3(options, targetConfigPath);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Installation failed'
+            };
+        }
+    }
+    async installFromS3(options, targetConfigPath) {
+        try {
+            const DEFAULT_VERSION = 'latest';
+            const distributionUrl = (0, urls_1.getDistributionUrl)();
+            const version = options.version || DEFAULT_VERSION;
+            // Detect device type from config (defaults to 'serving' for local installs)
+            const cliConfig = this.configManager.getConfig();
+            const deviceType = cliConfig.deviceType || 'serving';
+            // Build CloudFront URL with device type prefix
+            // Format: {distributionUrl}/{device-type}/{version}.zip
+            // This matches the S3 path structure we use in deploy-to-s3.sh
+            const downloadUrl = `${distributionUrl}/${deviceType}/${version}.zip`;
+            console.log(chalk_1.default.blue('Downloading agent from CloudFront...'));
+            console.log(chalk_1.default.gray(`  Distribution: ${distributionUrl}`));
+            console.log(chalk_1.default.gray(`  Device Type: ${deviceType}`));
+            console.log(chalk_1.default.gray(`  Version: ${version}`));
+            console.log(chalk_1.default.gray(`  URL: ${downloadUrl}`));
+            // Create temp directory for download
+            const tempDir = path.join(os.tmpdir(), `edgible-agent-${Date.now()}`);
+            await mkdir(tempDir, { recursive: true });
+            const zipPath = path.join(tempDir, 'agent.zip');
+            try {
+                // Download directly from CloudFront (no AWS SDK needed)
+                const response = await fetch(downloadUrl);
+                if (!response.ok) {
+                    let errorMessage = `Failed to download from CloudFront: ${response.status} ${response.statusText}`;
+                    if (response.status === 404) {
+                        errorMessage = `Agent version not found at ${downloadUrl}\n\n` +
+                            `The agent may not have been deployed to S3 yet.\n` +
+                            `To deploy the agent:\n` +
+                            `  1. Navigate to agent-v2 directory\n` +
+                            `  2. Run: npm run build\n` +
+                            `  3. Run: ./scripts/deploy-to-s3.sh --env production\n\n` +
+                            `Expected path: ${version}.zip`;
+                    }
+                    else if (response.status === 403) {
+                        errorMessage = `Access denied to ${downloadUrl}\n\n` +
+                            `This usually means:\n` +
+                            `  1. Agent not deployed: The file doesn't exist\n` +
+                            `     → Deploy agent: cd agent-v2 && ./scripts/deploy-to-s3.sh --env production\n\n` +
+                            `  2. CloudFront misconfiguration: OAC or bucket policy issue\n` +
+                            `     → Check backend Pulumi outputs for distribution status`;
+                    }
+                    throw new Error(errorMessage);
+                }
+                const buffer = await response.arrayBuffer();
+                fs.writeFileSync(zipPath, Buffer.from(buffer));
+                console.log(chalk_1.default.green(`✓ Downloaded to ${zipPath}`));
+                // Extract zip file
+                console.log(chalk_1.default.gray('Extracting agent files...'));
+                const extractPath = path.join(tempDir, 'extracted');
+                await mkdir(extractPath, { recursive: true });
+                // Use unzip command (available on most systems)
+                (0, child_process_1.execSync)(`unzip -q "${zipPath}" -d "${extractPath}"`, {
+                    stdio: 'pipe'
+                });
+                // Copy extracted files to agent directory
+                await this.copyDirectory(extractPath, targetConfigPath);
+                // Make the agent binary executable
+                const agentBinaryPath = path.join(targetConfigPath, 'index.js');
+                if (fs.existsSync(agentBinaryPath)) {
+                    fs.chmodSync(agentBinaryPath, '755');
+                }
+                // Create logs directory
+                const logsDir = path.join(targetConfigPath, 'logs');
+                if (!fs.existsSync(logsDir)) {
+                    await mkdir(logsDir, { recursive: true });
+                }
+                // Clean up temp directory
+                fs.rmSync(tempDir, { recursive: true, force: true });
+                console.log(chalk_1.default.green('✓ Agent downloaded and installed from S3'));
+                return {
+                    success: true,
+                    version: version
+                };
+            }
+            catch (downloadError) {
+                // Clean up temp directory on error
+                if (fs.existsSync(tempDir)) {
+                    fs.rmSync(tempDir, { recursive: true, force: true });
+                }
+                throw downloadError;
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'S3 download failed'
+            };
+        }
+    }
+    async installFromLocalBuild(targetConfigPath) {
+        try {
+            // Determine the agent-v2 directory path relative to CLI
+            // __dirname in compiled JS will be in cli/dist/services, so we go up to workspace root
+            const cliDir = path.resolve(__dirname, '..', '..');
+            const workspaceRoot = path.resolve(cliDir, '..');
+            const agentV2Path = path.join(workspaceRoot, 'agent-v2');
+            const agentDistPath = path.join(agentV2Path, 'dist');
+            // Detect device type from config (defaults to 'serving' for local installs)
+            const cliConfig = this.configManager.getConfig();
+            const deviceType = cliConfig.deviceType || 'serving';
+            console.log(chalk_1.default.blue('Installing agent from local build...'));
+            console.log(chalk_1.default.gray(`  Source: ${agentDistPath}`));
+            console.log(chalk_1.default.gray(`  Target: ${targetConfigPath}`));
+            console.log(chalk_1.default.gray(`  Device Type: ${deviceType}`));
+            // Check if local build exists, and if not, build it for the correct device type
+            if (!fs.existsSync(agentDistPath) || !fs.existsSync(path.join(agentDistPath, 'index.js'))) {
+                console.log(chalk_1.default.yellow('⚠ Local build not found or incomplete, building agent...'));
+                const { execSync } = require('child_process');
+                const buildCommand = deviceType === 'serving' ? 'npm run build:serving' : 'npm run build:gateway';
+                console.log(chalk_1.default.gray(`  Running: ${buildCommand}`));
+                try {
+                    execSync(buildCommand, {
+                        cwd: agentV2Path,
+                        stdio: 'inherit'
+                    });
+                    console.log(chalk_1.default.green('✓ Build completed'));
+                }
+                catch (buildError) {
+                    throw new Error(`Failed to build agent: ${buildError instanceof Error ? buildError.message : String(buildError)}\n\n` +
+                        `Please build manually:\n` +
+                        `  cd agent-v2\n` +
+                        `  npm run build:${deviceType}`);
+                }
+            }
+            else {
+                // Verify the build matches the device type (check if gateway code exists)
+                const gatewayCodePath = path.join(agentDistPath, 'gateway');
+                const hasGatewayCode = fs.existsSync(gatewayCodePath);
+                if (deviceType === 'serving' && hasGatewayCode) {
+                    console.log(chalk_1.default.yellow('⚠ Build contains gateway code but device type is serving, rebuilding...'));
+                    const { execSync } = require('child_process');
+                    console.log(chalk_1.default.gray(`  Running: npm run build:serving`));
+                    try {
+                        execSync('npm run build:serving', {
+                            cwd: agentV2Path,
+                            stdio: 'inherit'
+                        });
+                        console.log(chalk_1.default.green('✓ Rebuild completed'));
+                    }
+                    catch (buildError) {
+                        throw new Error(`Failed to rebuild agent for serving device: ${buildError instanceof Error ? buildError.message : String(buildError)}`);
+                    }
+                }
+                else if (deviceType === 'gateway' && !hasGatewayCode) {
+                    console.log(chalk_1.default.yellow('⚠ Build missing gateway code but device type is gateway, rebuilding...'));
+                    const { execSync } = require('child_process');
+                    console.log(chalk_1.default.gray(`  Running: npm run build:gateway`));
+                    try {
+                        execSync('npm run build:gateway', {
+                            cwd: agentV2Path,
+                            stdio: 'inherit'
+                        });
+                        console.log(chalk_1.default.green('✓ Rebuild completed'));
+                    }
+                    catch (buildError) {
+                        throw new Error(`Failed to rebuild agent for gateway device: ${buildError instanceof Error ? buildError.message : String(buildError)}`);
+                    }
+                }
+            }
+            // Check if index.js exists in the build
+            const indexPath = path.join(agentDistPath, 'index.js');
+            if (!fs.existsSync(indexPath)) {
+                throw new Error(`Agent entry point not found at ${indexPath}\n\n` +
+                    `The build may be incomplete. Please rebuild:\n` +
+                    `  cd agent-v2\n` +
+                    `  npm run build`);
+            }
+            // Copy dist directory contents to target
+            console.log(chalk_1.default.gray('Copying agent files...'));
+            await this.copyDirectory(agentDistPath, targetConfigPath);
+            // Copy package.json to target directory (needed for npm install)
+            const packageJsonPath = path.join(agentV2Path, 'package.json');
+            if (fs.existsSync(packageJsonPath)) {
+                const targetPackageJsonPath = path.join(targetConfigPath, 'package.json');
+                fs.copyFileSync(packageJsonPath, targetPackageJsonPath);
+                console.log(chalk_1.default.gray('✓ Copied package.json'));
+            }
+            else {
+                throw new Error(`package.json not found at ${packageJsonPath}\n\n` +
+                    `This is required for installing dependencies.`);
+            }
+            // Install production dependencies
+            console.log(chalk_1.default.gray('Installing production dependencies...'));
+            try {
+                (0, child_process_1.execSync)('npm install --production --no-optional', {
+                    cwd: targetConfigPath,
+                    stdio: 'inherit'
+                });
+                console.log(chalk_1.default.green('✓ Dependencies installed'));
+            }
+            catch (error) {
+                throw new Error(`Failed to install dependencies: ${error instanceof Error ? error.message : String(error)}\n\n` +
+                    `Make sure npm is available and you have write permissions to ${targetConfigPath}`);
+            }
+            // Make the agent binary executable
+            const agentBinaryPath = path.join(targetConfigPath, 'index.js');
+            if (fs.existsSync(agentBinaryPath)) {
+                fs.chmodSync(agentBinaryPath, '755');
+            }
+            // Create logs directory
+            const logsDir = path.join(targetConfigPath, 'logs');
+            if (!fs.existsSync(logsDir)) {
+                await mkdir(logsDir, { recursive: true });
+            }
+            console.log(chalk_1.default.green('✓ Agent installed from local build'));
+            return {
+                success: true,
+                version: 'local-dev'
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Local installation failed'
+            };
+        }
+    }
+    async createDefaultConfig() {
+        // Get device credentials from CLI config
+        const cliConfig = this.configManager.getConfig();
+        // Create agent-v2 configuration using actual device credentials
+        const agentV2Config = {
+            deviceId: cliConfig.deviceId || 'edgible-device-' + Math.random().toString(36).substr(2, 9),
+            devicePassword: cliConfig.devicePassword || 'edgible-password-' + Math.random().toString(36).substr(2, 9),
+            deviceType: cliConfig.deviceType || 'serving',
+            apiBaseUrl: (0, urls_1.getApiBaseUrl)(),
+            firewallEnabled: true,
+            pollingInterval: 60000,
+            healthCheckTimeout: 5000,
+            maxRetries: 3,
+            logLevel: 'info',
+            updateEnabled: true,
+            updateCheckInterval: 3600000,
+            wireguardMode: cliConfig.wireguardMode || 'kernel',
+            wireguardGoBinary: cliConfig.wireguardGoBinary || 'wireguard-go'
+        };
+        const agentV2ConfigPath = path.join(this.configPath, 'agent.config.json');
+        await writeFile(agentV2ConfigPath, JSON.stringify(agentV2Config, null, 2));
+        // Also create the legacy config for compatibility
+        const config = {
+            version: '1.0.0',
+            applications: [],
+            gateway: {
+                gatewayId: '',
+                publicIp: '',
+                region: 'us-east-1'
+            },
+            monitoring: {
+                enabled: true,
+                interval: 30,
+                alerting: {
+                    enabled: false,
+                    emailNotifications: false,
+                    thresholds: {
+                        responseTime: 1000,
+                        errorRate: 5,
+                        availability: 95
+                    }
+                }
+            },
+            logging: {
+                level: 'info',
+                console: true
+            }
+        };
+        const configPath = path.join(this.configPath, 'config.json');
+        await writeFile(configPath, JSON.stringify(config, null, 2));
+        return config;
+    }
+    async setupService(options) {
+        // Platform-specific service setup would go here
+        return { success: true };
+    }
+    async backupCurrentInstallation() {
+        const backupPath = `${this.agentPath}.backup.${Date.now()}`;
+        fs.copyFileSync(this.agentPath, backupPath);
+    }
+    async migrateConfiguration() {
+        // Configuration migration logic would go here
+    }
+    // Platform-specific service management methods (placeholders)
+    async startMacOSService() { return true; }
+    async stopMacOSService() { return true; }
+    async isMacOSServiceRunning() { return false; }
+    async getMacOSServicePID() { return undefined; }
+    async getMacOSProcessUptime(pid) { return 0; }
+    async startLinuxService() { return true; }
+    async stopLinuxService() { return true; }
+    async isLinuxServiceRunning() { return false; }
+    async getLinuxServicePID() { return undefined; }
+    async getLinuxProcessUptime(pid) { return 0; }
+    async startWindowsService() { return true; }
+    async stopWindowsService() { return true; }
+    async isWindowsServiceRunning() { return false; }
+    async getWindowsServicePID() { return undefined; }
+    async getWindowsProcessUptime(pid) { return 0; }
+    async startDockerService() { return true; }
+    async stopDockerService() { return true; }
+    async isDockerServiceRunning() { return false; }
+    async checkProcessHealth(pid) {
+        if (!pid)
+            return false;
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async validateConfiguration() {
+        try {
+            const configPath = path.join(this.configPath, 'config.json');
+            if (!fs.existsSync(configPath))
+                return false;
+            const configData = await readFile(configPath, 'utf8');
+            JSON.parse(configData);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async checkNetworkHealth() {
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 5000);
+            const response = await fetch('http://localhost:8080/health', { signal: controller.signal });
+            clearTimeout(timeoutId);
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    determineOverallHealth(checks) {
+        const failed = checks.filter(c => c.status === 'fail');
+        const warnings = checks.filter(c => c.status === 'warn');
+        if (failed.length > 0)
+            return 'unhealthy';
+        if (warnings.length > 0)
+            return 'degraded';
+        if (checks.every(c => c.status === 'pass'))
+            return 'healthy';
+        return 'unknown';
+    }
+    /**
+     * Display agent status in a user-friendly format
+     */
+    displayAgentStatus(status) {
+        console.log(chalk_1.default.blue('🤖 Local Agent Status:'));
+        console.log(chalk_1.default.white(`  Installed: ${status.installed ? chalk_1.default.green('Yes') : chalk_1.default.red('No')}`));
+        console.log(chalk_1.default.white(`  Running: ${status.running ? chalk_1.default.green('Yes') : chalk_1.default.red('No')}`));
+        console.log(chalk_1.default.white(`  Health: ${status.health === 'healthy' ? chalk_1.default.green('Healthy') :
+            status.health === 'degraded' ? chalk_1.default.yellow('Degraded') :
+                status.health === 'unhealthy' ? chalk_1.default.red('Unhealthy') : chalk_1.default.gray('Unknown')}`));
+        if (status.version) {
+            console.log(chalk_1.default.white(`  Version: ${status.version}`));
+        }
+        if (status.pid) {
+            console.log(chalk_1.default.white(`  PID: ${status.pid}`));
+        }
+        if (status.uptime) {
+            console.log(chalk_1.default.white(`  Uptime: ${Math.floor(status.uptime / 1000)}s`));
+        }
+        if (status.deviceId) {
+            console.log(chalk_1.default.white(`  Device ID: ${status.deviceId}`));
+        }
+        if (status.deviceType) {
+            console.log(chalk_1.default.white(`  Device Type: ${status.deviceType}`));
+        }
+        if (status.apiConnected !== undefined) {
+            console.log(chalk_1.default.white(`  API Connected: ${status.apiConnected ? chalk_1.default.green('Yes') : chalk_1.default.red('No')}`));
+        }
+        if (status.apiAuthenticated !== undefined) {
+            console.log(chalk_1.default.white(`  API Authenticated: ${status.apiAuthenticated ? chalk_1.default.green('Yes') : chalk_1.default.red('No')}`));
+        }
+        if (status.applications && status.applications.length > 0) {
+            console.log(chalk_1.default.white(`  Applications: ${status.applications.length}`));
+        }
+        if (status.lastError) {
+            console.log(chalk_1.default.red(`  Error: ${status.lastError}`));
+        }
+        if (!status.installed) {
+            console.log(chalk_1.default.yellow('\n💡 To install the agent, run: edgible agent install'));
+        }
+        else if (!status.running) {
+            console.log(chalk_1.default.yellow('\n💡 To start the agent, run: edgible agent start'));
+        }
+    }
+    /**
+     * Kill a process by PID using cross-platform approach
+     */
+    async killProcessByPid(pid) {
+        const platform = os.platform();
+        try {
+            if (platform === 'win32') {
+                // Windows: Use taskkill
+                const { exec } = require('child_process');
+                await new Promise((resolve, reject) => {
+                    exec(`taskkill /PID ${pid} /T /F`, (error) => {
+                        if (error && !error.message.includes('not found')) {
+                            reject(error);
+                        }
+                        else {
+                            resolve();
+                        }
+                    });
+                });
+            }
+            else {
+                // Unix-like: Use kill
+                process.kill(pid, 'SIGTERM');
+                // Wait for graceful shutdown
+                for (let i = 0; i < 50; i++) {
+                    try {
+                        process.kill(pid, 0);
+                        await new Promise(resolve => setTimeout(resolve, 100));
+                    }
+                    catch {
+                        return true; // Process killed
+                    }
+                }
+                // Force kill if still running
+                process.kill(pid, 'SIGKILL');
+            }
+            return true;
+        }
+        catch (error) {
+            console.log(`Failed to kill process ${pid}:`, error instanceof Error ? error.message : 'Unknown error');
+            return false;
+        }
+    }
+    /**
+     * Find and kill any running agent processes using cross-platform process search
+     */
+    async findAndKillAgentProcess() {
+        try {
+            const list = await (0, find_process_1.default)('name', this.agentPath, true);
+            if (list.length > 0) {
+                let killedAny = false;
+                for (const process of list) {
+                    console.log(`Killing agent process ${process.pid}...`);
+                    const killed = await this.killProcessByPid(process.pid);
+                    if (killed) {
+                        killedAny = true;
+                    }
+                }
+                return killedAny;
+            }
+            return false;
+        }
+        catch (error) {
+            console.log('Error searching for agent processes:', error.message);
+            return false;
+        }
+    }
+    /**
+     * Clean up any existing agent processes
+     */
+    async cleanupExistingAgents(debug = false) {
+        try {
+            if (debug) {
+                console.log(chalk_1.default.cyan('🐛 DEBUG: Starting cleanup of existing agents'));
+            }
+            // Use our improved process finding and killing method
+            try {
+                if (debug) {
+                    console.log(chalk_1.default.cyan('🐛 DEBUG: Checking for existing agent processes'));
+                }
+                const killed = await this.findAndKillAgentProcess();
+                if (killed) {
+                    if (debug) {
+                        console.log(chalk_1.default.yellow('🐛 DEBUG: Successfully killed existing agent processes'));
+                    }
+                }
+                else {
+                    if (debug) {
+                        console.log(chalk_1.default.cyan('🐛 DEBUG: No existing agent processes found'));
+                    }
+                }
+            }
+            catch (error) {
+                if (debug) {
+                    console.log(chalk_1.default.yellow('🐛 DEBUG: Process cleanup failed, continuing anyway'), error);
+                }
+                // Ignore cleanup errors - this is a best-effort cleanup
+            }
+            if (debug) {
+                console.log(chalk_1.default.cyan('🐛 DEBUG: Cleanup completed'));
+            }
+        }
+        catch (error) {
+            if (debug) {
+                console.log(chalk_1.default.red('🐛 DEBUG: Error in cleanup:'), error);
+            }
+            // Ignore cleanup errors
+        }
+    }
+    /**
+     * Get current log configuration
+     */
+    async getLogConfiguration() {
+        try {
+            const configPath = path.join(this.configPath, 'agent.config.json');
+            if (!fs.existsSync(configPath)) {
+                // Return default configuration
+                const defaultLevel = 'info';
+                const moduleLevels = new Map();
+                ['agent', 'caddy', 'firewall', 'health', 'status', 'update'].forEach(module => {
+                    moduleLevels.set(module, defaultLevel);
+                });
+                return { globalLevel: defaultLevel, moduleLevels };
+            }
+            const configData = fs.readFileSync(configPath, 'utf8');
+            const config = JSON.parse(configData);
+            const globalLevel = config.logLevel || 'info';
+            const moduleLevels = new Map();
+            // Set default levels for all modules
+            ['agent', 'api-client', 'caddy', 'firewall', 'health', 'status', 'update'].forEach(module => {
+                moduleLevels.set(module, globalLevel);
+            });
+            // Override with module-specific levels if they exist
+            if (config.logModules) {
+                Object.entries(config.logModules).forEach(([module, level]) => {
+                    if (level && typeof level === 'string') {
+                        moduleLevels.set(module, level);
+                    }
+                });
+            }
+            return { globalLevel, moduleLevels };
+        }
+        catch (error) {
+            console.error('Failed to read log configuration:', error);
+            throw error;
+        }
+    }
+    /**
+     * Update global log level
+     */
+    async updateGlobalLogLevel(level) {
+        try {
+            const configPath = path.join(this.configPath, 'agent.config.json');
+            if (!fs.existsSync(configPath)) {
+                throw new Error('Agent configuration file not found');
+            }
+            const configData = fs.readFileSync(configPath, 'utf8');
+            const config = JSON.parse(configData);
+            config.logLevel = level;
+            await writeFile(configPath, JSON.stringify(config, null, 2));
+        }
+        catch (error) {
+            console.error('Failed to update global log level:', error);
+            throw error;
+        }
+    }
+    /**
+     * Update module-specific log level
+     */
+    async updateModuleLogLevel(module, level) {
+        try {
+            const configPath = path.join(this.configPath, 'agent.config.json');
+            if (!fs.existsSync(configPath)) {
+                throw new Error('Agent configuration file not found');
+            }
+            const configData = fs.readFileSync(configPath, 'utf8');
+            const config = JSON.parse(configData);
+            if (!config.logModules) {
+                config.logModules = {};
+            }
+            config.logModules[module] = level;
+            await writeFile(configPath, JSON.stringify(config, null, 2));
+        }
+        catch (error) {
+            console.error('Failed to update module log level:', error);
+            throw error;
+        }
+    }
+    /**
+     * Reset module to use global log level
+     */
+    async resetModuleLogLevel(module) {
+        try {
+            const configPath = path.join(this.configPath, 'agent.config.json');
+            if (!fs.existsSync(configPath)) {
+                throw new Error('Agent configuration file not found');
+            }
+            const configData = fs.readFileSync(configPath, 'utf8');
+            const config = JSON.parse(configData);
+            if (config.logModules && config.logModules[module]) {
+                delete config.logModules[module];
+                // If no more module-specific levels, remove the logModules object
+                if (Object.keys(config.logModules).length === 0) {
+                    delete config.logModules;
+                }
+                await writeFile(configPath, JSON.stringify(config, null, 2));
+            }
+        }
+        catch (error) {
+            console.error('Failed to reset module log level:', error);
+            throw error;
+        }
+    }
+    /**
+     * Reset all modules to use global log level
+     */
+    async resetAllModuleLogLevels() {
+        try {
+            const configPath = path.join(this.configPath, 'agent.config.json');
+            if (!fs.existsSync(configPath)) {
+                throw new Error('Agent configuration file not found');
+            }
+            const configData = fs.readFileSync(configPath, 'utf8');
+            const config = JSON.parse(configData);
+            if (config.logModules) {
+                delete config.logModules;
+                await writeFile(configPath, JSON.stringify(config, null, 2));
+            }
+        }
+        catch (error) {
+            console.error('Failed to reset all module log levels:', error);
+            throw error;
+        }
+    }
+    async getStartCommand() {
+        const cliConfig = this.configManager.getConfig();
+        const configPath = path.join(this.configPath, 'agent.config.json');
+        const args = [
+            'node',
+            this.agentPath,
+            'start',
+            '-c',
+            configPath,
+            '--device-id',
+            cliConfig.deviceId || 'unknown',
+            '--device-type',
+            cliConfig.deviceType || 'serving',
+            '--api-url',
+            (0, urls_1.getApiBaseUrl)(),
+        ];
+        if (cliConfig.organizationId) {
+            args.push('--organization-id', cliConfig.organizationId);
+        }
+        return args.join(' ');
+    }
+    /**
+     * Get the path to the agent log file
+     */
+    getLogFilePath() {
+        return path.join(this.configPath, 'logs', 'agent.log');
+    }
+    /**
+     * Check if Docker is available
+     */
+    async checkDockerAvailable() {
+        try {
+            (0, child_process_1.execSync)('docker --version', { encoding: 'utf8', timeout: 5000 });
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Check if Docker image exists locally
+     */
+    async checkDockerImageExists(imageName = 'wireguard-mcp-agent:latest') {
+        try {
+            const output = (0, child_process_1.execSync)(`docker images --format "{{.Repository}}:{{.Tag}}" | grep -q "^${imageName}$" && echo "exists" || echo "not-found"`, { encoding: 'utf8', timeout: 10000 });
+            return output.trim() === 'exists';
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Recursively copy a directory
+     */
+    copyDirectorySync(source, destination) {
+        // Create destination directory if it doesn't exist
+        if (!fs.existsSync(destination)) {
+            (0, fs_1.mkdirSync)(destination, { recursive: true });
+        }
+        // Read source directory
+        const entries = (0, fs_1.readdirSync)(source, { withFileTypes: true });
+        for (const entry of entries) {
+            const sourcePath = path.join(source, entry.name);
+            const destPath = path.join(destination, entry.name);
+            if (entry.isDirectory()) {
+                // Recursively copy subdirectories
+                this.copyDirectorySync(sourcePath, destPath);
+            }
+            else {
+                // Copy files
+                (0, fs_1.copyFileSync)(sourcePath, destPath);
+            }
+        }
+    }
+    /**
+     * Copy backend directories to temp-sst-copy (required for Docker build)
+     */
+    async copySstDirectories(agentV2Path, debug) {
+        const tempDir = path.join(agentV2Path, 'temp-sst-copy');
+        const backendPath = path.resolve(agentV2Path, '..', 'backend');
+        if (debug) {
+            console.log(chalk_1.default.cyan(`🐛 DEBUG: Copying backend directories to temp-sst-copy`));
+            console.log(chalk_1.default.cyan(`🐛 DEBUG: Backend path: ${backendPath}`));
+            console.log(chalk_1.default.cyan(`🐛 DEBUG: Temp dir: ${tempDir}`));
+        }
+        // Check if backend directory exists
+        if (!fs.existsSync(backendPath)) {
+            throw new Error(`Backend directory not found at ${backendPath}. Expected structure: wireguard-private-mcp/backend and wireguard-private-mcp/agent-v2`);
+        }
+        // Create temp directory structure
+        const tempSrcPath = path.join(tempDir, 'src');
+        await mkdir(tempSrcPath, { recursive: true });
+        // Copy client directory
+        const backendClientPath = path.join(backendPath, 'src', 'client');
+        const tempClientPath = path.join(tempSrcPath, 'client');
+        if (!fs.existsSync(backendClientPath)) {
+            throw new Error(`Client directory not found at ${backendClientPath}`);
+        }
+        this.copyDirectorySync(backendClientPath, tempClientPath);
+        // Copy types directory
+        const backendTypesPath = path.join(backendPath, 'src', 'types');
+        const tempTypesPath = path.join(tempSrcPath, 'types');
+        if (!fs.existsSync(backendTypesPath)) {
+            throw new Error(`Types directory not found at ${backendTypesPath}`);
+        }
+        this.copyDirectorySync(backendTypesPath, tempTypesPath);
+        // Validate copies
+        if (!fs.existsSync(tempClientPath) || !fs.existsSync(tempTypesPath)) {
+            throw new Error(`Failed to validate copied directories. Expected: ${tempClientPath} and ${tempTypesPath}`);
+        }
+        if (debug) {
+            console.log(chalk_1.default.cyan(`🐛 DEBUG: Successfully copied backend directories`));
+        }
+    }
+    /**
+     * Build Docker image
+     */
+    async buildDockerImage(imageName = 'wireguard-mcp-agent:latest', debug) {
+        try {
+            // Try to find agent-v2 directory relative to CLI directory
+            // Note: This feature requires development environment setup
+            const cliDir = path.resolve(__dirname, '../..');
+            const workspaceRoot = path.resolve(cliDir, '..');
+            const agentV2Path = path.join(workspaceRoot, 'agent-v2');
+            if (!fs.existsSync(agentV2Path)) {
+                throw new Error('Agent source directory not found. Docker image building requires development environment setup.\n' +
+                    'This feature is not available in the npm-installed version of the CLI.\n' +
+                    'For production use, agents should be deployed via S3 distribution.');
+            }
+            if (debug) {
+                console.log(chalk_1.default.cyan(`🐛 DEBUG: Building Docker image: ${imageName}`));
+                console.log(chalk_1.default.cyan(`🐛 DEBUG: Build context: ${agentV2Path}`));
+            }
+            console.log(chalk_1.default.blue(`Building Docker image ${imageName}...`));
+            // Create temp-sst-copy directory with backend directories (required for build)
+            console.log(chalk_1.default.gray('Preparing build dependencies...'));
+            await this.copySstDirectories(agentV2Path, debug);
+            // Build the Docker image
+            (0, child_process_1.execSync)(`docker build -t ${imageName} .`, {
+                cwd: agentV2Path,
+                stdio: debug ? 'inherit' : 'pipe',
+                encoding: 'utf8',
+                timeout: 600000 // 10 minutes
+            });
+            console.log(chalk_1.default.green(`✓ Docker image ${imageName} built successfully`));
+            return true;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk_1.default.red(`Failed to build Docker image: ${errorMessage}`));
+            return false;
+        }
+    }
+    /**
+     * Get Docker container name for device
+     */
+    getDockerContainerName(deviceId) {
+        return `wireguard-mcp-agent-${deviceId}`;
+    }
+    /**
+     * Spawn agent in Docker container
+     */
+    async spawnDockerAgent(options) {
+        try {
+            // Check if Docker is available
+            const dockerAvailable = await this.checkDockerAvailable();
+            if (!dockerAvailable) {
+                throw new Error('Docker is not available. Please install Docker and ensure it is running.');
+            }
+            // Get device credentials from CLI config
+            const cliConfig = this.configManager.getConfig();
+            if (!cliConfig.deviceId || !cliConfig.devicePassword) {
+                throw new Error('No device credentials found in CLI config');
+            }
+            // Update agent configuration
+            await this.updateAgentConfig();
+            const imageName = 'wireguard-mcp-agent:latest';
+            const containerName = this.getDockerContainerName(cliConfig.deviceId);
+            // Check if container is already running
+            try {
+                const statusOutput = (0, child_process_1.execSync)(`docker ps --filter "name=${containerName}" --format "{{.Status}}"`, { encoding: 'utf8', timeout: 5000 });
+                if (statusOutput.trim()) {
+                    console.log(chalk_1.default.yellow(`Container ${containerName} is already running`));
+                    return true;
+                }
+            }
+            catch (error) {
+                // Container not running, continue
+            }
+            // Check if image exists, build if missing
+            const imageExists = await this.checkDockerImageExists(imageName);
+            if (!imageExists) {
+                console.log(chalk_1.default.blue(`Docker image ${imageName} not found, building...`));
+                const built = await this.buildDockerImage(imageName, options.debug);
+                if (!built) {
+                    throw new Error('Failed to build Docker image');
+                }
+            }
+            // Prepare environment variables
+            const envVars = [
+                `DEVICE_ID=${cliConfig.deviceId}`,
+                `DEVICE_PASSWORD=${cliConfig.devicePassword}`,
+                `DEVICE_TYPE=${cliConfig.deviceType || 'serving'}`,
+                `API_BASE_URL=${(0, urls_1.getApiBaseUrl)()}`,
+                `LOG_LEVEL=${options.debug ? 'debug' : 'info'}`
+            ];
+            if (cliConfig.organizationId) {
+                envVars.push(`ORGANIZATION_ID=${cliConfig.organizationId}`);
+            }
+            // Prepare docker run command
+            const configPath = path.join(this.configPath, 'agent.config.json');
+            const dockerArgs = [
+                'run',
+                '-d',
+                '--name', containerName,
+                '--restart', 'unless-stopped',
+                '--network', 'host',
+                '-v', `${configPath}:/app/agent.config.json:ro`,
+                ...envVars.flatMap(env => ['-e', env]),
+                imageName,
+                'start'
+            ];
+            if (options.debug) {
+                console.log(chalk_1.default.cyan('🐛 DEBUG: Docker command:'));
+                console.log(chalk_1.default.cyan(`  docker ${dockerArgs.join(' ')}`));
+            }
+            console.log(chalk_1.default.blue(`Starting agent in Docker container: ${containerName}...`));
+            (0, child_process_1.execSync)(`docker ${dockerArgs.join(' ')}`, {
+                stdio: options.debug ? 'inherit' : 'pipe',
+                encoding: 'utf8',
+                timeout: 30000
+            });
+            console.log(chalk_1.default.green(`✓ Agent started in Docker container: ${containerName}`));
+            console.log(chalk_1.default.gray(`  Use 'docker logs ${containerName}' to view logs`));
+            console.log(chalk_1.default.yellow(`  Note: Running without privileges - some features may be limited`));
+            return true;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk_1.default.red('Failed to start agent in Docker:'), errorMessage);
+            return false;
+        }
+    }
+    /**
+     * Stop Docker agent container
+     */
+    async stopDockerAgent(deviceId) {
+        try {
+            const containerName = this.getDockerContainerName(deviceId);
+            // Check if container exists
+            try {
+                (0, child_process_1.execSync)(`docker ps -a --filter "name=${containerName}" --format "{{.Names}}"`, {
+                    encoding: 'utf8',
+                    timeout: 5000
+                });
+            }
+            catch (error) {
+                console.log(chalk_1.default.yellow(`Container ${containerName} not found`));
+                return true; // Already stopped/removed
+            }
+            console.log(chalk_1.default.blue(`Stopping Docker container: ${containerName}...`));
+            // Stop container
+            try {
+                (0, child_process_1.execSync)(`docker stop ${containerName}`, {
+                    encoding: 'utf8',
+                    timeout: 30000,
+                    stdio: 'pipe'
+                });
+            }
+            catch (error) {
+                // Container might already be stopped
+            }
+            // Remove container
+            try {
+                (0, child_process_1.execSync)(`docker rm ${containerName}`, {
+                    encoding: 'utf8',
+                    timeout: 10000,
+                    stdio: 'pipe'
+                });
+            }
+            catch (error) {
+                // Container might already be removed
+            }
+            console.log(chalk_1.default.green(`✓ Docker container ${containerName} stopped and removed`));
+            return true;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk_1.default.red(`Failed to stop Docker container: ${errorMessage}`));
+            return false;
+        }
+    }
+    /**
+     * Check Docker agent container status
+     */
+    async checkDockerAgentStatus(deviceId) {
+        try {
+            const containerName = this.getDockerContainerName(deviceId);
+            const output = (0, child_process_1.execSync)(`docker ps --filter "name=${containerName}" --format "{{.Status}}"`, { encoding: 'utf8', timeout: 5000 });
+            if (output.trim()) {
+                return { running: true, status: output.trim() };
+            }
+            return { running: false };
+        }
+        catch (error) {
+            return { running: false };
+        }
+    }
+    /**
+     * Get Docker agent container logs
+     */
+    async getDockerAgentLogs(deviceId, follow = false) {
+        try {
+            const containerName = this.getDockerContainerName(deviceId);
+            const args = ['logs'];
+            if (follow) {
+                args.push('-f');
+            }
+            args.push(containerName);
+            (0, child_process_1.execSync)(`docker ${args.join(' ')}`, {
+                stdio: 'inherit',
+                encoding: 'utf8'
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk_1.default.red(`Failed to get Docker logs: ${errorMessage}`));
+        }
+    }
+}
+exports.LocalAgentManager = LocalAgentManager;
+//# sourceMappingURL=LocalAgentManager.js.map