@opencode-cloud/core 0.1.2 → 1.0.3

package/src/platform/launchd.rs

@@ -0,0 +1,363 @@
+//! macOS launchd service manager implementation
+//!
+//! Manages launchd user agents and system daemons for service registration.
+//! Uses plist serialization for property list generation and launchctl for
+//! service lifecycle management.
+
+use std::fs::{self, File};
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use anyhow::{Result, anyhow};
+use serde::Serialize;
+
+use super::{InstallResult, ServiceConfig, ServiceManager};
+
+/// Service label used for launchd registration
+const SERVICE_LABEL: &str = "com.opencode-cloud.service";
+
+/// Plist structure for launchd service definition
+#[derive(Serialize)]
+#[serde(rename_all = "PascalCase")]
+struct LaunchdPlist {
+    label: String,
+    program_arguments: Vec<String>,
+    run_at_load: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    keep_alive: Option<KeepAliveConfig>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    throttle_interval: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    standard_out_path: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    standard_error_path: Option<String>,
+}
+
+/// KeepAlive configuration for restart behavior
+#[derive(Serialize)]
+#[serde(rename_all = "PascalCase")]
+struct KeepAliveConfig {
+    /// Restart only on non-zero exit (false = restart on crash)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    successful_exit: Option<bool>,
+    /// Restart on signal-based crash (SIGSEGV, etc.)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    crashed: Option<bool>,
+}
+
+/// macOS launchd service manager
+///
+/// Manages launchd user agents (~/Library/LaunchAgents/) or system daemons
+/// (/Library/LaunchDaemons/) depending on the boot mode.
+pub struct LaunchdManager {
+    /// true = user mode (~/Library/LaunchAgents/), false = system (/Library/LaunchDaemons/)
+    user_mode: bool,
+}
+
+impl LaunchdManager {
+    /// Create a new LaunchdManager
+    ///
+    /// # Arguments
+    /// * `boot_mode` - "user" for user agents, "system" for system daemons
+    pub fn new(boot_mode: &str) -> Self {
+        Self {
+            user_mode: boot_mode != "system",
+        }
+    }
+
+    /// Get the directory where service files are stored
+    fn service_dir(&self) -> PathBuf {
+        if self.user_mode {
+            directories::BaseDirs::new()
+                .expect("Could not determine base directories")
+                .home_dir()
+                .join("Library/LaunchAgents")
+        } else {
+            PathBuf::from("/Library/LaunchDaemons")
+        }
+    }
+
+    /// Get the service label
+    fn label(&self) -> &str {
+        SERVICE_LABEL
+    }
+
+    /// Get the log path for a given stream (stdout or stderr)
+    fn log_path(&self, stream: &str) -> PathBuf {
+        directories::BaseDirs::new()
+            .expect("Could not determine base directories")
+            .home_dir()
+            .join(format!("Library/Logs/opencode-cloud.{stream}.log"))
+    }
+
+    /// Generate plist content from service configuration
+    fn generate_plist(&self, config: &ServiceConfig) -> LaunchdPlist {
+        LaunchdPlist {
+            label: self.label().to_string(),
+            program_arguments: vec![
+                config.executable_path.display().to_string(),
+                "start".to_string(),
+                "--no-daemon".to_string(),
+            ],
+            run_at_load: true,
+            keep_alive: Some(KeepAliveConfig {
+                // Only restart on non-zero exit (crash)
+                successful_exit: Some(false),
+                // Restart on signal-based crash
+                crashed: Some(true),
+            }),
+            throttle_interval: Some(config.restart_delay),
+            standard_out_path: Some(self.log_path("stdout").display().to_string()),
+            standard_error_path: Some(self.log_path("stderr").display().to_string()),
+        }
+    }
+}
+
+/// Get the current user's UID
+fn get_user_id() -> Result<u32> {
+    let output = Command::new("id").arg("-u").output()?;
+    let uid_str = String::from_utf8_lossy(&output.stdout);
+    uid_str
+        .trim()
+        .parse()
+        .map_err(|e| anyhow!("Failed to parse UID: {}", e))
+}
+
+impl ServiceManager for LaunchdManager {
+    fn install(&self, config: &ServiceConfig) -> Result<InstallResult> {
+        // Check permissions for system-level install
+        if !self.user_mode {
+            let uid = get_user_id()?;
+            if uid != 0 {
+                return Err(anyhow!(
+                    "System-level installation requires root. Run with sudo."
+                ));
+            }
+        }
+
+        // Create service directory if needed
+        let service_dir = self.service_dir();
+        if !service_dir.exists() {
+            fs::create_dir_all(&service_dir)?;
+        }
+
+        let plist_path = self.service_file_path();
+
+        // If service is already loaded, bootout first
+        if plist_path.exists() {
+            // Ignore errors during bootout - service might not be running
+            let _ = self.bootout();
+        }
+
+        // Generate and write plist
+        let plist = self.generate_plist(config);
+        let file = File::create(&plist_path)?;
+        plist::to_writer_xml(file, &plist)?;
+
+        // Bootstrap the service
+        self.bootstrap(&plist_path)?;
+
+        Ok(InstallResult {
+            service_file_path: plist_path,
+            service_name: self.label().to_string(),
+            started: true,
+            requires_root: !self.user_mode,
+        })
+    }
+
+    fn uninstall(&self) -> Result<()> {
+        let plist_path = self.service_file_path();
+
+        // Bootout service if running (ignore errors for idempotency)
+        let _ = self.bootout();
+
+        // Remove plist file if it exists
+        if plist_path.exists() {
+            fs::remove_file(&plist_path)?;
+        }
+
+        Ok(())
+    }
+
+    fn is_installed(&self) -> Result<bool> {
+        Ok(self.service_file_path().exists())
+    }
+
+    fn service_file_path(&self) -> PathBuf {
+        self.service_dir().join(format!("{}.plist", self.label()))
+    }
+
+    fn service_name(&self) -> &str {
+        self.label()
+    }
+}
+
+impl LaunchdManager {
+    /// Bootstrap the service using modern launchctl syntax
+    fn bootstrap(&self, plist_path: &Path) -> Result<()> {
+        let output = if self.user_mode {
+            let uid = get_user_id()?;
+            let domain = format!("gui/{uid}");
+            Command::new("launchctl")
+                .args(["bootstrap", &domain, &plist_path.display().to_string()])
+                .output()?
+        } else {
+            Command::new("launchctl")
+                .args(["bootstrap", "system", &plist_path.display().to_string()])
+                .output()?
+        };
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            // Handle "already loaded" error gracefully - service is running
+            if stderr.contains("already loaded") || stderr.contains("service already loaded") {
+                return Ok(());
+            }
+            return Err(anyhow!("Failed to bootstrap service: {}", stderr.trim()));
+        }
+
+        Ok(())
+    }
+
+    /// Bootout the service using modern launchctl syntax
+    fn bootout(&self) -> Result<()> {
+        let output = if self.user_mode {
+            let uid = get_user_id()?;
+            let service_target = format!("gui/{uid}/{}", self.label());
+            Command::new("launchctl")
+                .args(["bootout", &service_target])
+                .output()?
+        } else {
+            let service_target = format!("system/{}", self.label());
+            Command::new("launchctl")
+                .args(["bootout", &service_target])
+                .output()?
+        };
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            // Handle "not found" error gracefully - service wasn't running
+            if stderr.contains("not find") || stderr.contains("No such") {
+                return Ok(());
+            }
+            return Err(anyhow!("Failed to bootout service: {}", stderr.trim()));
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_launchd_manager_user_mode() {
+        let manager = LaunchdManager::new("user");
+        assert!(manager.user_mode);
+        assert_eq!(manager.label(), SERVICE_LABEL);
+    }
+
+    #[test]
+    fn test_launchd_manager_system_mode() {
+        let manager = LaunchdManager::new("system");
+        assert!(!manager.user_mode);
+    }
+
+    #[test]
+    fn test_service_dir_user_mode() {
+        let manager = LaunchdManager::new("user");
+        let service_dir = manager.service_dir();
+        assert!(
+            service_dir
+                .to_string_lossy()
+                .contains("Library/LaunchAgents")
+        );
+    }
+
+    #[test]
+    fn test_service_dir_system_mode() {
+        let manager = LaunchdManager::new("system");
+        let service_dir = manager.service_dir();
+        assert_eq!(service_dir, PathBuf::from("/Library/LaunchDaemons"));
+    }
+
+    #[test]
+    fn test_service_file_path() {
+        let manager = LaunchdManager::new("user");
+        let path = manager.service_file_path();
+        assert!(path.to_string_lossy().ends_with(".plist"));
+        assert!(
+            path.to_string_lossy()
+                .contains("com.opencode-cloud.service")
+        );
+    }
+
+    #[test]
+    fn test_log_path() {
+        let manager = LaunchdManager::new("user");
+        let stdout_path = manager.log_path("stdout");
+        let stderr_path = manager.log_path("stderr");
+
+        assert!(stdout_path.to_string_lossy().contains("Library/Logs"));
+        assert!(
+            stdout_path
+                .to_string_lossy()
+                .contains("opencode-cloud.stdout.log")
+        );
+        assert!(
+            stderr_path
+                .to_string_lossy()
+                .contains("opencode-cloud.stderr.log")
+        );
+    }
+
+    #[test]
+    fn test_generate_plist() {
+        let manager = LaunchdManager::new("user");
+        let config = ServiceConfig {
+            executable_path: PathBuf::from("/usr/local/bin/occ"),
+            restart_retries: 3,
+            restart_delay: 5,
+            boot_mode: "user".to_string(),
+        };
+
+        let plist = manager.generate_plist(&config);
+
+        assert_eq!(plist.label, SERVICE_LABEL);
+        assert_eq!(plist.program_arguments.len(), 3);
+        assert_eq!(plist.program_arguments[0], "/usr/local/bin/occ");
+        assert_eq!(plist.program_arguments[1], "start");
+        assert_eq!(plist.program_arguments[2], "--no-daemon");
+        assert!(plist.run_at_load);
+        assert!(plist.keep_alive.is_some());
+        assert_eq!(plist.throttle_interval, Some(5));
+    }
+
+    #[test]
+    fn test_plist_serialization() {
+        let manager = LaunchdManager::new("user");
+        let config = ServiceConfig {
+            executable_path: PathBuf::from("/usr/local/bin/occ"),
+            restart_retries: 3,
+            restart_delay: 5,
+            boot_mode: "user".to_string(),
+        };
+
+        let plist = manager.generate_plist(&config);
+
+        // Serialize to XML string to verify format
+        let mut buffer = Vec::new();
+        plist::to_writer_xml(&mut buffer, &plist).expect("Failed to serialize plist");
+        let xml = String::from_utf8(buffer).expect("Invalid UTF-8");
+
+        // Verify key elements are present
+        assert!(xml.contains("<key>Label</key>"));
+        assert!(xml.contains("<string>com.opencode-cloud.service</string>"));
+        assert!(xml.contains("<key>ProgramArguments</key>"));
+        assert!(xml.contains("<key>RunAtLoad</key>"));
+        assert!(xml.contains("<true/>"));
+        assert!(xml.contains("<key>KeepAlive</key>"));
+        assert!(xml.contains("<key>ThrottleInterval</key>"));
+    }
+}

