@opencode-cloud/core 1.0.8 → 3.0.15

package/src/host/provision.rs

@@ -0,0 +1,394 @@
+//! Remote host provisioning
+//!
+//! Functions to detect Linux distribution and install Docker on remote hosts.
+
+use std::process::{Command, Stdio};
+
+use super::error::HostError;
+use super::schema::HostConfig;
+
+/// Linux distribution family
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum DistroFamily {
+    /// Debian, Ubuntu, and derivatives (apt-based)
+    Debian,
+    /// RHEL, CentOS, Fedora, Amazon Linux (dnf/yum-based)
+    RedHat,
+    /// Alpine Linux (apk-based)
+    Alpine,
+    /// Arch Linux (pacman-based)
+    Arch,
+    /// SUSE/openSUSE (zypper-based)
+    Suse,
+    /// Unknown distribution
+    Unknown(String),
+}
+
+impl std::fmt::Display for DistroFamily {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            DistroFamily::Debian => write!(f, "Debian/Ubuntu"),
+            DistroFamily::RedHat => write!(f, "RHEL/Amazon Linux"),
+            DistroFamily::Alpine => write!(f, "Alpine"),
+            DistroFamily::Arch => write!(f, "Arch"),
+            DistroFamily::Suse => write!(f, "SUSE"),
+            DistroFamily::Unknown(id) => write!(f, "Unknown ({id})"),
+        }
+    }
+}
+
+/// Detected distribution information
+#[derive(Debug, Clone)]
+pub struct DistroInfo {
+    /// Distribution family (Debian, RedHat, etc.)
+    pub family: DistroFamily,
+    /// Distribution ID (e.g., "ubuntu", "amzn", "debian")
+    pub id: String,
+    /// Pretty name (e.g., "Ubuntu 22.04.3 LTS")
+    pub pretty_name: String,
+    /// Version ID (e.g., "22.04", "2023")
+    pub version_id: Option<String>,
+}
+
+/// Detect the Linux distribution on a remote host
+///
+/// Runs `cat /etc/os-release` via SSH to parse distribution info.
+pub fn detect_distro(host: &HostConfig) -> Result<DistroInfo, HostError> {
+    let output = run_ssh_command(host, "cat /etc/os-release")?;
+
+    parse_os_release(&output)
+}
+
+/// Parse /etc/os-release content into DistroInfo
+fn parse_os_release(content: &str) -> Result<DistroInfo, HostError> {
+    let mut id = String::new();
+    let mut id_like = String::new();
+    let mut pretty_name = String::new();
+    let mut version_id = None;
+
+    for line in content.lines() {
+        if let Some((key, value)) = line.split_once('=') {
+            let value = value.trim_matches('"');
+            match key {
+                "ID" => id = value.to_lowercase(),
+                "ID_LIKE" => id_like = value.to_lowercase(),
+                "PRETTY_NAME" => pretty_name = value.to_string(),
+                "VERSION_ID" => version_id = Some(value.to_string()),
+                _ => {}
+            }
+        }
+    }
+
+    if id.is_empty() {
+        return Err(HostError::ConnectionFailed(
+            "Could not detect Linux distribution".to_string(),
+        ));
+    }
+
+    // Determine distribution family
+    let family = match id.as_str() {
+        "ubuntu" | "debian" | "linuxmint" | "pop" | "elementary" | "raspbian" => {
+            DistroFamily::Debian
+        }
+        "amzn" | "rhel" | "centos" | "fedora" | "rocky" | "almalinux" | "ol" => {
+            DistroFamily::RedHat
+        }
+        "alpine" => DistroFamily::Alpine,
+        "arch" | "manjaro" | "endeavouros" => DistroFamily::Arch,
+        "opensuse" | "sles" | "opensuse-leap" | "opensuse-tumbleweed" => DistroFamily::Suse,
+        _ => {
+            // Check ID_LIKE for derivatives
+            if id_like.contains("debian") || id_like.contains("ubuntu") {
+                DistroFamily::Debian
+            } else if id_like.contains("rhel")
+                || id_like.contains("fedora")
+                || id_like.contains("centos")
+            {
+                DistroFamily::RedHat
+            } else if id_like.contains("arch") {
+                DistroFamily::Arch
+            } else if id_like.contains("suse") {
+                DistroFamily::Suse
+            } else {
+                DistroFamily::Unknown(id.clone())
+            }
+        }
+    };
+
+    Ok(DistroInfo {
+        family,
+        id,
+        pretty_name,
+        version_id,
+    })
+}
+
+/// Install Docker on a remote host
+///
+/// Returns a vector of commands that will be executed (for user review).
+pub fn get_docker_install_commands(distro: &DistroInfo) -> Result<Vec<&'static str>, HostError> {
+    match &distro.family {
+        DistroFamily::Debian => Ok(vec![
+            // Update package index
+            "sudo apt-get update",
+            // Install prerequisites
+            "sudo apt-get install -y ca-certificates curl gnupg",
+            // Add Docker's official GPG key
+            "sudo install -m 0755 -d /etc/apt/keyrings",
+            "curl -fsSL https://download.docker.com/linux/$(. /etc/os-release && echo \"$ID\")/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg",
+            "sudo chmod a+r /etc/apt/keyrings/docker.gpg",
+            // Set up the repository
+            "echo \"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/$(. /etc/os-release && echo \"$ID\") $(. /etc/os-release && echo \"$VERSION_CODENAME\") stable\" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null",
+            // Install Docker
+            "sudo apt-get update",
+            "sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin",
+            // Start Docker
+            "sudo systemctl enable docker",
+            "sudo systemctl start docker",
+            // Add current user to docker group
+            "sudo usermod -aG docker $USER",
+        ]),
+
+        DistroFamily::RedHat => {
+            // Amazon Linux 2023 uses dnf, Amazon Linux 2 uses yum
+            // We'll use a command that works for both
+            Ok(vec![
+                // Install Docker (Amazon Linux uses amazon-linux-extras or dnf)
+                "sudo yum install -y docker || sudo dnf install -y docker",
+                // Start Docker
+                "sudo systemctl enable docker",
+                "sudo systemctl start docker",
+                // Add current user to docker group
+                "sudo usermod -aG docker $USER",
+            ])
+        }
+
+        DistroFamily::Alpine => Ok(vec![
+            "sudo apk add docker docker-cli-compose",
+            "sudo rc-update add docker boot",
+            "sudo service docker start",
+            "sudo addgroup $USER docker",
+        ]),
+
+        DistroFamily::Arch => Ok(vec![
+            "sudo pacman -Sy --noconfirm docker docker-compose",
+            "sudo systemctl enable docker",
+            "sudo systemctl start docker",
+            "sudo usermod -aG docker $USER",
+        ]),
+
+        DistroFamily::Suse => Ok(vec![
+            "sudo zypper install -y docker docker-compose",
+            "sudo systemctl enable docker",
+            "sudo systemctl start docker",
+            "sudo usermod -aG docker $USER",
+        ]),
+
+        DistroFamily::Unknown(id) => Err(HostError::ConnectionFailed(format!(
+            "Unsupported Linux distribution: {id}. Please install Docker manually."
+        ))),
+    }
+}
+
+/// Execute Docker installation on remote host
+///
+/// Runs the installation commands via SSH and captures output.
+pub fn install_docker(
+    host: &HostConfig,
+    distro: &DistroInfo,
+    on_output: impl Fn(&str),
+) -> Result<(), HostError> {
+    let commands = get_docker_install_commands(distro)?;
+
+    // Combine all commands with && to fail fast
+    let combined = commands.join(" && ");
+
+    on_output(&format!("Installing Docker on {} host...", distro.family));
+
+    // Run the installation
+    run_ssh_command_with_output(host, &combined, on_output)?;
+
+    Ok(())
+}
+
+/// Run a command on remote host via SSH and return output
+fn run_ssh_command(host: &HostConfig, command: &str) -> Result<String, HostError> {
+    let mut cmd = build_ssh_command(host);
+    cmd.arg(command);
+
+    cmd.stdin(Stdio::null())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped());
+
+    let output = cmd.output().map_err(|e| {
+        if e.kind() == std::io::ErrorKind::NotFound {
+            HostError::SshSpawn("SSH not found. Install OpenSSH client.".to_string())
+        } else {
+            HostError::SshSpawn(e.to_string())
+        }
+    })?;
+
+    if output.status.success() {
+        Ok(String::from_utf8_lossy(&output.stdout).to_string())
+    } else {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        Err(HostError::ConnectionFailed(stderr.to_string()))
+    }
+}
+
+/// Run a command on remote host via SSH with streaming output
+fn run_ssh_command_with_output(
+    host: &HostConfig,
+    command: &str,
+    on_output: impl Fn(&str),
+) -> Result<(), HostError> {
+    use std::io::{BufRead, BufReader};
+
+    let mut cmd = build_ssh_command(host);
+
+    // Request a pseudo-terminal for interactive commands (like sudo)
+    cmd.arg("-t").arg("-t");
+    cmd.arg(command);
+
+    cmd.stdin(Stdio::null())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped());
+
+    let mut child = cmd.spawn().map_err(|e| {
+        if e.kind() == std::io::ErrorKind::NotFound {
+            HostError::SshSpawn("SSH not found. Install OpenSSH client.".to_string())
+        } else {
+            HostError::SshSpawn(e.to_string())
+        }
+    })?;
+
+    // Stream stdout
+    if let Some(stdout) = child.stdout.take() {
+        let reader = BufReader::new(stdout);
+        for line in reader.lines().map_while(Result::ok) {
+            on_output(&line);
+        }
+    }
+
+    let status = child
+        .wait()
+        .map_err(|e| HostError::SshSpawn(e.to_string()))?;
+
+    if status.success() {
+        Ok(())
+    } else {
+        Err(HostError::ConnectionFailed(
+            "Docker installation failed".to_string(),
+        ))
+    }
+}
+
+/// Build base SSH command with host config
+fn build_ssh_command(host: &HostConfig) -> Command {
+    let mut cmd = Command::new("ssh");
+
+    // Standard options
+    cmd.arg("-o")
+        .arg("BatchMode=yes")
+        .arg("-o")
+        .arg("ConnectTimeout=30")
+        .arg("-o")
+        .arg("StrictHostKeyChecking=accept-new");
+
+    // Host-specific options (port, identity, jump, user@host)
+    cmd.args(host.ssh_args());
+
+    cmd
+}
+
+/// Verify Docker is working after installation
+///
+/// Note: Due to group membership changes, this may fail until the user
+/// reconnects. We run with sudo as a fallback.
+pub fn verify_docker_installed(host: &HostConfig) -> Result<String, HostError> {
+    // Try without sudo first (if group membership is active)
+    let output = run_ssh_command(
+        host,
+        "docker version --format '{{.Server.Version}}' 2>/dev/null || sudo docker version --format '{{.Server.Version}}'",
+    );
+
+    match output {
+        Ok(version) => Ok(version.trim().to_string()),
+        Err(_) => Err(HostError::RemoteDockerUnavailable(
+            "Docker installed but not accessible. You may need to reconnect for group membership to take effect.".to_string(),
+        )),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_os_release_ubuntu() {
+        let content = r#"
+PRETTY_NAME="Ubuntu 22.04.3 LTS"
+NAME="Ubuntu"
+VERSION_ID="22.04"
+VERSION="22.04.3 LTS (Jammy Jellyfish)"
+VERSION_CODENAME=jammy
+ID=ubuntu
+ID_LIKE=debian
+"#;
+        let info = parse_os_release(content).unwrap();
+        assert_eq!(info.family, DistroFamily::Debian);
+        assert_eq!(info.id, "ubuntu");
+        assert_eq!(info.version_id, Some("22.04".to_string()));
+    }
+
+    #[test]
+    fn test_parse_os_release_amazon_linux() {
+        let content = r#"
+NAME="Amazon Linux"
+VERSION="2023"
+ID="amzn"
+ID_LIKE="fedora"
+VERSION_ID="2023"
+PRETTY_NAME="Amazon Linux 2023"
+"#;
+        let info = parse_os_release(content).unwrap();
+        assert_eq!(info.family, DistroFamily::RedHat);
+        assert_eq!(info.id, "amzn");
+    }
+
+    #[test]
+    fn test_parse_os_release_debian() {
+        let content = r#"
+PRETTY_NAME="Debian GNU/Linux 12 (bookworm)"
+NAME="Debian GNU/Linux"
+VERSION_ID="12"
+VERSION="12 (bookworm)"
+ID=debian
+"#;
+        let info = parse_os_release(content).unwrap();
+        assert_eq!(info.family, DistroFamily::Debian);
+        assert_eq!(info.id, "debian");
+    }
+
+    #[test]
+    fn test_get_docker_install_commands() {
+        let debian_info = DistroInfo {
+            family: DistroFamily::Debian,
+            id: "ubuntu".to_string(),
+            pretty_name: "Ubuntu 22.04".to_string(),
+            version_id: Some("22.04".to_string()),
+        };
+        let commands = get_docker_install_commands(&debian_info).unwrap();
+        assert!(!commands.is_empty());
+        assert!(commands.iter().any(|c| c.contains("docker")));
+
+        let redhat_info = DistroInfo {
+            family: DistroFamily::RedHat,
+            id: "amzn".to_string(),
+            pretty_name: "Amazon Linux 2023".to_string(),
+            version_id: Some("2023".to_string()),
+        };
+        let commands = get_docker_install_commands(&redhat_info).unwrap();
+        assert!(!commands.is_empty());
+    }
+}

package/src/host/schema.rs

@@ -0,0 +1,308 @@
+//! Host configuration schema
+//!
+//! Data structures for storing remote host configurations.
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// Configuration for a remote host
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+pub struct HostConfig {
+    /// SSH hostname or IP address
+    pub hostname: String,
+
+    /// SSH username (default: current user from whoami)
+    #[serde(default = "default_user")]
+    pub user: String,
+
+    /// SSH port (default: 22)
+    #[serde(default)]
+    pub port: Option<u16>,
+
+    /// Path to SSH identity file (private key)
+    #[serde(default)]
+    pub identity_file: Option<String>,
+
+    /// Jump host for ProxyJump (user@host:port format)
+    #[serde(default)]
+    pub jump_host: Option<String>,
+
+    /// Organization groups/tags for this host
+    #[serde(default)]
+    pub groups: Vec<String>,
+
+    /// Optional description
+    #[serde(default)]
+    pub description: Option<String>,
+}
+
+fn default_user() -> String {
+    whoami::username()
+}
+
+impl Default for HostConfig {
+    fn default() -> Self {
+        Self {
+            hostname: String::new(),
+            user: default_user(),
+            port: None,
+            identity_file: None,
+            jump_host: None,
+            groups: Vec::new(),
+            description: None,
+        }
+    }
+}
+
+impl HostConfig {
+    /// Create a new host config with just hostname
+    pub fn new(hostname: impl Into<String>) -> Self {
+        Self {
+            hostname: hostname.into(),
+            ..Default::default()
+        }
+    }
+
+    /// Builder pattern: set user
+    pub fn with_user(mut self, user: impl Into<String>) -> Self {
+        self.user = user.into();
+        self
+    }
+
+    /// Builder pattern: set port
+    pub fn with_port(mut self, port: u16) -> Self {
+        self.port = Some(port);
+        self
+    }
+
+    /// Builder pattern: set identity file
+    pub fn with_identity_file(mut self, path: impl Into<String>) -> Self {
+        self.identity_file = Some(path.into());
+        self
+    }
+
+    /// Builder pattern: set jump host
+    pub fn with_jump_host(mut self, jump: impl Into<String>) -> Self {
+        self.jump_host = Some(jump.into());
+        self
+    }
+
+    /// Builder pattern: add group
+    pub fn with_group(mut self, group: impl Into<String>) -> Self {
+        self.groups.push(group.into());
+        self
+    }
+
+    /// Builder pattern: set description
+    pub fn with_description(mut self, desc: impl Into<String>) -> Self {
+        self.description = Some(desc.into());
+        self
+    }
+
+    /// Get SSH command arguments for this host
+    ///
+    /// Returns arguments for port, identity file, jump host, and target (user@hostname).
+    /// Does NOT include standard options like BatchMode or ConnectTimeout.
+    pub fn ssh_args(&self) -> Vec<String> {
+        let mut args = Vec::new();
+
+        // Port (if specified)
+        if let Some(port) = self.port {
+            args.push("-p".to_string());
+            args.push(port.to_string());
+        }
+
+        // Identity file
+        if let Some(key) = &self.identity_file {
+            args.push("-i".to_string());
+            args.push(key.clone());
+        }
+
+        // Jump host
+        if let Some(jump) = &self.jump_host {
+            args.push("-J".to_string());
+            args.push(jump.clone());
+        }
+
+        // Target: user@hostname
+        args.push(format!("{}@{}", self.user, self.hostname));
+
+        args
+    }
+
+    /// Format the effective SSH command for display
+    ///
+    /// Returns a human-readable SSH command string showing how the connection
+    /// will be made, useful for debugging and user feedback.
+    pub fn format_ssh_command(&self) -> String {
+        let mut parts = vec!["ssh".to_string()];
+
+        // Port (if non-default)
+        if let Some(port) = self.port {
+            if port != 22 {
+                parts.push(format!("-p {port}"));
+            }
+        }
+
+        // Identity file
+        if let Some(key) = &self.identity_file {
+            parts.push(format!("-i {key}"));
+        }
+
+        // Jump host
+        if let Some(jump) = &self.jump_host {
+            parts.push(format!("-J {jump}"));
+        }
+
+        // Target: user@hostname
+        parts.push(format!("{}@{}", self.user, self.hostname));
+
+        parts.join(" ")
+    }
+}
+
+/// Root structure for hosts.json file
+#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]
+#[serde(deny_unknown_fields)]
+pub struct HostsFile {
+    /// Schema version for future migrations
+    #[serde(default = "default_version")]
+    pub version: u32,
+
+    /// Default host name (None = local Docker)
+    #[serde(default)]
+    pub default_host: Option<String>,
+
+    /// Map of host name to configuration
+    #[serde(default)]
+    pub hosts: HashMap<String, HostConfig>,
+}
+
+fn default_version() -> u32 {
+    1
+}
+
+impl HostsFile {
+    /// Create empty hosts file
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Add a host
+    pub fn add_host(&mut self, name: impl Into<String>, config: HostConfig) {
+        self.hosts.insert(name.into(), config);
+    }
+
+    /// Remove a host
+    pub fn remove_host(&mut self, name: &str) -> Option<HostConfig> {
+        // Clear default if removing the default host
+        if self.default_host.as_deref() == Some(name) {
+            self.default_host = None;
+        }
+        self.hosts.remove(name)
+    }
+
+    /// Get a host by name
+    pub fn get_host(&self, name: &str) -> Option<&HostConfig> {
+        self.hosts.get(name)
+    }
+
+    /// Get mutable reference to a host
+    pub fn get_host_mut(&mut self, name: &str) -> Option<&mut HostConfig> {
+        self.hosts.get_mut(name)
+    }
+
+    /// Check if host exists
+    pub fn has_host(&self, name: &str) -> bool {
+        self.hosts.contains_key(name)
+    }
+
+    /// Set the default host
+    pub fn set_default(&mut self, name: Option<String>) {
+        self.default_host = name;
+    }
+
+    /// Get list of host names
+    pub fn host_names(&self) -> Vec<&str> {
+        self.hosts.keys().map(|s| s.as_str()).collect()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_host_config_defaults() {
+        let config = HostConfig::default();
+        assert!(config.hostname.is_empty());
+        assert!(!config.user.is_empty()); // Should be current user
+        assert!(config.port.is_none());
+        assert!(config.identity_file.is_none());
+        assert!(config.jump_host.is_none());
+        assert!(config.groups.is_empty());
+        assert!(config.description.is_none());
+    }
+
+    #[test]
+    fn test_host_config_builder() {
+        let config = HostConfig::new("example.com")
+            .with_user("admin")
+            .with_port(2222)
+            .with_identity_file("~/.ssh/prod_key")
+            .with_group("production");
+
+        assert_eq!(config.hostname, "example.com");
+        assert_eq!(config.user, "admin");
+        assert_eq!(config.port, Some(2222));
+        assert_eq!(config.identity_file, Some("~/.ssh/prod_key".to_string()));
+        assert_eq!(config.groups, vec!["production"]);
+    }
+
+    #[test]
+    fn test_hosts_file_operations() {
+        let mut hosts = HostsFile::new();
+        assert!(hosts.hosts.is_empty());
+
+        // Add host
+        hosts.add_host("prod-1", HostConfig::new("prod1.example.com"));
+        assert!(hosts.has_host("prod-1"));
+        assert!(!hosts.has_host("prod-2"));
+
+        // Set default
+        hosts.set_default(Some("prod-1".to_string()));
+        assert_eq!(hosts.default_host, Some("prod-1".to_string()));
+
+        // Remove host clears default
+        hosts.remove_host("prod-1");
+        assert!(!hosts.has_host("prod-1"));
+        assert!(hosts.default_host.is_none());
+    }
+
+    #[test]
+    fn test_serialize_deserialize() {
+        let mut hosts = HostsFile::new();
+        hosts.add_host(
+            "test",
+            HostConfig::new("test.example.com")
+                .with_user("testuser")
+                .with_port(22),
+        );
+
+        let json = serde_json::to_string_pretty(&hosts).unwrap();
+        let parsed: HostsFile = serde_json::from_str(&json).unwrap();
+
+        assert_eq!(hosts, parsed);
+    }
+
+    #[test]
+    fn test_deserialize_minimal() {
+        // Minimal JSON should work with defaults
+        let json = r#"{"version": 1}"#;
+        let hosts: HostsFile = serde_json::from_str(json).unwrap();
+        assert_eq!(hosts.version, 1);
+        assert!(hosts.hosts.is_empty());
+        assert!(hosts.default_host.is_none());
+    }
+}