@edgible-team/cli 1.2.4 → 1.2.8

package/dist/commands/agent/install.d.ts

@@ -0,0 +1,11 @@
+import { LocalAgentManager } from '../../services/LocalAgentManager';
+import { EdgibleService } from '../../services/edgible';
+import { Logger } from '../../utils/logger';
+import { ConfigManager } from '../../state/config';
+import { AuthService } from '../../services/auth/AuthService';
+export declare function handleAgentInstall(options: {
+    type?: string;
+    dev?: boolean;
+    local?: boolean;
+}, logger: Logger, configManager: ConfigManager, edgibleService: EdgibleService, authService: AuthService, agentManager: LocalAgentManager): Promise<void>;
+//# sourceMappingURL=install.d.ts.map

package/dist/commands/agent/install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../../src/commands/agent/install.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAU9D,wBAAsB,kBAAkB,CACtC,OAAO,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,EAC1D,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,aAAa,EAC5B,cAAc,EAAE,cAAc,EAC9B,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,iBAAiB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAkZf"}

package/dist/commands/agent/install.js

@@ -0,0 +1,399 @@
+"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.handleAgentInstall = handleAgentInstall;
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const os = __importStar(require("os"));
+const config_validator_1 = require("../utils/config-validator");
+const DependencyInstaller_1 = require("../../services/DependencyInstaller");
+const PlatformDetector_1 = require("../../utils/PlatformDetector");
+const DaemonManagerFactory_1 = require("../../services/daemon/DaemonManagerFactory");
+const PathResolver_1 = require("../../utils/PathResolver");
+const urls_1 = require("../../utils/urls");
+const sudo_checker_1 = require("../../utils/sudo-checker");
+async function handleAgentInstall(options, logger, configManager, edgibleService, authService, agentManager) {
+    if (!(0, sudo_checker_1.checkSudoPermissions)()) {
+        console.log(chalk_1.default.redBright("Please run this command with administrator priviledges (i.e. sudo)"));
+        return;
+    }
+    (0, config_validator_1.validateConfig)(configManager, {
+        requireAuth: true,
+        requireOrganization: true,
+    });
+    console.log(chalk_1.default.blue.bold('\n═══════════════════════════════════════════'));
+    console.log(chalk_1.default.blue.bold('   Edgible Agent Installation'));
+    console.log(chalk_1.default.blue.bold('═══════════════════════════════════════════\n'));
+    // Step 1: Check platform and root privileges
+    const platform = PlatformDetector_1.PlatformDetector.getPlatform();
+    const isRoot = await PlatformDetector_1.PlatformDetector.isRoot();
+    console.log(chalk_1.default.gray(`Platform: ${platform}`));
+    console.log(chalk_1.default.gray(`Running as ${isRoot ? 'root/administrator' : 'regular user'}\n`));
+    if (!isRoot) {
+        console.log(chalk_1.default.yellow('⚠  ' + PlatformDetector_1.PlatformDetector.getRootRequirementMessage()));
+        console.log(chalk_1.default.gray('   Some installation options require elevated privileges.\n'));
+    }
+    // Step 2: Device Selection (moved from start command)
+    const config = configManager.getConfig();
+    let deviceId = config.deviceId;
+    let devicePassword = config.devicePassword;
+    console.log(chalk_1.default.blue('📱 Device Selection'));
+    console.log(chalk_1.default.gray('Select which serving device this agent should represent:\n'));
+    try {
+        // Fetch available serving devices
+        const servingDevicesResp = await edgibleService.listServingDevices();
+        const servingDevices = servingDevicesResp?.devices || [];
+        if (servingDevices.length > 0) {
+            // Show list of devices to select from
+            const deviceChoices = servingDevices.map((d) => {
+                const isCurrentDevice = config.deviceId === d.id;
+                const displayName = `${d.name || d.id}${d.description ? ` - ${d.description}` : ''}${isCurrentDevice ? chalk_1.default.gray(' (current)') : ''}`;
+                return {
+                    name: displayName,
+                    value: d.id
+                };
+            });
+            // Add option to create new device
+            deviceChoices.push({
+                name: chalk_1.default.cyan('➕ Create new serving device'),
+                value: '__create_new__'
+            });
+            const { selectedDeviceId } = await inquirer_1.default.prompt([{
+                    type: 'list',
+                    name: 'selectedDeviceId',
+                    message: 'Select serving device:',
+                    choices: deviceChoices,
+                    default: config.deviceId || undefined
+                }]);
+            if (selectedDeviceId === '__create_new__') {
+                // Create new device
+                const deviceNameAnswer = await inquirer_1.default.prompt([{
+                        type: 'input',
+                        name: 'deviceName',
+                        message: 'Enter a name for this device:',
+                        default: `${os.hostname()}-${os.platform()}`,
+                        validate: (input) => {
+                            if (!input.trim()) {
+                                return 'Device name is required';
+                            }
+                            return true;
+                        }
+                    }]);
+                const descriptionAnswer = await inquirer_1.default.prompt([{
+                        type: 'input',
+                        name: 'description',
+                        message: 'Enter device description (optional):',
+                        default: `Serving device: ${deviceNameAnswer.deviceName}`
+                    }]);
+                console.log(chalk_1.default.gray('\nCreating device...'));
+                const createResponse = await edgibleService.createServingDevice({
+                    name: deviceNameAnswer.deviceName.trim(),
+                    description: descriptionAnswer.description.trim()
+                });
+                deviceId = createResponse.device.id;
+                devicePassword = createResponse.device.password;
+                console.log(chalk_1.default.green(`✓ Device created: ${deviceId}`));
+                console.log(chalk_1.default.yellow(`\n⚠  Device Password: ${devicePassword}`));
+                console.log(chalk_1.default.yellow('⚠  Please save this password securely!\n'));
+                // Verify device credentials
+                if (devicePassword && deviceId) {
+                    console.log(chalk_1.default.gray('Verifying device credentials...'));
+                    try {
+                        const isValid = await authService.verifyDeviceCredentials(deviceId, devicePassword);
+                        if (isValid) {
+                            console.log(chalk_1.default.green('✓ Device credentials verified\n'));
+                        }
+                    }
+                    catch (verifyError) {
+                        console.log(chalk_1.default.yellow('⚠  Could not verify device credentials\n'));
+                    }
+                }
+                // Save device credentials to config
+                configManager.updateConfig({
+                    deviceId: deviceId,
+                    deviceName: deviceNameAnswer.deviceName.trim(),
+                    devicePassword: devicePassword,
+                    deviceType: 'serving'
+                });
+            }
+            else {
+                // Use existing device - need to fetch full details to get password
+                deviceId = selectedDeviceId;
+                if (!deviceId) {
+                    throw new Error('No device selected');
+                }
+                console.log(chalk_1.default.gray('Retrieving device credentials...\n'));
+                // Fetch device details to get the plaintext password
+                const deviceResponse = await edgibleService.getDevice(deviceId);
+                devicePassword = deviceResponse.device?.password || '';
+                if (!devicePassword) {
+                    throw new Error('Could not retrieve device password from API');
+                }
+                // Save device credentials to config
+                configManager.updateConfig({
+                    deviceId,
+                    devicePassword,
+                    deviceType: 'serving'
+                });
+                console.log(chalk_1.default.green(`✓ Using device: ${deviceId}\n`));
+            }
+        }
+        else {
+            // No devices exist, must create one
+            console.log(chalk_1.default.yellow('No serving devices found. Creating a new one...\n'));
+            const deviceNameAnswer = await inquirer_1.default.prompt([{
+                    type: 'input',
+                    name: 'deviceName',
+                    message: 'Enter a name for this device:',
+                    default: `${os.hostname()}-${os.platform()}`,
+                    validate: (input) => input.trim().length > 0 || 'Device name is required'
+                }]);
+            const createResponse = await edgibleService.createServingDevice({
+                name: deviceNameAnswer.deviceName.trim(),
+                description: `Serving device: ${deviceNameAnswer.deviceName}`
+            });
+            deviceId = createResponse.device.id;
+            devicePassword = createResponse.device.password;
+            console.log(chalk_1.default.green(`✓ Device created: ${deviceId}`));
+            console.log(chalk_1.default.yellow(`\n⚠  Device Password: ${devicePassword}`));
+            console.log(chalk_1.default.yellow('⚠  Please save this password securely!\n'));
+            configManager.updateConfig({
+                deviceId,
+                deviceName: deviceNameAnswer.deviceName.trim(),
+                devicePassword,
+                deviceType: 'serving'
+            });
+        }
+    }
+    catch (error) {
+        logger.error('Error during device selection', error);
+        const errorMessage = error instanceof Error ? error.message : 'An unexpected error occurred';
+        console.error(chalk_1.default.red('Error during device selection:'), errorMessage);
+        throw error;
+    }
+    // Verify we have device credentials
+    if (!deviceId || !devicePassword) {
+        throw new Error('Device credentials are required');
+    }
+    // Step 3: Installation Method Selection
+    console.log(chalk_1.default.blue('🔧 Installation Method'));
+    console.log(chalk_1.default.gray('Choose how to run the agent:\n'));
+    const availableOptions = await PlatformDetector_1.PlatformDetector.getAvailableOptions();
+    if (availableOptions.length === 0) {
+        console.error(chalk_1.default.red('✗ No installation methods available on this system'));
+        console.error(chalk_1.default.yellow('\nThe agent requires native daemon support:'));
+        console.error(chalk_1.default.yellow('  - Linux: systemd (requires root/sudo)'));
+        console.error(chalk_1.default.yellow('  - macOS: launchd (requires root/sudo)'));
+        console.error(chalk_1.default.yellow('  - Windows: Windows Service (requires Administrator)'));
+        console.error(chalk_1.default.yellow('\nPlease ensure you have the appropriate privileges and daemon support.'));
+        return;
+    }
+    let selectedType;
+    if (options.type) {
+        // Type specified via flag - validate it's a supported daemon type
+        const supportedTypes = ['systemd', 'launchd', 'windows-service'];
+        if (!supportedTypes.includes(options.type)) {
+            console.error(chalk_1.default.red(`✗ Installation type '${options.type}' is not supported`));
+            console.error(chalk_1.default.yellow(`  Only daemon installations are supported: ${supportedTypes.join(', ')}`));
+            console.error(chalk_1.default.yellow(`  Docker and Podman installations are no longer available`));
+            return;
+        }
+        selectedType = options.type;
+        const option = availableOptions.find(opt => opt.type === selectedType);
+        if (!option) {
+            console.error(chalk_1.default.red(`✗ Installation type '${selectedType}' not available on this platform`));
+            console.error(chalk_1.default.yellow(`  This installation type is not supported on ${platform}`));
+            return;
+        }
+        if (!option.available) {
+            console.error(chalk_1.default.red(`✗ Installation type '${selectedType}' is not available on this system`));
+            console.error(chalk_1.default.yellow(`  Requirements: ${option.requires.join(', ')}`));
+            return;
+        }
+    }
+    else {
+        // Interactive selection
+        const choices = availableOptions.map(opt => {
+            const status = opt.available ? chalk_1.default.green('✓') : chalk_1.default.red('✗');
+            const rootBadge = opt.requiresRoot ? chalk_1.default.yellow('[requires root]') : '';
+            return {
+                name: `${status} ${opt.name} ${rootBadge}\n  ${chalk_1.default.gray(opt.description)}\n  ${chalk_1.default.gray('Pros:')} ${opt.pros.join(', ')}\n  ${chalk_1.default.gray('Best for:')} ${opt.bestFor}`,
+                value: opt.type,
+                disabled: !opt.available ? `Requires: ${opt.requires.join(', ')}` : false
+            };
+        });
+        const { installType } = await inquirer_1.default.prompt([{
+                type: 'list',
+                name: 'installType',
+                message: 'Select installation method:',
+                choices,
+                pageSize: 10
+            }]);
+        selectedType = installType;
+    }
+    console.log(chalk_1.default.green(`\n✓ Selected: ${selectedType}\n`));
+    // Validate --local flag is only used with native service managers
+    if (options.local && selectedType !== 'systemd' && selectedType !== 'launchd' && selectedType !== 'windows-service') {
+        console.error(chalk_1.default.red('✗ --local flag is only supported with native daemon installations'));
+        console.error(chalk_1.default.yellow('  Supported with: systemd, launchd, windows-service'));
+        return;
+    }
+    // Step 4: Check and Install Dependencies
+    // All supported installation types are native daemons, so always check dependencies
+    {
+        console.log(chalk_1.default.blue('🔍 Checking System Dependencies'));
+        console.log(chalk_1.default.gray('Verifying required tools are installed...\n'));
+        const dependencyInstaller = new DependencyInstaller_1.DependencyInstaller();
+        try {
+            await dependencyInstaller.checkAndInstallDependencies({
+                includeWireGuardGo: false, // Use kernel WireGuard by default
+                includeIptables: platform === 'linux', // Only check iptables on Linux
+                autoInstall: false // Prompt user for installation
+            });
+            console.log(chalk_1.default.green('✓ Dependencies verified\n'));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('✗ Dependency check failed'));
+            console.error(chalk_1.default.red(`  ${error instanceof Error ? error.message : String(error)}`));
+            console.log(chalk_1.default.yellow('\n⚠  Some dependencies are missing. The agent may not function correctly.'));
+            console.log(chalk_1.default.yellow('   You can install them manually or run: edgible agent setup --auto-install\n'));
+            // Ask if user wants to continue anyway
+            const { continueAnyway } = await inquirer_1.default.prompt([{
+                    type: 'confirm',
+                    name: 'continueAnyway',
+                    message: 'Continue with installation anyway?',
+                    default: false
+                }]);
+            if (!continueAnyway) {
+                console.log(chalk_1.default.gray('Installation cancelled.'));
+                return;
+            }
+        }
+    }
+    // Step 5: Install Agent Files
+    let agentPath;
+    // All supported types are native daemons, so use system path
+    const useSystemPath = true;
+    const configPath = PathResolver_1.PathResolver.getAgentConfigPath(useSystemPath);
+    // For native daemon installations, download/install agent files
+    console.log(chalk_1.default.blue('📦 Installing Agent Files'));
+    const installResult = await agentManager.installLocalAgent({
+        installationType: selectedType,
+        installFromLocal: options.local,
+        autoStart: false
+    });
+    if (!installResult.success) {
+        console.error(chalk_1.default.red('✗ Failed to install agent files'));
+        console.error(chalk_1.default.red(`  ${installResult.error}`));
+        return;
+    }
+    agentPath = installResult.path || configPath;
+    console.log(chalk_1.default.green('✓ Agent files installed\n'));
+    // Step 6: Configure Daemon
+    console.log(chalk_1.default.blue('⚙️  Configuring Daemon'));
+    // Create agent config at the correct path for this installation type
+    await agentManager.updateAgentConfig(configPath);
+    const daemonConfig = {
+        deviceId,
+        devicePassword,
+        deviceType: 'serving',
+        apiBaseUrl: (0, urls_1.getApiBaseUrl)(),
+        organizationId: config.organizationId,
+        configPath,
+        agentPath
+    };
+    const daemonManager = DaemonManagerFactory_1.DaemonManagerFactory.create(selectedType);
+    try {
+        await daemonManager.install(daemonConfig);
+        console.log(chalk_1.default.green('✓ Daemon configured\n'));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('✗ Failed to configure daemon'));
+        console.error(chalk_1.default.red(`  ${error instanceof Error ? error.message : String(error)}`));
+        return;
+    }
+    // Save installation type to config
+    configManager.updateConfig({
+        agentInstallationType: selectedType,
+        agentServiceName: 'edgible-agent',
+        agentContainerName: undefined, // No container installations supported
+        agentDataPath: configPath
+    });
+    // Step 7: Enable and Start
+    console.log(chalk_1.default.blue('🚀 Starting Agent'));
+    try {
+        await daemonManager.enable();
+        console.log(chalk_1.default.green('✓ Enabled for startup\n'));
+    }
+    catch (error) {
+        console.warn(chalk_1.default.yellow(`⚠  Could not enable auto-start: ${error instanceof Error ? error.message : String(error)}`));
+    }
+    try {
+        await daemonManager.start();
+        console.log(chalk_1.default.green('✓ Agent started\n'));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('✗ Failed to start agent'));
+        console.error(chalk_1.default.red(`  ${error instanceof Error ? error.message : String(error)}`));
+        return;
+    }
+    // Wait a moment for agent to initialize
+    await new Promise(resolve => setTimeout(resolve, 3000));
+    // Show status
+    console.log(chalk_1.default.blue('📊 Agent Status'));
+    try {
+        const status = await daemonManager.status();
+        console.log(`  Running: ${status.running ? chalk_1.default.green('Yes') : chalk_1.default.red('No')}`);
+        console.log(`  Enabled: ${status.enabled ? chalk_1.default.green('Yes') : chalk_1.default.gray('No')}`);
+        if (status.pid) {
+            console.log(`  PID: ${status.pid}`);
+        }
+    }
+    catch (error) {
+        console.warn(chalk_1.default.yellow('  Could not fetch status'));
+    }
+    console.log(chalk_1.default.blue.bold('\n═══════════════════════════════════════════'));
+    console.log(chalk_1.default.green.bold('  ✓ Installation Complete!'));
+    console.log(chalk_1.default.blue.bold('═══════════════════════════════════════════\n'));
+    console.log(chalk_1.default.gray('Next steps:'));
+    console.log(chalk_1.default.gray(`  • View status: ${chalk_1.default.white('edgible agent status')}`));
+    console.log(chalk_1.default.gray(`  • View logs: ${chalk_1.default.white('edgible agent logs --follow')}`));
+    console.log(chalk_1.default.gray(`  • Stop agent: ${chalk_1.default.white('edgible agent stop')}`));
+    console.log(chalk_1.default.gray(`  • Restart agent: ${chalk_1.default.white('edgible agent restart')}\n`));
+}
+//# sourceMappingURL=install.js.map

