@edgible-team/cli 1.0.1

package/dist/services/daemon/DaemonManagerFactory.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DaemonManagerFactory = void 0;
+const SystemdDaemonManager_1 = require("./SystemdDaemonManager");
+const LaunchdDaemonManager_1 = require("./LaunchdDaemonManager");
+const WindowsServiceDaemonManager_1 = require("./WindowsServiceDaemonManager");
+const DockerDaemonManager_1 = require("./DockerDaemonManager");
+const PodmanDaemonManager_1 = require("./PodmanDaemonManager");
+const PlatformDetector_1 = require("../../utils/PlatformDetector");
+class DaemonManagerFactory {
+    /**
+     * Create a daemon manager instance based on the type
+     */
+    static create(type) {
+        const platform = PlatformDetector_1.PlatformDetector.getPlatform();
+        switch (type) {
+            case 'systemd':
+                if (platform !== 'linux') {
+                    throw new Error('systemd is only available on Linux');
+                }
+                return new SystemdDaemonManager_1.SystemdDaemonManager();
+            case 'launchd':
+                if (platform !== 'darwin') {
+                    throw new Error('launchd is only available on macOS');
+                }
+                return new LaunchdDaemonManager_1.LaunchdDaemonManager();
+            case 'windows-service':
+                if (platform !== 'win32') {
+                    throw new Error('Windows Service is only available on Windows');
+                }
+                return new WindowsServiceDaemonManager_1.WindowsServiceDaemonManager();
+            case 'docker':
+                return new DockerDaemonManager_1.DockerDaemonManager();
+            case 'podman':
+                return new PodmanDaemonManager_1.PodmanDaemonManager();
+            default:
+                throw new Error(`Unknown daemon type: ${type}`);
+        }
+    }
+    /**
+     * Get daemon manager from stored config type
+     */
+    static fromConfig(installationType) {
+        if (!installationType) {
+            return null;
+        }
+        const validTypes = ['systemd', 'launchd', 'windows-service', 'docker', 'podman'];
+        if (!validTypes.includes(installationType)) {
+            throw new Error(`Invalid installation type in config: ${installationType}`);
+        }
+        return this.create(installationType);
+    }
+    /**
+     * Get the recommended daemon manager for the current platform
+     */
+    static async getRecommended() {
+        const recommendedType = await PlatformDetector_1.PlatformDetector.getRecommendedType();
+        if (!recommendedType) {
+            return null;
+        }
+        return this.create(recommendedType);
+    }
+}
+exports.DaemonManagerFactory = DaemonManagerFactory;
+//# sourceMappingURL=DaemonManagerFactory.js.map

package/dist/services/daemon/DockerDaemonManager.js

