@opencode-cloud/core 0.1.3 → 1.0.4

package/src/docker/progress.rs

@@ -0,0 +1,401 @@
+//! Progress reporting utilities for Docker operations
+//!
+//! This module provides progress bars and spinners for Docker image
+//! builds and pulls, using indicatif for terminal output.
+
+use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
+use std::collections::HashMap;
+use std::time::{Duration, Instant};
+
+/// Minimum time between spinner message updates to prevent flickering
+const SPINNER_UPDATE_THROTTLE: Duration = Duration::from_millis(150);
+
+/// Strip ANSI escape codes from a string
+///
+/// Docker build output often contains ANSI color codes that can interfere
+/// with our spinner display. This removes them for clean output.
+fn strip_ansi_codes(s: &str) -> String {
+    let mut result = String::with_capacity(s.len());
+    let mut chars = s.chars().peekable();
+
+    while let Some(c) = chars.next() {
+        if c == '\x1b' {
+            // Check for CSI sequence: ESC [
+            if chars.peek() == Some(&'[') {
+                chars.next(); // consume '['
+                // Skip until we hit a letter (the command character)
+                while let Some(&next) = chars.peek() {
+                    chars.next();
+                    if next.is_ascii_alphabetic() {
+                        break;
+                    }
+                }
+            }
+            // Also handle ESC followed by other sequences (less common)
+        } else {
+            result.push(c);
+        }
+    }
+
+    result
+}
+
+/// Format duration as MM:SS, or HH:MM:SS if over an hour
+fn format_elapsed(duration: Duration) -> String {
+    let total_secs = duration.as_secs();
+    let hours = total_secs / 3600;
+    let minutes = (total_secs % 3600) / 60;
+    let seconds = total_secs % 60;
+
+    if hours > 0 {
+        format!("{:02}:{:02}:{:02}", hours, minutes, seconds)
+    } else {
+        format!("{:02}:{:02}", minutes, seconds)
+    }
+}
+
+/// Progress reporter for Docker operations
+///
+/// Manages multiple progress bars for concurrent operations like
+/// multi-layer image pulls and build steps.
+pub struct ProgressReporter {
+    multi: MultiProgress,
+    bars: HashMap<String, ProgressBar>,
+    last_update: HashMap<String, Instant>,
+    last_message: HashMap<String, String>,
+    start_time: Instant,
+    /// Optional context prefix shown before step messages (e.g., "Building Docker image")
+    context: Option<String>,
+}
+
+impl Default for ProgressReporter {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ProgressReporter {
+    /// Create a new progress reporter
+    pub fn new() -> Self {
+        Self {
+            multi: MultiProgress::new(),
+            bars: HashMap::new(),
+            last_update: HashMap::new(),
+            last_message: HashMap::new(),
+            start_time: Instant::now(),
+            context: None,
+        }
+    }
+
+    /// Create a new progress reporter with a context prefix
+    ///
+    /// The context is shown before step messages, e.g., "Building Docker image · Step 1/10"
+    pub fn with_context(context: &str) -> Self {
+        Self {
+            multi: MultiProgress::new(),
+            bars: HashMap::new(),
+            last_update: HashMap::new(),
+            last_message: HashMap::new(),
+            start_time: Instant::now(),
+            context: Some(context.to_string()),
+        }
+    }
+
+    /// Format a message with context prefix if set
+    fn format_message(&self, message: &str) -> String {
+        let elapsed = format_elapsed(self.start_time.elapsed());
+
+        // Strip ANSI escape codes that Docker may include in its output
+        let stripped = strip_ansi_codes(message);
+
+        // Collapse message to single line for spinner display:
+        // - Replace all whitespace sequences (including newlines) with single space
+        // - Trim leading/trailing whitespace
+        let clean_msg = stripped.split_whitespace().collect::<Vec<_>>().join(" ");
+
+        // Format: "[elapsed] Context · message" or "[elapsed] message"
+        // Timer at the beginning for easy scanning
+        match &self.context {
+            Some(ctx) => format!("[{}] {} · {}", elapsed, ctx, clean_msg),
+            None => format!("[{}] {}", elapsed, clean_msg),
+        }
+    }
+
+    /// Create a spinner for indeterminate progress (e.g., build steps)
+    pub fn add_spinner(&mut self, id: &str, message: &str) -> &ProgressBar {
+        let spinner = self.multi.add(ProgressBar::new_spinner());
+        spinner.set_style(
+            ProgressStyle::default_spinner()
+                .template("{spinner:.green} {msg}")
+                .expect("valid template")
+                .tick_chars("⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"),
+        );
+        spinner.set_message(self.format_message(message));
+        spinner.enable_steady_tick(std::time::Duration::from_millis(100));
+        self.bars.insert(id.to_string(), spinner);
+        self.bars.get(id).expect("just inserted")
+    }
+
+    /// Create a progress bar for determinate progress (e.g., layer download)
+    ///
+    /// `total` is in bytes
+    pub fn add_bar(&mut self, id: &str, total: u64) -> &ProgressBar {
+        let bar = self.multi.add(ProgressBar::new(total));
+        bar.set_style(
+            ProgressStyle::default_bar()
+                .template(
+                    "{spinner:.green} [{bar:40.cyan/blue}] {bytes}/{total_bytes} ({eta}) {msg}",
+                )
+                .expect("valid template")
+                .progress_chars("=>-"),
+        );
+        bar.enable_steady_tick(std::time::Duration::from_millis(100));
+        self.bars.insert(id.to_string(), bar);
+        self.bars.get(id).expect("just inserted")
+    }
+
+    /// Update progress for a layer (used during image pull)
+    ///
+    /// `current` and `total` are in bytes, `status` is the Docker status message
+    pub fn update_layer(&mut self, layer_id: &str, current: u64, total: u64, status: &str) {
+        if let Some(bar) = self.bars.get(layer_id) {
+            // Update total if it changed (Docker sometimes updates this)
+            if bar.length() != Some(total) && total > 0 {
+                bar.set_length(total);
+            }
+            bar.set_position(current);
+            bar.set_message(status.to_string());
+        } else {
+            // Create new bar for this layer
+            let bar = self.add_bar(layer_id, total);
+            bar.set_position(current);
+            bar.set_message(status.to_string());
+        }
+    }
+
+    /// Update spinner message (used during build)
+    ///
+    /// Updates are throttled to prevent flickering from rapid message changes.
+    /// "Step X/Y" messages always update immediately as they indicate significant progress.
+    pub fn update_spinner(&mut self, id: &str, message: &str) {
+        let now = Instant::now();
+        let is_step_message = message.starts_with("Step ");
+
+        // Check if we should throttle this update
+        if !is_step_message {
+            if let Some(last) = self.last_update.get(id) {
+                if now.duration_since(*last) < SPINNER_UPDATE_THROTTLE {
+                    return; // Throttle: too soon since last update
+                }
+            }
+
+            // Skip if message is identical to last one
+            if let Some(last_msg) = self.last_message.get(id) {
+                if last_msg == message {
+                    return;
+                }
+            }
+        }
+
+        // Perform the update with context and elapsed time
+        let formatted = self.format_message(message);
+
+        if let Some(spinner) = self.bars.get(id) {
+            spinner.set_message(formatted);
+        } else {
+            // Create new spinner if doesn't exist
+            self.add_spinner(id, message);
+        }
+
+        // Track update time and message
+        self.last_update.insert(id.to_string(), now);
+        self.last_message
+            .insert(id.to_string(), message.to_string());
+    }
+
+    /// Mark a layer/step as complete
+    pub fn finish(&mut self, id: &str, message: &str) {
+        if let Some(bar) = self.bars.get(id) {
+            bar.finish_with_message(message.to_string());
+        }
+    }
+
+    /// Mark all progress as complete
+    pub fn finish_all(&self, message: &str) {
+        for bar in self.bars.values() {
+            bar.finish_with_message(message.to_string());
+        }
+    }
+
+    /// Mark all progress as failed
+    pub fn abandon_all(&self, message: &str) {
+        for bar in self.bars.values() {
+            bar.abandon_with_message(message.to_string());
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn progress_reporter_creation() {
+        let reporter = ProgressReporter::new();
+        assert!(reporter.bars.is_empty());
+    }
+
+    #[test]
+    fn progress_reporter_default() {
+        let reporter = ProgressReporter::default();
+        assert!(reporter.bars.is_empty());
+    }
+
+    #[test]
+    fn add_spinner_creates_entry() {
+        let mut reporter = ProgressReporter::new();
+        reporter.add_spinner("test", "Testing...");
+        assert!(reporter.bars.contains_key("test"));
+    }
+
+    #[test]
+    fn add_bar_creates_entry() {
+        let mut reporter = ProgressReporter::new();
+        reporter.add_bar("layer1", 1000);
+        assert!(reporter.bars.contains_key("layer1"));
+    }
+
+    #[test]
+    fn update_layer_creates_if_missing() {
+        let mut reporter = ProgressReporter::new();
+        reporter.update_layer("layer1", 500, 1000, "Downloading");
+        assert!(reporter.bars.contains_key("layer1"));
+    }
+
+    #[test]
+    fn update_spinner_creates_if_missing() {
+        let mut reporter = ProgressReporter::new();
+        reporter.update_spinner("step1", "Building...");
+        assert!(reporter.bars.contains_key("step1"));
+    }
+
+    #[test]
+    fn finish_handles_missing_id() {
+        let mut reporter = ProgressReporter::new();
+        // Should not panic on missing id
+        reporter.finish("nonexistent", "Done");
+    }
+
+    #[test]
+    fn finish_all_handles_empty() {
+        let reporter = ProgressReporter::new();
+        // Should not panic on empty
+        reporter.finish_all("Done");
+    }
+
+    #[test]
+    fn abandon_all_handles_empty() {
+        let reporter = ProgressReporter::new();
+        // Should not panic on empty
+        reporter.abandon_all("Failed");
+    }
+
+    #[test]
+    fn format_elapsed_shows_seconds_only() {
+        let duration = Duration::from_secs(45);
+        assert_eq!(format_elapsed(duration), "00:45");
+    }
+
+    #[test]
+    fn format_elapsed_shows_minutes_and_seconds() {
+        let duration = Duration::from_secs(90); // 1m 30s
+        assert_eq!(format_elapsed(duration), "01:30");
+    }
+
+    #[test]
+    fn format_elapsed_shows_hours_when_needed() {
+        let duration = Duration::from_secs(3661); // 1h 1m 1s
+        assert_eq!(format_elapsed(duration), "01:01:01");
+    }
+
+    #[test]
+    fn format_elapsed_zero() {
+        let duration = Duration::from_secs(0);
+        assert_eq!(format_elapsed(duration), "00:00");
+    }
+
+    #[test]
+    fn with_context_sets_context() {
+        let reporter = ProgressReporter::with_context("Building Docker image");
+        assert!(reporter.context.is_some());
+        assert_eq!(reporter.context.unwrap(), "Building Docker image");
+    }
+
+    #[test]
+    fn format_message_includes_context_for_steps() {
+        let reporter = ProgressReporter::with_context("Building Docker image");
+        let msg = reporter.format_message("Step 1/10 : FROM ubuntu");
+        // Format: [elapsed] Context · message
+        assert!(msg.contains("Building Docker image · Step 1/10"));
+        assert!(msg.starts_with("[00:00]"));
+    }
+
+    #[test]
+    fn format_message_includes_context_for_all_messages() {
+        let reporter = ProgressReporter::with_context("Building Docker image");
+        let msg = reporter.format_message("Compiling foo v1.0");
+        // Format: [elapsed] Context · message
+        assert!(msg.contains("Building Docker image · Compiling foo"));
+        assert!(msg.starts_with("[00:00]"));
+    }
+
+    #[test]
+    fn format_message_without_context() {
+        let reporter = ProgressReporter::new();
+        let msg = reporter.format_message("Step 1/10 : FROM ubuntu");
+        // Format: [elapsed] message (no context, no dot)
+        assert!(msg.contains("Step 1/10"));
+        assert!(msg.starts_with("[00:00]"));
+        assert!(!msg.contains("·"));
+    }
+
+    #[test]
+    fn format_message_collapses_whitespace() {
+        let reporter = ProgressReporter::new();
+        // All whitespace (including newlines) collapsed to single spaces for spinner display
+        let msg = reporter.format_message("Compiling foo\n     Compiling bar\n");
+        assert!(!msg.contains('\n'));
+        assert!(msg.contains("Compiling foo Compiling bar"));
+    }
+
+    #[test]
+    fn strip_ansi_codes_removes_color_codes() {
+        // Red text: \x1b[31m ... \x1b[0m
+        let input = "\x1b[31mError:\x1b[0m something failed";
+        let result = strip_ansi_codes(input);
+        assert_eq!(result, "Error: something failed");
+    }
+
+    #[test]
+    fn strip_ansi_codes_handles_plain_text() {
+        let input = "Just plain text";
+        let result = strip_ansi_codes(input);
+        assert_eq!(result, "Just plain text");
+    }
+
+    #[test]
+    fn strip_ansi_codes_handles_multiple_codes() {
+        // Bold green: \x1b[1;32m
+        let input = "\x1b[1;32mSuccess\x1b[0m and \x1b[33mwarning\x1b[0m";
+        let result = strip_ansi_codes(input);
+        assert_eq!(result, "Success and warning");
+    }
+
+    #[test]
+    fn format_message_strips_ansi_codes() {
+        let reporter = ProgressReporter::new();
+        let msg = reporter.format_message("\x1b[31mCompiling\x1b[0m foo");
+        assert!(msg.contains("Compiling foo"));
+        assert!(!msg.contains("\x1b"));
+    }
+}

package/src/docker/volume.rs

@@ -0,0 +1,144 @@
+//! Docker volume management
+//!
+//! This module provides functions to create and manage Docker volumes
+//! for persistent storage across container restarts.
+
+use super::{DockerClient, DockerError};
+use bollard::volume::CreateVolumeOptions;
+use std::collections::HashMap;
+use tracing::debug;
+
+/// Volume name for opencode session history
+pub const VOLUME_SESSION: &str = "opencode-cloud-session";
+
+/// Volume name for project files
+pub const VOLUME_PROJECTS: &str = "opencode-cloud-projects";
+
+/// Volume name for opencode configuration
+pub const VOLUME_CONFIG: &str = "opencode-cloud-config";
+
+/// All volume names as array for iteration
+pub const VOLUME_NAMES: [&str; 3] = [VOLUME_SESSION, VOLUME_PROJECTS, VOLUME_CONFIG];
+
+/// Mount point for session history inside container
+pub const MOUNT_SESSION: &str = "/home/opencode/.opencode";
+
+/// Mount point for project files inside container
+pub const MOUNT_PROJECTS: &str = "/workspace";
+
+/// Mount point for configuration inside container
+pub const MOUNT_CONFIG: &str = "/home/opencode/.config";
+
+/// Ensure all required volumes exist
+///
+/// Creates volumes if they don't exist. This operation is idempotent -
+/// calling it multiple times has no additional effect.
+pub async fn ensure_volumes_exist(client: &DockerClient) -> Result<(), DockerError> {
+    debug!("Ensuring all required volumes exist");
+
+    for volume_name in VOLUME_NAMES {
+        ensure_volume_exists(client, volume_name).await?;
+    }
+
+    debug!("All volumes verified/created");
+    Ok(())
+}
+
+/// Ensure a specific volume exists
+async fn ensure_volume_exists(client: &DockerClient, name: &str) -> Result<(), DockerError> {
+    debug!("Checking volume: {}", name);
+
+    // Create volume options with default local driver
+    let options = CreateVolumeOptions {
+        name,
+        driver: "local",
+        driver_opts: HashMap::new(),
+        labels: HashMap::from([("managed-by", "opencode-cloud")]),
+    };
+
+    // create_volume is idempotent - returns existing volume if it exists
+    client
+        .inner()
+        .create_volume(options)
+        .await
+        .map_err(|e| DockerError::Volume(format!("Failed to create volume {name}: {e}")))?;
+
+    debug!("Volume {} ready", name);
+    Ok(())
+}
+
+/// Check if a specific volume exists
+pub async fn volume_exists(client: &DockerClient, name: &str) -> Result<bool, DockerError> {
+    debug!("Checking if volume exists: {}", name);
+
+    match client.inner().inspect_volume(name).await {
+        Ok(_) => Ok(true),
+        Err(bollard::errors::Error::DockerResponseServerError {
+            status_code: 404, ..
+        }) => Ok(false),
+        Err(e) => Err(DockerError::Volume(format!(
+            "Failed to inspect volume {name}: {e}"
+        ))),
+    }
+}
+
+/// Remove a volume
+///
+/// Returns error if volume is in use by a container.
+/// Use force_remove_volume for cleanup during uninstall.
+pub async fn remove_volume(client: &DockerClient, name: &str) -> Result<(), DockerError> {
+    debug!("Removing volume: {}", name);
+
+    client
+        .inner()
+        .remove_volume(name, None)
+        .await
+        .map_err(|e| DockerError::Volume(format!("Failed to remove volume {name}: {e}")))?;
+
+    debug!("Volume {} removed", name);
+    Ok(())
+}
+
+/// Remove all opencode-cloud volumes
+///
+/// Used during uninstall. Fails if any volume is in use.
+pub async fn remove_all_volumes(client: &DockerClient) -> Result<(), DockerError> {
+    debug!("Removing all opencode-cloud volumes");
+
+    for volume_name in VOLUME_NAMES {
+        // Check if volume exists before trying to remove
+        if volume_exists(client, volume_name).await? {
+            remove_volume(client, volume_name).await?;
+        }
+    }
+
+    debug!("All volumes removed");
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn volume_constants_are_correct() {
+        assert_eq!(VOLUME_SESSION, "opencode-cloud-session");
+        assert_eq!(VOLUME_PROJECTS, "opencode-cloud-projects");
+        assert_eq!(VOLUME_CONFIG, "opencode-cloud-config");
+    }
+
+    #[test]
+    fn volume_names_array_has_all_volumes() {
+        assert_eq!(VOLUME_NAMES.len(), 3);
+        assert!(VOLUME_NAMES.contains(&VOLUME_SESSION));
+        assert!(VOLUME_NAMES.contains(&VOLUME_PROJECTS));
+        assert!(VOLUME_NAMES.contains(&VOLUME_CONFIG));
+    }
+
+    #[test]
+    fn mount_points_are_correct() {
+        assert_eq!(MOUNT_SESSION, "/home/opencode/.opencode");
+        assert_eq!(MOUNT_PROJECTS, "/workspace");
+        assert_eq!(MOUNT_CONFIG, "/home/opencode/.config");
+    }
+}

package/src/lib.rs

@@ -4,6 +4,8 @@
 //! and Node.js bindings via NAPI-RS.
 
 pub mod config;
+pub mod docker;
+pub mod platform;
 pub mod singleton;
 pub mod version;
 
@@ -16,6 +18,18 @@ pub use config::{Config, load_config, save_config};
 // Re-export singleton types
 pub use singleton::{InstanceLock, SingletonError};
 
+// Re-export docker types
+pub use docker::{CONTAINER_NAME, DockerClient, DockerError, OPENCODE_WEB_PORT};
+
+// Re-export platform types
+pub use platform::{
+    InstallResult, ServiceConfig, ServiceManager, get_service_manager,
+    is_service_registration_supported,
+};
+
+// Re-export bollard to ensure all crates use the same version
+pub use bollard;
+
 // NAPI bindings for Node.js consumers (only when napi feature is enabled)
 #[cfg(feature = "napi")]
 use napi_derive::napi;