package/dist/commands/agent/logs.d.ts

@@ -0,0 +1,12 @@
+import { ConfigManager } from '../../state/config';
+export declare function handleAgentLogs(options: {
+    follow?: boolean;
+    lines?: string;
+    level?: string;
+    module?: string;
+    comprehensive?: boolean;
+    singleLine?: boolean;
+    stdout?: boolean;
+    stderr?: boolean;
+}, configManager: ConfigManager): Promise<void>;
+//# sourceMappingURL=logs.d.ts.map

package/dist/commands/agent/logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logs.d.ts","sourceRoot":"","sources":["../../../src/commands/agent/logs.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAInD,wBAAsB,eAAe,CACnC,OAAO,EAAE;IACP,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,EACD,aAAa,EAAE,aAAa,GAC3B,OAAO,CAAC,IAAI,CAAC,CAqEf"}

package/dist/commands/agent/logs.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAgentLogs = handleAgentLogs;
+const chalk_1 = __importDefault(require("chalk"));
+const DaemonManagerFactory_1 = require("../../services/daemon/DaemonManagerFactory");
+const log_formatter_1 = require("../../utils/log-formatter");
+async function handleAgentLogs(options, configManager) {
+    const config = configManager.getConfig();
+    if (!config.agentInstallationType) {
+        console.log(chalk_1.default.yellow('⚠  Agent installation type not found in config'));
+        console.log(chalk_1.default.gray('  Run "edgible agent install" to install the agent\n'));
+        return;
+    }
+    const daemonManager = DaemonManagerFactory_1.DaemonManagerFactory.fromConfig(config.agentInstallationType);
+    if (!daemonManager) {
+        console.error(chalk_1.default.red('✗ Could not create daemon manager'));
+        return;
+    }
+    const lines = options.lines ? parseInt(options.lines, 10) : 100;
+    const follow = options.follow || false;
+    const level = options.level || 'all';
+    const module = options.module;
+    const comprehensive = options.comprehensive || false;
+    const singleLine = options.singleLine || false;
+    try {
+        const rawLogs = await daemonManager.logs(follow, lines, {
+            stdout: options.stdout,
+            stderr: options.stderr
+        });
+        // For follow mode, logs are streamed directly and rawLogs will be empty
+        if (follow) {
+            return;
+        }
+        // For comprehensive mode, just output raw logs
+        if (comprehensive) {
+            console.log(rawLogs);
+        }
+        else {
+            // Parse and format JSON logs (works for both systemd and launchd)
+            // Both output JSON in production mode, launchd just writes pure JSON lines
+            const formattedLogs = (0, log_formatter_1.processLogs)(rawLogs, {
+                module: module,
+                level: level,
+                singleLine: singleLine
+            });
+            if (formattedLogs.trim()) {
+                console.log(formattedLogs);
+            }
+            else {
+                // No formatted logs found - could be no matches or non-JSON logs
+                if (module || (level && level !== 'all')) {
+                    // Filters were applied but no matches
+                    if (module) {
+                        console.log(chalk_1.default.yellow(`No logs found for module(s): ${module}`));
+                    }
+                    else {
+                        console.log(chalk_1.default.yellow(`No logs found for level: ${level}`));
+                    }
+                }
+                else {
+                    // No filters, but no JSON logs found - might be plain text logs
+                    // Output raw logs as fallback
+                    console.log(rawLogs);
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('✗ Failed to read logs'));
+        console.error(chalk_1.default.red(`  ${error instanceof Error ? error.message : String(error)}\n`));
+        throw error;
+    }
+}
+//# sourceMappingURL=logs.js.map

package/dist/commands/agent/restart.d.ts

@@ -0,0 +1,4 @@
+import { Logger } from '../../utils/logger';
+import { ConfigManager } from '../../state/config';
+export declare function handleAgentRestart(logger: Logger, configManager: ConfigManager): Promise<void>;
+//# sourceMappingURL=restart.d.ts.map

package/dist/commands/agent/restart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restart.d.ts","sourceRoot":"","sources":["../../../src/commands/agent/restart.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGnD,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,aAAa,GAC3B,OAAO,CAAC,IAAI,CAAC,CA2Bf"}

package/dist/commands/agent/restart.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAgentRestart = handleAgentRestart;
+const chalk_1 = __importDefault(require("chalk"));
+const DaemonManagerFactory_1 = require("../../services/daemon/DaemonManagerFactory");
+async function handleAgentRestart(logger, configManager) {
+    const config = configManager.getConfig();
+    if (!config.agentInstallationType) {
+        console.log(chalk_1.default.yellow('⚠  Agent installation type not found in config'));
+        console.log(chalk_1.default.gray('  Run "edgible agent install" to install the agent\n'));
+        return;
+    }
+    logger.info('Restarting local agent');
+    console.log(chalk_1.default.blue('Restarting agent...\n'));
+    const daemonManager = DaemonManagerFactory_1.DaemonManagerFactory.fromConfig(config.agentInstallationType);
+    if (!daemonManager) {
+        console.error(chalk_1.default.red('✗ Could not create daemon manager'));
+        return;
+    }
+    try {
+        await daemonManager.restart();
+        console.log(chalk_1.default.green('✓ Agent restarted successfully\n'));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('✗ Failed to restart agent'));
+        console.error(chalk_1.default.red(`  ${error instanceof Error ? error.message : String(error)}\n`));
+        throw error;
+    }
+}
+//# sourceMappingURL=restart.js.map

package/dist/commands/agent/set-log-level.d.ts

@@ -0,0 +1,8 @@
+import { Logger } from '../../utils/logger';
+import { ConfigManager } from '../../state/config';
+import { LocalAgentManager } from '../../services/LocalAgentManager';
+export declare function handleAgentSetLogLevel(options: {
+    level?: string;
+    restart?: boolean;
+}, logger: Logger, configManager: ConfigManager, agentManager: LocalAgentManager): Promise<void>;
+//# sourceMappingURL=set-log-level.d.ts.map

package/dist/commands/agent/set-log-level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-log-level.d.ts","sourceRoot":"","sources":["../../../src/commands/agent/set-log-level.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAIrE,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,EAC9C,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,iBAAiB,GAC9B,OAAO,CAAC,IAAI,CAAC,CA6Ff"}