package/src/platform/mod.rs

@@ -0,0 +1,191 @@
+//! Platform-specific service manager abstraction
+//!
+//! This module provides a unified interface for registering the opencode-cloud
+//! service with platform-specific init systems (systemd on Linux, launchd on macOS).
+
+use std::path::PathBuf;
+
+use anyhow::Result;
+
+#[cfg(any(
+    target_os = "linux",
+    not(any(target_os = "linux", target_os = "macos"))
+))]
+use anyhow::anyhow;
+
+#[cfg(target_os = "linux")]
+mod systemd;
+
+#[cfg(target_os = "macos")]
+mod launchd;
+
+#[cfg(target_os = "linux")]
+pub use systemd::{SystemdManager, systemd_available};
+
+#[cfg(target_os = "macos")]
+pub use launchd::LaunchdManager;
+
+/// Configuration for service installation
+#[derive(Debug, Clone)]
+pub struct ServiceConfig {
+    /// Path to the executable to run
+    pub executable_path: PathBuf,
+
+    /// Number of restart attempts on crash
+    pub restart_retries: u32,
+
+    /// Seconds between restart attempts
+    pub restart_delay: u32,
+
+    /// Boot mode: "user" (starts on login) or "system" (starts on boot)
+    pub boot_mode: String,
+}
+
+/// Result of a service installation operation
+#[derive(Debug, Clone)]
+pub struct InstallResult {
+    /// Path to the service file that was created
+    pub service_file_path: PathBuf,
+
+    /// Name of the service (e.g., "opencode-cloud")
+    pub service_name: String,
+
+    /// Whether the service was started after installation
+    pub started: bool,
+
+    /// Whether root/sudo is required for this installation type
+    pub requires_root: bool,
+}
+
+/// Trait for platform-specific service managers
+///
+/// Implementations handle the details of registering services with
+/// systemd (Linux) or launchd (macOS).
+pub trait ServiceManager: Send + Sync {
+    /// Install the service with the given configuration
+    ///
+    /// Creates the service file and registers it with the init system.
+    /// Also starts the service immediately after registration.
+    fn install(&self, config: &ServiceConfig) -> Result<InstallResult>;
+
+    /// Uninstall the service
+    ///
+    /// Stops the service if running and removes the registration.
+    fn uninstall(&self) -> Result<()>;
+
+    /// Check if the service is currently installed
+    fn is_installed(&self) -> Result<bool>;
+
+    /// Get the path to the service file
+    fn service_file_path(&self) -> PathBuf;
+
+    /// Get the service name
+    fn service_name(&self) -> &str;
+}
+
+/// Get the appropriate service manager for the current platform
+///
+/// Returns an error if the platform is not supported or if the
+/// service manager implementation is not yet available.
+pub fn get_service_manager() -> Result<Box<dyn ServiceManager>> {
+    #[cfg(target_os = "linux")]
+    {
+        if !systemd::systemd_available() {
+            return Err(anyhow!(
+                "systemd not available on this system. \
+                 Service registration requires systemd as the init system."
+            ));
+        }
+        Ok(Box::new(systemd::SystemdManager::new("user")))
+    }
+    #[cfg(target_os = "macos")]
+    {
+        Ok(Box::new(launchd::LaunchdManager::new("user")))
+    }
+    #[cfg(not(any(target_os = "linux", target_os = "macos")))]
+    {
+        Err(anyhow!("Unsupported platform for service registration"))
+    }
+}
+
+/// Check if service registration is supported on the current platform
+///
+/// Returns true for Linux (systemd) and macOS (launchd).
+pub fn is_service_registration_supported() -> bool {
+    cfg!(any(target_os = "linux", target_os = "macos"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_service_config_creation() {
+        let config = ServiceConfig {
+            executable_path: PathBuf::from("/usr/local/bin/occ"),
+            restart_retries: 3,
+            restart_delay: 5,
+            boot_mode: "user".to_string(),
+        };
+
+        assert_eq!(config.executable_path, PathBuf::from("/usr/local/bin/occ"));
+        assert_eq!(config.restart_retries, 3);
+        assert_eq!(config.restart_delay, 5);
+        assert_eq!(config.boot_mode, "user");
+    }
+
+    #[test]
+    fn test_install_result_creation() {
+        let result = InstallResult {
+            service_file_path: PathBuf::from("/etc/systemd/user/opencode-cloud.service"),
+            service_name: "opencode-cloud".to_string(),
+            started: true,
+            requires_root: false,
+        };
+
+        assert_eq!(
+            result.service_file_path,
+            PathBuf::from("/etc/systemd/user/opencode-cloud.service")
+        );
+        assert_eq!(result.service_name, "opencode-cloud");
+        assert!(result.started);
+        assert!(!result.requires_root);
+    }
+
+    #[test]
+    fn test_is_service_registration_supported() {
+        // On macOS/Linux this should return true, on other platforms false
+        #[cfg(any(target_os = "linux", target_os = "macos"))]
+        assert!(is_service_registration_supported());
+
+        #[cfg(not(any(target_os = "linux", target_os = "macos")))]
+        assert!(!is_service_registration_supported());
+    }
+
+    #[test]
+    fn test_get_service_manager_behavior() {
+        let result = get_service_manager();
+
+        // On Linux with systemd: returns Ok(SystemdManager)
+        // On Linux without systemd: returns Err (systemd not available)
+        // On macOS: returns Ok(LaunchdManager)
+        // On other platforms: returns Err (unsupported)
+        #[cfg(target_os = "linux")]
+        {
+            // Result depends on whether systemd is available
+            // This test just verifies the function doesn't panic
+            let _ = result;
+        }
+        #[cfg(target_os = "macos")]
+        {
+            // LaunchdManager should be returned on macOS
+            assert!(result.is_ok());
+            let manager = result.unwrap();
+            assert_eq!(manager.service_name(), "com.opencode-cloud.service");
+        }
+        #[cfg(not(any(target_os = "linux", target_os = "macos")))]
+        {
+            assert!(result.is_err());
+        }
+    }
+}