@opencode-cloud/core 3.0.15 → 3.1.3

package/src/docker/progress.rs

@@ -40,20 +40,6 @@ fn strip_ansi_codes(s: &str) -> String {
     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!("{hours:02}:{minutes:02}:{seconds:02}")
-    } else {
-        format!("{minutes:02}:{seconds:02}")
-    }
-}
-
 /// Progress reporter for Docker operations
 ///
 /// Manages multiple progress bars for concurrent operations like
@@ -61,11 +47,12 @@ fn format_elapsed(duration: Duration) -> String {
 pub struct ProgressReporter {
     multi: MultiProgress,
     bars: HashMap<String, ProgressBar>,
-    last_update: HashMap<String, Instant>,
-    last_message: HashMap<String, String>,
-    start_time: Instant,
+    last_update_by_id: HashMap<String, Instant>,
+    last_message_by_id: HashMap<String, String>,
     /// Optional context prefix shown before step messages (e.g., "Building Docker image")
     context: Option<String>,
+    /// When true, print build output lines directly instead of spinners
+    plain_output: bool,
 }
 
 impl Default for ProgressReporter {
@@ -80,10 +67,10 @@ impl ProgressReporter {
         Self {
             multi: MultiProgress::new(),
             bars: HashMap::new(),
-            last_update: HashMap::new(),
-            last_message: HashMap::new(),
-            start_time: Instant::now(),
+            last_update_by_id: HashMap::new(),
+            last_message_by_id: HashMap::new(),
             context: None,
+            plain_output: false,
         }
     }
 
@@ -94,17 +81,32 @@ impl ProgressReporter {
         Self {
             multi: MultiProgress::new(),
             bars: HashMap::new(),
-            last_update: HashMap::new(),
-            last_message: HashMap::new(),
-            start_time: Instant::now(),
+            last_update_by_id: HashMap::new(),
+            last_message_by_id: HashMap::new(),
             context: Some(context.to_string()),
+            plain_output: false,
         }
     }
 
+    /// Create a progress reporter that prints build output directly
+    pub fn with_context_plain(context: &str) -> Self {
+        Self {
+            multi: MultiProgress::new(),
+            bars: HashMap::new(),
+            last_update_by_id: HashMap::new(),
+            last_message_by_id: HashMap::new(),
+            context: Some(context.to_string()),
+            plain_output: true,
+        }
+    }
+
+    /// Check if plain output mode is enabled
+    pub fn is_plain_output(&self) -> bool {
+        self.plain_output
+    }
+
     /// 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);
 
@@ -113,20 +115,25 @@ impl ProgressReporter {
         // - 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
+        // Format: "Context · message" or "message"
         match &self.context {
-            Some(ctx) => format!("[{elapsed}] {ctx} · {clean_msg}"),
-            None => format!("[{elapsed}] {clean_msg}"),
+            Some(ctx) => format!("{ctx} · {clean_msg}"),
+            None => clean_msg,
         }
     }
 
     /// Create a spinner for indeterminate progress (e.g., build steps)
     pub fn add_spinner(&mut self, id: &str, message: &str) -> &ProgressBar {
+        if self.plain_output {
+            let spinner = ProgressBar::hidden();
+            self.bars.insert(id.to_string(), spinner);
+            return self.bars.get(id).expect("just inserted");
+        }
+
         let spinner = self.multi.add(ProgressBar::new_spinner());
         spinner.set_style(
             ProgressStyle::default_spinner()
-                .template("{spinner:.green} {msg}")
+                .template("{spinner:.green} [{elapsed}] {msg}")
                 .expect("valid template")
                 .tick_chars("⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"),
         );
@@ -140,6 +147,12 @@ impl ProgressReporter {
     ///
     /// `total` is in bytes
     pub fn add_bar(&mut self, id: &str, total: u64) -> &ProgressBar {
+        if self.plain_output {
+            let bar = ProgressBar::hidden();
+            self.bars.insert(id.to_string(), bar);
+            return self.bars.get(id).expect("just inserted");
+        }
+
         let bar = self.multi.add(ProgressBar::new(total));
         bar.set_style(
             ProgressStyle::default_bar()
@@ -158,6 +171,10 @@ impl ProgressReporter {
     ///
     /// `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 self.plain_output {
+            return;
+        }
+
         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 {
@@ -178,19 +195,29 @@ impl ProgressReporter {
     /// 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) {
+        if self.plain_output {
+            let clean = strip_ansi_codes(message);
+            let formatted = match &self.context {
+                Some(ctx) => format!("{ctx} · {clean}"),
+                None => clean,
+            };
+            eprintln!("{formatted}");
+            return;
+        }
+
         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 let Some(last) = self.last_update_by_id.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 let Some(last_msg) = self.last_message_by_id.get(id) {
                 if last_msg == message {
                     return;
                 }
@@ -208,8 +235,8 @@ impl ProgressReporter {
         }
 
         // Track update time and message
-        self.last_update.insert(id.to_string(), now);
-        self.last_message
+        self.last_update_by_id.insert(id.to_string(), now);
+        self.last_message_by_id
             .insert(id.to_string(), message.to_string());
     }
 
@@ -300,30 +327,6 @@ mod tests {
         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");
@@ -335,27 +338,24 @@ mod tests {
     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]"));
+        // Format: Context · message
+        assert!(msg.starts_with("Building Docker image · Step 1/10"));
     }
 
     #[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]"));
+        // Format: Context · message
+        assert!(msg.starts_with("Building Docker image · Compiling foo"));
     }
 
     #[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]"));
+        // Format: message (no context, no dot)
+        assert!(msg.starts_with("Step 1/10"));
         assert!(!msg.contains("·"));
     }