@@ -0,0 +1,395 @@
+"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.DockerDaemonManager = 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 PathResolver_1 = require("../../utils/PathResolver");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class DockerDaemonManager {
+    constructor() {
+        this.containerName = 'edgible-agent';
+        this.imageName = 'edgible-agent:latest';
+        this.platform = PlatformDetector_1.PlatformDetector.getPlatform();
+    }
+    async install(config) {
+        // Check if image exists locally
+        const imageExists = await this.checkImageExists();
+        if (!imageExists) {
+            throw new Error(`Docker image '${this.imageName}' not found. Please build or pull the image first.\n` +
+                `  To build: cd agent-v2 && docker build -t ${this.imageName} .\n` +
+                `  Or pull from registry if available.`);
+        }
+        // Create Docker container with proper mounts and capabilities
+        const dockerRunCommand = this.generateDockerRunCommand(config);
+        try {
+            // Remove existing container if it exists
+            try {
+                await execAsync(`docker rm -f ${this.containerName}`);
+            }
+            catch {
+                // Container doesn't exist, that's fine
+            }
+            // Create container
+            await execAsync(dockerRunCommand);
+            console.log('Docker container created successfully');
+            // Create systemd/launchd service wrapper for auto-start on boot
+            await this.createServiceWrapper(config);
+        }
+        catch (error) {
+            throw new Error(`Failed to create Docker container: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async start() {
+        try {
+            await execAsync(`docker start ${this.containerName}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to start container: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async stop() {
+        try {
+            await execAsync(`docker stop ${this.containerName}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to stop container: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async restart() {
+        try {
+            await execAsync(`docker restart ${this.containerName}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to restart container: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async status() {
+        try {
+            const { stdout } = await execAsync(`docker ps -a --filter name=${this.containerName} --format "{{.Status}}|||{{.ID}}"`);
+            if (!stdout.trim()) {
+                return {
+                    running: false,
+                    enabled: false,
+                    message: 'Container not found'
+                };
+            }
+            const [status, containerId] = stdout.trim().split('|||');
+            const isRunning = status.toLowerCase().includes('up');
+            // Get more detailed info if running
+            if (isRunning) {
+                const { stdout: inspectOut } = await execAsync(`docker inspect ${containerId} --format "{{.State.Pid}}"`);
+                const pid = parseInt(inspectOut.trim(), 10);
+                return {
+                    running: true,
+                    enabled: true,
+                    pid: pid || undefined,
+                    message: status
+                };
+            }
+            return {
+                running: false,
+                enabled: true,
+                message: status
+            };
+        }
+        catch (error) {
+            return {
+                running: false,
+                enabled: false,
+                message: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    async logs(follow, lines = 100) {
+        const followFlag = follow ? '-f' : '';
+        if (follow) {
+            const { spawn } = require('child_process');
+            const proc = spawn('docker', ['logs', this.containerName, '--tail', String(lines), '-f'], {
+                stdio: 'inherit'
+            });
+            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(`docker logs ${this.containerName} --tail ${lines}`);
+                return stdout;
+            }
+            catch (error) {
+                throw new Error(`Failed to read logs: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    async enable() {
+        // Container is created with --restart unless-stopped, so it's automatically enabled
+        // But we also need to enable the systemd/launchd wrapper service
+        if (this.platform === 'linux') {
+            try {
+                await execAsync('systemctl enable edgible-agent-docker');
+            }
+            catch (error) {
+                // Service wrapper might not exist yet
+            }
+        }
+        else if (this.platform === 'darwin') {
+            try {
+                await execAsync('launchctl load /Library/LaunchDaemons/com.edgible.agent.docker.plist');
+            }
+            catch (error) {
+                // Service wrapper might not exist yet
+            }
+        }
+        // Windows doesn't need explicit enable as Docker Desktop handles startup
+    }
+    async disable() {
+        if (this.platform === 'linux') {
+            try {
+                await execAsync('systemctl disable edgible-agent-docker');
+            }
+            catch (error) {
+                // Ignore errors
+            }
+        }
+        else if (this.platform === 'darwin') {
+            try {
+                await execAsync('launchctl unload /Library/LaunchDaemons/com.edgible.agent.docker.plist');
+            }
+            catch (error) {
+                // Ignore errors
+            }
+        }
+    }
+    async uninstall() {
+        // Stop and remove container
+        try {
+            await this.stop();
+        }
+        catch {
+            // Ignore if already stopped
+        }
+        try {
+            await execAsync(`docker rm ${this.containerName}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to remove container: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Remove service wrapper
+        await this.removeServiceWrapper();
+    }
+    getPlatform() {
+        return this.platform;
+    }
+    getType() {
+        return 'docker';
+    }
+    async checkImageExists() {
+        try {
+            await execAsync(`docker image inspect ${this.imageName}`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async buildImage(agentPath) {
+        // Look for Dockerfile in agent-v2 directory
+        const dockerfilePath = path.join(path.dirname(path.dirname(path.dirname(agentPath))), 'agent-v2', 'Dockerfile');
+        const buildContext = path.dirname(dockerfilePath);
+        try {
+            console.log(`Building Docker image from ${buildContext}...`);
+            const { stdout, stderr } = await execAsync(`docker build -t ${this.imageName} -f ${dockerfilePath} ${buildContext}`, { maxBuffer: 10 * 1024 * 1024 } // 10MB buffer for build output
+            );
+            if (stdout)
+                console.log(stdout);
+            if (stderr)
+                console.error(stderr);
+            console.log('Docker image built successfully');
+        }
+        catch (error) {
+            throw new Error(`Failed to build Docker image: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    generateDockerRunCommand(config) {
+        const configPath = config.configPath;
+        const applicationsPath = path.join(configPath, 'applications');
+        const logsPath = path.join(configPath, 'logs');
+        // Ensure all required directories exist with proper permissions
+        try {
+            require('fs').mkdirSync(applicationsPath, { recursive: true, mode: 0o755 });
+            require('fs').mkdirSync(logsPath, { recursive: true, mode: 0o755 });
+            // Ensure parent directory also has proper permissions
+            require('fs').chmodSync(configPath, 0o755);
+            require('fs').chmodSync(applicationsPath, 0o755);
+            require('fs').chmodSync(logsPath, 0o755);
+        }
+        catch (error) {
+            console.warn('Could not set directory permissions:', error);
+            // Continue anyway - entrypoint will try to fix permissions
+        }
+        // Docker socket path varies by platform
+        let dockerSocketMount = '';
+        if (this.platform === 'linux') {
+            dockerSocketMount = '-v /var/run/docker.sock:/var/run/docker.sock';
+        }
+        else if (this.platform === 'darwin') {
+            dockerSocketMount = '-v /var/run/docker.sock:/var/run/docker.sock';
+        }
+        else if (this.platform === 'win32') {
+            dockerSocketMount = '-v //var/run/docker.sock:/var/run/docker.sock';
+        }
+        // Use :z flag for SELinux systems to allow container access
+        // This is safe for non-SELinux systems (flag is ignored)
+        // For serving devices, use bridge network to prevent exposing Caddy ports externally
+        // For gateway devices, use host network for direct network access
+        const networkMode = config.deviceType === 'serving' ? 'bridge' : 'host';
+        const networkFlag = networkMode === 'bridge' ? '--network bridge' : '--network host';
+        // For serving devices on bridge network, we don't expose ports
+        // Caddy will bind to localhost (127.0.0.1) only, so ports won't be accessible externally
+        // Use system path inside container
+        const containerConfigPath = PathResolver_1.PathResolver.getSystemDataPath() + '/agent';
+        const containerConfigFile = `${containerConfigPath}/agent.config.json`;
+        // Required capabilities:
+        // - NET_ADMIN: For WireGuard interface management, IP routing, iptables
+        // - NET_BIND_SERVICE: For Caddy to bind to privileged ports (80, 443)
+        // - SYS_MODULE: Optional, for kernel module loading (may not work in containers)
+        return `docker create \\
+      --name ${this.containerName} \\
+      ${networkFlag} \\
+      --cap-add NET_ADMIN \\
+      --cap-add NET_BIND_SERVICE \\
+      --restart unless-stopped \\
+      -v "${configPath}:${containerConfigPath}:z" \\
+      -v "${applicationsPath}:${containerConfigPath}/applications:z" \\
+      ${dockerSocketMount} \\
+      -e NODE_ENV=production \\
+      -e EDGIBLE_CONFIG_PATH="${containerConfigPath}" \\
+      -e DEVICE_TYPE=${config.deviceType} \\
+      ${this.imageName} \\
+      start --config "${containerConfigFile}"`;
+    }
+    async createServiceWrapper(config) {
+        if (this.platform === 'linux') {
+            await this.createSystemdWrapper();
+        }
+        else if (this.platform === 'darwin') {
+            await this.createLaunchdWrapper();
+        }
+        // Windows doesn't need a wrapper as Docker Desktop handles startup
+    }
+    async createSystemdWrapper() {
+        const serviceContent = `[Unit]
+Description=Edgible Agent (Docker)
+After=docker.service
+Requires=docker.service
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+ExecStart=/usr/bin/docker start ${this.containerName}
+ExecStop=/usr/bin/docker stop ${this.containerName}
+
+[Install]
+WantedBy=multi-user.target
+`;
+        try {
+            await fs.writeFile('/etc/systemd/system/edgible-agent-docker.service', serviceContent, 'utf8');
+            await execAsync('systemctl daemon-reload');
+        }
+        catch (error) {
+            console.warn('Failed to create systemd wrapper service:', error);
+        }
+    }
+    async createLaunchdWrapper() {
+        const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.edgible.agent.docker</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>/usr/local/bin/docker</string>
+        <string>start</string>
+        <string>${this.containerName}</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <dict>
+        <key>SuccessfulExit</key>
+        <false/>
+    </dict>
+</dict>
+</plist>
+`;
+        try {
+            await fs.writeFile('/Library/LaunchDaemons/com.edgible.agent.docker.plist', plistContent, 'utf8');
+        }
+        catch (error) {
+            console.warn('Failed to create launchd wrapper:', error);
+        }
+    }
+    async removeServiceWrapper() {
+        if (this.platform === 'linux') {
+            try {
+                await execAsync('systemctl disable edgible-agent-docker');
+                await fs.unlink('/etc/systemd/system/edgible-agent-docker.service');
+                await execAsync('systemctl daemon-reload');
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        else if (this.platform === 'darwin') {
+            try {
+                await execAsync('launchctl unload /Library/LaunchDaemons/com.edgible.agent.docker.plist');
+                await fs.unlink('/Library/LaunchDaemons/com.edgible.agent.docker.plist');
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+    }
+}
+exports.DockerDaemonManager = DockerDaemonManager;
+//# sourceMappingURL=DockerDaemonManager.js.map