@edgible-team/cli 1.0.1

package/dist/services/daemon/SystemdDaemonManager.js

@@ -0,0 +1,221 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemdDaemonManager = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const fs = __importStar(require("fs/promises"));
+const PlatformDetector_1 = require("../../utils/PlatformDetector");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class SystemdDaemonManager {
+    constructor() {
+        this.serviceName = 'edgible-agent';
+        this.serviceFilePath = `/etc/systemd/system/${this.serviceName}.service`;
+        if (PlatformDetector_1.PlatformDetector.getPlatform() !== 'linux') {
+            throw new Error('SystemdDaemonManager is only supported on Linux');
+        }
+    }
+    async install(config) {
+        // Generate systemd service file
+        const serviceContent = this.generateServiceFile(config);
+        // Write service file (requires root)
+        try {
+            await fs.writeFile(this.serviceFilePath, serviceContent, 'utf8');
+        }
+        catch (error) {
+            throw new Error(`Failed to write systemd service file: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Reload systemd daemon
+        try {
+            await execAsync('systemctl daemon-reload');
+        }
+        catch (error) {
+            throw new Error(`Failed to reload systemd: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async start() {
+        try {
+            await execAsync(`systemctl start ${this.serviceName}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to start service: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async stop() {
+        try {
+            await execAsync(`systemctl stop ${this.serviceName}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to stop service: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async restart() {
+        try {
+            await execAsync(`systemctl restart ${this.serviceName}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to restart service: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async status() {
+        try {
+            const { stdout } = await execAsync(`systemctl status ${this.serviceName}`);
+            const isActive = stdout.includes('Active: active');
+            const isEnabled = await this.isEnabled();
+            // Extract PID if available
+            const pidMatch = stdout.match(/Main PID: (\d+)/);
+            const pid = pidMatch ? parseInt(pidMatch[1], 10) : undefined;
+            return {
+                running: isActive,
+                enabled: isEnabled,
+                pid,
+                message: stdout
+            };
+        }
+        catch (error) {
+            // Service might not exist or be stopped
+            return {
+                running: false,
+                enabled: false,
+                message: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    async logs(follow, lines = 100) {
+        const followFlag = follow ? '-f' : '';
+        const command = `journalctl -u ${this.serviceName} -n ${lines} ${followFlag}`;
+        if (follow) {
+            // For follow mode, spawn the process and pipe to stdout
+            const { spawn } = require('child_process');
+            const proc = spawn('journalctl', ['-u', this.serviceName, '-n', String(lines), '-f'], {
+                stdio: 'inherit'
+            });
+            // Handle process termination
+            process.on('SIGINT', () => {
+                proc.kill('SIGTERM');
+                process.exit(0);
+            });
+            // Return empty string for follow mode as logs are streamed to stdout
+            return '';
+        }
+        else {
+            try {
+                const { stdout } = await execAsync(command);
+                return stdout;
+            }
+            catch (error) {
+                throw new Error(`Failed to read logs: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    async enable() {
+        try {
+            await execAsync(`systemctl enable ${this.serviceName}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to enable service: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async disable() {
+        try {
+            await execAsync(`systemctl disable ${this.serviceName}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to disable service: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async uninstall() {
+        // Stop and disable service first
+        try {
+            await this.stop();
+        }
+        catch {
+            // Ignore if already stopped
+        }
+        try {
+            await this.disable();
+        }
+        catch {
+            // Ignore if not enabled
+        }
+        // Remove service file
+        try {
+            await fs.unlink(this.serviceFilePath);
+            await execAsync('systemctl daemon-reload');
+        }
+        catch (error) {
+            throw new Error(`Failed to remove service file: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    getPlatform() {
+        return 'linux';
+    }
+    getType() {
+        return 'systemd';
+    }
+    async isEnabled() {
+        try {
+            const { stdout } = await execAsync(`systemctl is-enabled ${this.serviceName}`);
+            return stdout.trim() === 'enabled';
+        }
+        catch {
+            return false;
+        }
+    }
+    generateServiceFile(config) {
+        const nodePath = process.execPath; // Path to current Node.js executable
+        return `[Unit]
+Description=Edgible Agent
+After=network.target
+
+[Service]
+Type=simple
+User=root
+WorkingDirectory=${config.agentPath}
+ExecStart=${nodePath} ${config.agentPath}/index.js start -c ${config.configPath}/agent.config.json
+Restart=always
+RestartSec=10
+Environment=NODE_ENV=production
+Environment=EDGIBLE_CONFIG_PATH=${config.configPath}
+StandardOutput=journal
+StandardError=journal
+
+[Install]
+WantedBy=multi-user.target
+`;
+    }
+}
+exports.SystemdDaemonManager = SystemdDaemonManager;
+//# sourceMappingURL=SystemdDaemonManager.js.map

package/dist/services/daemon/WindowsServiceDaemonManager.js

@@ -0,0 +1,210 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowsServiceDaemonManager = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const PlatformDetector_1 = require("../../utils/PlatformDetector");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class WindowsServiceDaemonManager {
+    constructor() {
+        this.serviceName = 'EdgibleAgent';
+        this.displayName = 'Edgible Agent';
+        this.description = 'Edgible Agent Service for device management and networking';
+        if (PlatformDetector_1.PlatformDetector.getPlatform() !== 'win32') {
+            throw new Error('WindowsServiceDaemonManager is only supported on Windows');
+        }
+    }
+    async install(config) {
+        const nodePath = process.execPath;
+        const agentScript = path.join(config.agentPath, 'index.js');
+        const configFile = path.join(config.configPath, 'agent.config.json');
+        // Create a wrapper batch file to run the service
+        const wrapperPath = path.join(config.agentPath, 'service-wrapper.bat');
+        const wrapperContent = `@echo off
+"${nodePath}" "${agentScript}" start -c "${configFile}"
+`;
+        try {
+            await fs.writeFile(wrapperPath, wrapperContent, 'utf8');
+        }
+        catch (error) {
+            throw new Error(`Failed to create service wrapper: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Create the service using sc.exe
+        try {
+            const createCommand = `sc create ${this.serviceName} ` +
+                `binPath= "\\"${wrapperPath}\\"" ` +
+                `DisplayName= "${this.displayName}" ` +
+                `start= auto`;
+            await execAsync(createCommand);
+            // Set service description
+            await execAsync(`sc description ${this.serviceName} "${this.description}"`);
+            // Set service to restart on failure
+            await execAsync(`sc failure ${this.serviceName} reset= 86400 actions= restart/60000/restart/60000/restart/60000`);
+        }
+        catch (error) {
+            throw new Error(`Failed to create Windows service: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async start() {
+        try {
+            await execAsync(`sc start ${this.serviceName}`);
+            // Wait a moment for service to start
+            await new Promise(resolve => setTimeout(resolve, 2000));
+        }
+        catch (error) {
+            throw new Error(`Failed to start service: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async stop() {
+        try {
+            await execAsync(`sc stop ${this.serviceName}`);
+            // Wait a moment for service to stop
+            await new Promise(resolve => setTimeout(resolve, 2000));
+        }
+        catch (error) {
+            throw new Error(`Failed to stop service: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async restart() {
+        await this.stop();
+        await this.start();
+    }
+    async status() {
+        try {
+            const { stdout } = await execAsync(`sc query ${this.serviceName}`);
+            const isRunning = stdout.includes('STATE') && stdout.includes('RUNNING');
+            const isStopped = stdout.includes('STATE') && stdout.includes('STOPPED');
+            // Extract PID if available (requires Windows 10+)
+            const pidMatch = stdout.match(/PID\s+:\s+(\d+)/);
+            const pid = pidMatch ? parseInt(pidMatch[1], 10) : undefined;
+            return {
+                running: isRunning,
+                enabled: true, // If service exists, it's enabled
+                pid,
+                message: stdout
+            };
+        }
+        catch (error) {
+            // Service might not exist
+            return {
+                running: false,
+                enabled: false,
+                message: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    async logs(follow, lines = 100) {
+        // Windows Event Log integration would be more complex
+        // For now, we'll try to read from a log file if the agent writes one
+        const logPath = path.join(process.env.EDGIBLE_CONFIG_PATH || path.join(process.env.USERPROFILE || 'C:\\', '.edgible', 'agent'), 'logs', 'agent.log');
+        try {
+            if (follow) {
+                console.log('Following logs (press Ctrl+C to stop)...');
+                // Use PowerShell Get-Content -Wait for following
+                const { spawn } = require('child_process');
+                const proc = spawn('powershell.exe', [
+                    '-Command',
+                    `Get-Content -Path "${logPath}" -Wait -Tail ${lines}`
+                ], {
+                    stdio: 'inherit'
+                });
+                process.on('SIGINT', () => {
+                    proc.kill();
+                    process.exit(0);
+                });
+                // Return empty string for follow mode as logs are streamed to stdout
+                return '';
+            }
+            else {
+                // Read last N lines using PowerShell
+                const { stdout } = await execAsync(`powershell.exe -Command "Get-Content -Path '${logPath}' -Tail ${lines}"`);
+                return stdout;
+            }
+        }
+        catch (error) {
+            // Try Windows Event Log as fallback
+            try {
+                const { stdout } = await execAsync(`powershell.exe -Command "Get-EventLog -LogName Application -Source '${this.serviceName}' -Newest ${lines} | Format-List"`);
+                return stdout;
+            }
+            catch {
+                throw new Error(`Failed to read logs: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    async enable() {
+        try {
+            await execAsync(`sc config ${this.serviceName} start= auto`);
+        }
+        catch (error) {
+            throw new Error(`Failed to enable service: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async disable() {
+        try {
+            await execAsync(`sc config ${this.serviceName} start= demand`);
+        }
+        catch (error) {
+            throw new Error(`Failed to disable service: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async uninstall() {
+        // Stop service first
+        try {
+            await this.stop();
+        }
+        catch {
+            // Ignore if already stopped
+        }
+        // Delete service
+        try {
+            await execAsync(`sc delete ${this.serviceName}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to remove service: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    getPlatform() {
+        return 'win32';
+    }
+    getType() {
+        return 'windows-service';
+    }
+}
+exports.WindowsServiceDaemonManager = WindowsServiceDaemonManager;
+//# sourceMappingURL=WindowsServiceDaemonManager.js.map

package/dist/services/daemon/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaemonManagerFactory = exports.PodmanDaemonManager = exports.DockerDaemonManager = exports.WindowsServiceDaemonManager = exports.LaunchdDaemonManager = exports.SystemdDaemonManager = void 0;
+var SystemdDaemonManager_1 = require("./SystemdDaemonManager");
+Object.defineProperty(exports, "SystemdDaemonManager", { enumerable: true, get: function () { return SystemdDaemonManager_1.SystemdDaemonManager; } });
+var LaunchdDaemonManager_1 = require("./LaunchdDaemonManager");
+Object.defineProperty(exports, "LaunchdDaemonManager", { enumerable: true, get: function () { return LaunchdDaemonManager_1.LaunchdDaemonManager; } });
+var WindowsServiceDaemonManager_1 = require("./WindowsServiceDaemonManager");
+Object.defineProperty(exports, "WindowsServiceDaemonManager", { enumerable: true, get: function () { return WindowsServiceDaemonManager_1.WindowsServiceDaemonManager; } });
+var DockerDaemonManager_1 = require("./DockerDaemonManager");
+Object.defineProperty(exports, "DockerDaemonManager", { enumerable: true, get: function () { return DockerDaemonManager_1.DockerDaemonManager; } });
+var PodmanDaemonManager_1 = require("./PodmanDaemonManager");
+Object.defineProperty(exports, "PodmanDaemonManager", { enumerable: true, get: function () { return PodmanDaemonManager_1.PodmanDaemonManager; } });
+var DaemonManagerFactory_1 = require("./DaemonManagerFactory");
+Object.defineProperty(exports, "DaemonManagerFactory", { enumerable: true, get: function () { return DaemonManagerFactory_1.DaemonManagerFactory; } });
+//# sourceMappingURL=index.js.map