@edgible-team/cli 1.0.1

package/dist/services/daemon/LaunchdDaemonManager.js

@@ -0,0 +1,257 @@
+"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.LaunchdDaemonManager = 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 LaunchdDaemonManager {
+    constructor() {
+        this.serviceName = 'com.edgible.agent';
+        if (PlatformDetector_1.PlatformDetector.getPlatform() !== 'darwin') {
+            throw new Error('LaunchdDaemonManager is only supported on macOS');
+        }
+        // Use LaunchDaemons for system-wide (root) installation
+        this.plistPath = `/Library/LaunchDaemons/${this.serviceName}.plist`;
+        this.logPath = '/var/log/edgible-agent';
+    }
+    async install(config) {
+        // Create log directory
+        try {
+            await execAsync(`mkdir -p ${this.logPath}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to create log directory: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Generate plist file
+        const plistContent = this.generatePlistFile(config);
+        // Write plist file (requires root)
+        try {
+            await fs.writeFile(this.plistPath, plistContent, 'utf8');
+            await execAsync(`chmod 644 ${this.plistPath}`);
+            await execAsync(`chown root:wheel ${this.plistPath}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to write launchd plist file: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async start() {
+        try {
+            await execAsync(`launchctl load ${this.plistPath}`);
+            await execAsync(`launchctl start ${this.serviceName}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to start service: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async stop() {
+        try {
+            await execAsync(`launchctl stop ${this.serviceName}`);
+            await execAsync(`launchctl unload ${this.plistPath}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to stop service: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async restart() {
+        await this.stop();
+        // Wait a moment before restarting
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        await this.start();
+    }
+    async status() {
+        try {
+            const { stdout } = await execAsync(`launchctl list | grep ${this.serviceName}`);
+            const parts = stdout.trim().split(/\s+/);
+            if (parts.length >= 3) {
+                const pidStr = parts[0];
+                const running = pidStr !== '-';
+                const pid = running ? parseInt(pidStr, 10) : undefined;
+                return {
+                    running,
+                    enabled: true, // If it's listed, it's loaded
+                    pid,
+                    message: stdout
+                };
+            }
+            return {
+                running: false,
+                enabled: false,
+                message: 'Service not loaded'
+            };
+        }
+        catch (error) {
+            // Service might not be loaded
+            return {
+                running: false,
+                enabled: false,
+                message: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    async logs(follow, lines = 100) {
+        const stdoutLog = path.join(this.logPath, 'stdout.log');
+        const stderrLog = path.join(this.logPath, 'stderr.log');
+        if (follow) {
+            // Use tail -f for following logs
+            const { spawn } = require('child_process');
+            console.log('==> stdout.log <==');
+            const stdoutProc = spawn('tail', ['-f', '-n', String(lines), stdoutLog], {
+                stdio: 'inherit'
+            });
+            console.log('\n==> stderr.log <==');
+            const stderrProc = spawn('tail', ['-f', '-n', String(lines), stderrLog], {
+                stdio: 'inherit'
+            });
+            // Handle process termination
+            process.on('SIGINT', () => {
+                stdoutProc.kill('SIGTERM');
+                stderrProc.kill('SIGTERM');
+                process.exit(0);
+            });
+            // Return empty string for follow mode as logs are streamed to stdout
+            return '';
+        }
+        else {
+            try {
+                let combinedLogs = '';
+                try {
+                    const { stdout: stdoutContent } = await execAsync(`tail -n ${lines} ${stdoutLog}`);
+                    combinedLogs += '==> stdout.log <==\n' + stdoutContent;
+                }
+                catch (error) {
+                    // File might not exist yet
+                    combinedLogs += '==> stdout.log <==\n(no logs yet)\n';
+                }
+                try {
+                    const { stdout: stderrContent } = await execAsync(`tail -n ${lines} ${stderrLog}`);
+                    combinedLogs += '\n==> stderr.log <==\n' + stderrContent;
+                }
+                catch (error) {
+                    // File might not exist yet
+                    combinedLogs += '\n==> stderr.log <==\n(no logs yet)\n';
+                }
+                return combinedLogs;
+            }
+            catch (error) {
+                throw new Error(`Failed to read logs: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    async enable() {
+        // On launchd, loading the plist enables it
+        // It's already enabled by the install() method
+        try {
+            await execAsync(`launchctl load ${this.plistPath}`);
+        }
+        catch (error) {
+            // May already be loaded
+        }
+    }
+    async disable() {
+        try {
+            await execAsync(`launchctl unload ${this.plistPath}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to disable service: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async uninstall() {
+        // Stop and unload service first
+        try {
+            await this.stop();
+        }
+        catch {
+            // Ignore if already stopped
+        }
+        // Remove plist file
+        try {
+            await fs.unlink(this.plistPath);
+        }
+        catch (error) {
+            throw new Error(`Failed to remove plist file: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    getPlatform() {
+        return 'darwin';
+    }
+    getType() {
+        return 'launchd';
+    }
+    generatePlistFile(config) {
+        const nodePath = process.execPath; // Path to current Node.js executable
+        return `<?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>${this.serviceName}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${nodePath}</string>
+        <string>${config.agentPath}/index.js</string>
+        <string>start</string>
+        <string>-c</string>
+        <string>${config.configPath}/agent.config.json</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>${this.logPath}/stdout.log</string>
+    <key>StandardErrorPath</key>
+    <string>${this.logPath}/stderr.log</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:/usr/local/sbin:/usr/bin:/bin:/usr/sbin:/sbin</string>
+        <key>NODE_ENV</key>
+        <string>production</string>
+        <key>EDGIBLE_CONFIG_PATH</key>
+        <string>${config.configPath}</string>
+    </dict>
+    <key>WorkingDirectory</key>
+    <string>${config.agentPath}</string>
+</dict>
+</plist>
+`;
+    }
+}
+exports.LaunchdDaemonManager = LaunchdDaemonManager;
+//# sourceMappingURL=LaunchdDaemonManager.js.map

package/dist/services/daemon/PodmanDaemonManager.js

@@ -0,0 +1,369 @@
+"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.PodmanDaemonManager = 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 os = __importStar(require("os"));
+const PlatformDetector_1 = require("../../utils/PlatformDetector");
+const PathResolver_1 = require("../../utils/PathResolver");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class PodmanDaemonManager {
+    constructor() {
+        this.containerName = 'edgible-agent';
+        this.imageName = 'edgible-agent:latest';
+        this.platform = PlatformDetector_1.PlatformDetector.getPlatform();
+        this.systemdUserPath = path.join(os.homedir(), '.config', 'systemd', 'user');
+    }
+    async install(config) {
+        // Check if image exists locally
+        const imageExists = await this.checkImageExists();
+        if (!imageExists) {
+            throw new Error(`Podman image '${this.imageName}' not found. Please build or pull the image first.\n` +
+                `  To build: cd agent-v2 && podman build -t ${this.imageName} .\n` +
+                `  Or pull from registry if available.`);
+        }
+        // Create Podman container with proper mounts and capabilities
+        const podmanRunCommand = this.generatePodmanRunCommand(config);
+        try {
+            // Remove existing container if it exists
+            try {
+                await execAsync(`podman rm -f ${this.containerName}`);
+            }
+            catch {
+                // Container doesn't exist, that's fine
+            }
+            // Create container
+            await execAsync(podmanRunCommand);
+            console.log('Podman container created successfully');
+            // Create systemd user service for auto-start
+            await this.createUserService(config);
+        }
+        catch (error) {
+            throw new Error(`Failed to create Podman container: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async start() {
+        // Use systemd user service if on Linux, otherwise direct podman command
+        if (this.platform === 'linux') {
+            try {
+                await execAsync(`systemctl --user start edgible-agent-podman`);
+            }
+            catch (error) {
+                // Fallback to direct podman command
+                await execAsync(`podman start ${this.containerName}`);
+            }
+        }
+        else {
+            await execAsync(`podman start ${this.containerName}`);
+        }
+    }
+    async stop() {
+        if (this.platform === 'linux') {
+            try {
+                await execAsync(`systemctl --user stop edgible-agent-podman`);
+            }
+            catch (error) {
+                // Fallback to direct podman command
+                await execAsync(`podman stop ${this.containerName}`);
+            }
+        }
+        else {
+            await execAsync(`podman stop ${this.containerName}`);
+        }
+    }
+    async restart() {
+        if (this.platform === 'linux') {
+            try {
+                await execAsync(`systemctl --user restart edgible-agent-podman`);
+            }
+            catch (error) {
+                // Fallback to direct podman command
+                await execAsync(`podman restart ${this.containerName}`);
+            }
+        }
+        else {
+            await execAsync(`podman restart ${this.containerName}`);
+        }
+    }
+    async status() {
+        try {
+            const { stdout } = await execAsync(`podman 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) {
+                try {
+                    const { stdout: inspectOut } = await execAsync(`podman inspect ${containerId} --format "{{.State.Pid}}"`);
+                    const pid = parseInt(inspectOut.trim(), 10);
+                    return {
+                        running: true,
+                        enabled: true,
+                        pid: pid || undefined,
+                        message: status
+                    };
+                }
+                catch {
+                    return {
+                        running: true,
+                        enabled: true,
+                        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) {
+        if (follow) {
+            const { spawn } = require('child_process');
+            const proc = spawn('podman', ['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(`podman 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() {
+        if (this.platform === 'linux') {
+            try {
+                await execAsync('systemctl --user enable edgible-agent-podman');
+                // Enable lingering to allow user services to run without login
+                await execAsync('loginctl enable-linger');
+            }
+            catch (error) {
+                console.warn('Failed to enable systemd user service:', error);
+            }
+        }
+        // Other platforms don't have a built-in service manager for Podman
+    }
+    async disable() {
+        if (this.platform === 'linux') {
+            try {
+                await execAsync('systemctl --user disable edgible-agent-podman');
+            }
+            catch (error) {
+                console.warn('Failed to disable systemd user service:', error);
+            }
+        }
+    }
+    async uninstall() {
+        // Stop and remove container
+        try {
+            await this.stop();
+        }
+        catch {
+            // Ignore if already stopped
+        }
+        try {
+            await execAsync(`podman rm ${this.containerName}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to remove container: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Remove user service
+        if (this.platform === 'linux') {
+            try {
+                await this.disable();
+                await fs.unlink(path.join(this.systemdUserPath, 'edgible-agent-podman.service'));
+                await execAsync('systemctl --user daemon-reload');
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+    }
+    getPlatform() {
+        return this.platform;
+    }
+    getType() {
+        return 'podman';
+    }
+    async checkImageExists() {
+        try {
+            await execAsync(`podman 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 Podman image from ${buildContext}...`);
+            const { stdout, stderr } = await execAsync(`podman 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('Podman image built successfully');
+        }
+        catch (error) {
+            throw new Error(`Failed to build Podman image: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    generatePodmanRunCommand(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
+        }
+        // Try to mount Docker socket from host (for Podman containers that need Docker)
+        // First check standard Docker socket location
+        let dockerSocketMount = '';
+        const dockerSocketPath = '/var/run/docker.sock';
+        if (require('fs').existsSync(dockerSocketPath)) {
+            dockerSocketMount = `-v "${dockerSocketPath}:${dockerSocketPath}"`;
+        }
+        // Podman socket path (for rootless mode) - optional
+        const podmanSocketPath = path.join(os.homedir(), '.local', 'share', 'containers', 'podman', 'machine');
+        let podmanSocketMount = '';
+        // Check if we need to mount the Podman socket
+        if (require('fs').existsSync(podmanSocketPath)) {
+            podmanSocketMount = `-v "${podmanSocketPath}:${podmanSocketPath}"`;
+        }
+        // For rootless Podman:
+        // - :z flag relabels SELinux context for shared container access
+        // - :U flag fixes ownership automatically (UID mapping)
+        // Both flags can be combined for systems with SELinux
+        // 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 `podman create \\
+      --name ${this.containerName} \\
+      ${networkFlag} \\
+      --cap-add NET_ADMIN \\
+      --cap-add NET_BIND_SERVICE \\
+      --restart unless-stopped \\
+      -v "${configPath}:${containerConfigPath}:z,U" \\
+      -v "${applicationsPath}:${containerConfigPath}/applications:z,U" \\
+      ${dockerSocketMount} \\
+      ${podmanSocketMount} \\
+      -e NODE_ENV=production \\
+      -e EDGIBLE_CONFIG_PATH="${containerConfigPath}" \\
+      -e DEVICE_TYPE=${config.deviceType} \\
+      ${this.imageName} \\
+      start --config "${containerConfigFile}"`;
+    }
+    async createUserService(config) {
+        if (this.platform !== 'linux') {
+            // Only create systemd user service on Linux
+            return;
+        }
+        const serviceContent = `[Unit]
+Description=Edgible Agent (Podman)
+After=network.target
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+ExecStart=/usr/bin/podman start ${this.containerName}
+ExecStop=/usr/bin/podman stop ${this.containerName}
+
+[Install]
+WantedBy=default.target
+`;
+        try {
+            // Ensure systemd user directory exists
+            await fs.mkdir(this.systemdUserPath, { recursive: true });
+            await fs.writeFile(path.join(this.systemdUserPath, 'edgible-agent-podman.service'), serviceContent, 'utf8');
+            await execAsync('systemctl --user daemon-reload');
+            console.log('Systemd user service created');
+        }
+        catch (error) {
+            console.warn('Failed to create systemd user service:', error);
+        }
+    }
+}
+exports.PodmanDaemonManager = PodmanDaemonManager;
+//# sourceMappingURL=PodmanDaemonManager.js.map