Upgrade bollard from 0.18 to 0.20.1 (#17)

Breaking API changes in bollard 0.20:
- Move options structs to query_parameters module (CreateContainerOptions,
  StartContainerOptions, StopContainerOptions, RemoveContainerOptions,
  LogsOptions, BuildImageOptions, CreateImageOptions, TagImageOptions,
  CreateVolumeOptions, RemoveVolumeOptions, PruneContainersOptions,
  PruneImagesOptions, PruneNetworksOptions, DataUsageOptions)
- Replace container Config with ContainerCreateBody (models module)
- Replace CreateVolumeOptions with VolumeCreateRequest (models module)
- Change exposed_ports from HashMap to Vec<String>
- Add required platform/target fields to BuildImageOptions
- Change t field from i64 to Option<i32> in StopContainerOptions
- Add signal field to StopContainerOptions
- Remove generics from StartContainerOptions and LogsOptions
- Change build_image body to Either<Full<Bytes>, StreamBody<...>>
- Change BuildInfo.error to error_detail.message (nested Option)
- Change CreateImageInfo.error to error_detail.message
- Update SystemDataUsageResponse with new *DiskUsage sub-structs
- Remove generics from prune_* methods
- Add required argument to df() method

Closes #15

https://claude.ai/code/session_01HC3UStk1vUaD7rjrsJ3vUA

Co-authored-by: Claude <noreply@anthropic.com>

Author: pRizz

Cargo.lock

@@ -19,7 +19,7 @@ categories = ["command-line-utilities", "development-tools"]
 [workspace.dependencies]
 opencode-cloud-core = { version = "12.0.2", path = "packages/core" }
 clap = { version = "4.5", features = ["derive"] }
-tokio = { version = "1.43", features = ["rt-multi-thread", "macros", "signal"] }
+tokio = { version = "1.43", features = ["rt-multi-thread", "macros", "signal", "io-std", "io-util"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 jsonc-parser = { version = "0.29", features = ["serde"] }
@@ -34,7 +34,7 @@ napi-derive = "2"
 tempfile = "3"
 
 # Docker integration
-bollard = { version = "0.18", features = ["chrono", "buildkit"] }
+bollard = { version = "0.20.1", features = ["chrono", "buildkit"] }
 futures-util = "0.3"
 tar = "0.4"
 flate2 = "1.0"

Cargo.toml

@@ -68,9 +68,10 @@ pub fn format_host_disk_report(
 }
 
 pub async fn get_disk_usage_report(client: &DockerClient) -> Result<DiskUsageReport> {
+    use opencode_cloud_core::bollard::query_parameters::DataUsageOptions;
     let data_usage = client
         .inner()
-        .df()
+        .df(None::<DataUsageOptions>)
         .await
         .map_err(|e| anyhow!("Failed to read Docker disk usage: {e}"))?;
     Ok(build_disk_usage_report(&data_usage))
@@ -92,22 +93,23 @@ pub fn format_bytes_i64(value: i64) -> String {
 }
 
 fn build_disk_usage_report(data_usage: &SystemDataUsageResponse) -> DiskUsageReport {
-    let images = data_usage.layers_size;
+    // Bollard v0.20+ uses new disk usage structures
+    let images = data_usage
+        .images_disk_usage
+        .as_ref()
+        .and_then(|u| u.total_size);
     let containers = data_usage
-        .containers
+        .containers_disk_usage
+        .as_ref()
+        .and_then(|u| u.total_size);
+    let volumes = data_usage
+        .volumes_disk_usage
         .as_ref()
-        .and_then(|containers| sum_optional_sizes(containers.iter().map(|c| c.size_rw)));
-    let volumes = data_usage.volumes.as_ref().and_then(|volumes| {
-        sum_optional_sizes(
-            volumes
-                .iter()
-                .map(|v| v.usage_data.as_ref().map(|u| u.size)),
-        )
-    });
+        .and_then(|u| u.total_size);
     let build_cache = data_usage
-        .build_cache
+        .build_cache_disk_usage
         .as_ref()
-        .and_then(|cache| sum_optional_sizes(cache.iter().map(|entry| entry.size)));
+        .and_then(|u| u.total_size);
 
     let total = match (images, containers, volumes, build_cache) {
         (Some(images), Some(containers), Some(volumes), Some(build_cache)) => {
@@ -143,25 +145,6 @@ fn build_host_disk_report(disks: &Disks) -> Option<HostDiskReport> {
     })
 }
 
-fn sum_optional_sizes<T>(values: T) -> Option<i64>
-where
-    T: Iterator<Item = Option<i64>>,
-{
-    let mut total = 0i64;
-    let mut any = false;
-    for value in values {
-        let Some(value) = value else {
-            continue;
-        };
-        if value < 0 {
-            continue;
-        }
-        total += value;
-        any = true;
-    }
-    if any { Some(total) } else { None }
-}
-
 fn format_delta_i64(after: Option<i64>, before: Option<i64>) -> Option<String> {
     let (after, before) = (after?, before?);
     let delta = after - before;

packages/cli-rust/src/commands/disk_usage.rs

@@ -7,7 +7,8 @@ use anyhow::{Result, anyhow};
 use clap::Args;
 use console::style;
 use futures_util::StreamExt;
-use opencode_cloud_core::bollard::container::{LogOutput, LogsOptions};
+use opencode_cloud_core::bollard::container::LogOutput;
+use opencode_cloud_core::bollard::query_parameters::LogsOptions;
 use opencode_cloud_core::docker::{CONTAINER_NAME, container_is_running};
 
 /// Arguments for the logs command
@@ -82,7 +83,7 @@ pub async fn cmd_logs(args: &LogsArgs, maybe_host: Option<&str>, quiet: bool) ->
     }
 
     // Create log options
-    let options = LogsOptions::<String> {
+    let options = LogsOptions {
         stdout: true,
         stderr: true,
         follow,

packages/cli-rust/src/commands/logs.rs

@@ -13,7 +13,8 @@ use anyhow::{Result, anyhow};
 use clap::Args;
 use console::style;
 use futures_util::stream::StreamExt;
-use opencode_cloud_core::bollard::container::{LogOutput, LogsOptions};
+use opencode_cloud_core::bollard::container::LogOutput;
+use opencode_cloud_core::bollard::query_parameters::LogsOptions;
 use opencode_cloud_core::config::save_config;
 use opencode_cloud_core::docker::{
     CONTAINER_NAME, DEFAULT_STOP_TIMEOUT_SECS, DockerClient, DockerError, IMAGE_NAME_GHCR,
@@ -1230,7 +1231,7 @@ const FATAL_ERROR_PATTERNS: &[&str] = &[
 
 /// Check container logs for fatal errors that indicate the service cannot start
 async fn check_for_fatal_errors(client: &DockerClient) -> Option<String> {
-    let options = LogsOptions::<String> {
+    let options = LogsOptions {
         stdout: true,
         stderr: true,
         tail: "20".to_string(),
@@ -1368,7 +1369,7 @@ pub(crate) async fn wait_for_broker_ready(
 
 /// Show recent container logs for debugging
 async fn show_recent_logs(client: &DockerClient, lines: usize) {
-    let options = LogsOptions::<String> {
+    let options = LogsOptions {
         stdout: true,
         stderr: true,
         tail: lines.to_string(),

packages/cli-rust/src/commands/start.rs

@@ -1246,19 +1246,23 @@ async fn purge_unused_docker_resources(client: &DockerClient, quiet: bool) -> Re
     let mut reclaimed = 0i64;
     let mut has_reclaimed = false;
 
+    use opencode_cloud_core::bollard::query_parameters::PruneContainersOptions;
     let container_prune = client
         .inner()
-        .prune_containers::<String>(None)
+        .prune_containers(None::<PruneContainersOptions>)
         .await
         .map_err(|e| anyhow!("Failed to prune containers: {e}"))?;
     if let Some(value) = container_prune.space_reclaimed {
         reclaimed += value;
         has_reclaimed = true;
     }
 
+    use opencode_cloud_core::bollard::query_parameters::{
+        PruneImagesOptions, PruneNetworksOptions,
+    };
     let image_prune = client
         .inner()
-        .prune_images::<String>(None)
+        .prune_images(None::<PruneImagesOptions>)
         .await
         .map_err(|e| anyhow!("Failed to prune images: {e}"))?;
     if let Some(value) = image_prune.space_reclaimed {
@@ -1268,7 +1272,7 @@ async fn purge_unused_docker_resources(client: &DockerClient, quiet: bool) -> Re
 
     client
         .inner()
-        .prune_networks::<String>(None)
+        .prune_networks(None::<PruneNetworksOptions>)
         .await
         .map_err(|e| anyhow!("Failed to prune networks: {e}"))?;
 

packages/cli-rust/src/commands/update.rs

@@ -39,7 +39,7 @@ napi = { version = "2", features = ["tokio_rt", "napi9"], optional = true }
 napi-derive = { version = "2", optional = true }
 
 # Docker integration
-bollard = { version = "0.18", features = ["chrono", "buildkit"] }
+bollard = { version = "0.20.1", features = ["chrono", "buildkit"] }
 futures-util = "0.3"
 tar = "0.4"
 flate2 = "1.0"

packages/core/Cargo.toml

@@ -10,9 +10,9 @@ use super::volume::{
     VOLUME_CACHE, VOLUME_CONFIG, VOLUME_PROJECTS, VOLUME_SESSION, VOLUME_STATE, VOLUME_USERS,
 };
 use super::{DockerClient, DockerError};
-use bollard::container::{
-    Config, CreateContainerOptions, RemoveContainerOptions, StartContainerOptions,
-    StopContainerOptions,
+use bollard::models::ContainerCreateBody;
+use bollard::query_parameters::{
+    CreateContainerOptions, RemoveContainerOptions, StartContainerOptions, StopContainerOptions,
 };
 use bollard::service::{
     HostConfig, Mount, MountPointTypeEnum, MountTypeEnum, PortBinding, PortMap,
@@ -155,11 +155,10 @@ pub async fn create_container(
         );
     }
 
-    // Create exposed ports map
-    let mut exposed_ports = HashMap::new();
-    exposed_ports.insert("3000/tcp".to_string(), HashMap::new());
+    // Create exposed ports list (bollard v0.20+ uses Vec<String>)
+    let mut exposed_ports = vec!["3000/tcp".to_string()];
     if cockpit_enabled_val {
-        exposed_ports.insert("9090/tcp".to_string(), HashMap::new());
+        exposed_ports.push("9090/tcp".to_string());
     }
 
     // Create host config
@@ -224,8 +223,8 @@ pub async fn create_container(
     }
     let final_env = if env.is_empty() { None } else { Some(env) };
 
-    // Create container config
-    let config = Config {
+    // Create container config (bollard v0.20+ uses ContainerCreateBody)
+    let config = ContainerCreateBody {
         image: Some(image_name.to_string()),
         hostname: Some(CONTAINER_NAME.to_string()),
         working_dir: Some("/home/opencode/workspace".to_string()),
@@ -237,8 +236,8 @@ pub async fn create_container(
 
     // Create container
     let options = CreateContainerOptions {
-        name: container_name,
-        platform: None,
+        name: Some(container_name.to_string()),
+        platform: String::new(),
     };
 
     let response = client
@@ -266,7 +265,7 @@ pub async fn start_container(client: &DockerClient, name: &str) -> Result<(), Do
 
     client
         .inner()
-        .start_container(name, None::<StartContainerOptions<String>>)
+        .start_container(name, None::<StartContainerOptions>)
         .await
         .map_err(|e| DockerError::Container(format!("Failed to start container {name}: {e}")))?;
 
@@ -285,10 +284,13 @@ pub async fn stop_container(
     name: &str,
     timeout_secs: Option<i64>,
 ) -> Result<(), DockerError> {
-    let timeout = timeout_secs.unwrap_or(10);
+    let timeout = timeout_secs.unwrap_or(10) as i32;
     debug!("Stopping container {} with {}s timeout", name, timeout);
 
-    let options = StopContainerOptions { t: timeout };
+    let options = StopContainerOptions {
+        signal: None,
+        t: Some(timeout),
+    };
 
     client
         .inner()

packages/core/src/docker/container.rs

@@ -7,13 +7,14 @@ use super::progress::ProgressReporter;
 use super::{
     DOCKERFILE, DockerClient, DockerError, IMAGE_NAME_DOCKERHUB, IMAGE_NAME_GHCR, IMAGE_TAG_DEFAULT,
 };
-use bollard::image::{BuildImageOptions, BuilderVersion, CreateImageOptions};
 use bollard::moby::buildkit::v1::StatusResponse as BuildkitStatusResponse;
 use bollard::models::BuildInfoAux;
+use bollard::query_parameters::{BuildImageOptions, BuilderVersion, CreateImageOptions};
 use bytes::Bytes;
 use flate2::Compression;
 use flate2::write::GzEncoder;
 use futures_util::StreamExt;
+use http_body_util::{Either, Full};
 use std::collections::{HashMap, VecDeque};
 use std::env;
 use std::time::{SystemTime, UNIX_EPOCH};
@@ -103,18 +104,20 @@ pub async fn build_image(
     );
     let build_args = build_args.unwrap_or_default();
     let options = BuildImageOptions {
-        t: full_name.clone(),
+        t: Some(full_name.clone()),
         dockerfile: "Dockerfile".to_string(),
         version: BuilderVersion::BuilderBuildKit,
         session: Some(session_id),
         rm: true,
         nocache: no_cache,
-        buildargs: build_args,
+        buildargs: Some(build_args),
+        platform: String::new(),
+        target: String::new(),
         ..Default::default()
     };
 
     // Create build body from context
-    let body = Bytes::from(context);
+    let body: Either<Full<Bytes>, _> = Either::Left(Full::new(Bytes::from(context)));
 
     // Start build with streaming output
     let mut stream = client.inner().build_image(options, None, Some(body));
@@ -137,10 +140,12 @@ pub async fn build_image(
 
         handle_stream_message(&info, progress, &mut log_state);
 
-        if let Some(error_msg) = info.error {
-            progress.abandon_all(&error_msg);
+        if let Some(error_detail) = &info.error_detail
+            && let Some(error_msg) = &error_detail.message
+        {
+            progress.abandon_all(error_msg);
             let context = format_build_error_with_context(
-                &error_msg,
+                error_msg,
                 &log_state.recent_logs,
                 &log_state.error_logs,
                 &log_state.recent_buildkit_logs,
@@ -620,8 +625,9 @@ async fn do_pull(
     let full_name = format!("{image}:{tag}");
 
     let options = CreateImageOptions {
-        from_image: image,
-        tag,
+        from_image: Some(image.to_string()),
+        tag: Some(tag.to_string()),
+        platform: String::new(),
         ..Default::default()
     };
 
@@ -634,9 +640,11 @@ async fn do_pull(
         match result {
             Ok(info) => {
                 // Handle errors from the stream
-                if let Some(error_msg) = info.error {
-                    progress.abandon_all(&error_msg);
-                    return Err(DockerError::Pull(error_msg));
+                if let Some(error_detail) = &info.error_detail
+                    && let Some(error_msg) = &error_detail.message
+                {
+                    progress.abandon_all(error_msg);
+                    return Err(DockerError::Pull(error_msg.to_string()));
                 }
 
                 // Handle layer progress

packages/core/src/docker/image.rs

@@ -6,7 +6,7 @@
 use super::image::{image_exists, pull_image};
 use super::progress::ProgressReporter;
 use super::{DockerClient, DockerError, IMAGE_NAME_GHCR, IMAGE_TAG_DEFAULT};
-use bollard::image::TagImageOptions;
+use bollard::query_parameters::TagImageOptions;
 use tracing::debug;
 
 /// Tag for the previous image version (used for rollback)
@@ -45,8 +45,8 @@ pub async fn tag_current_as_previous(client: &DockerClient) -> Result<(), Docker
 
     // Tag current as previous
     let options = TagImageOptions {
-        repo: IMAGE_NAME_GHCR,
-        tag: PREVIOUS_TAG,
+        repo: Some(IMAGE_NAME_GHCR.to_string()),
+        tag: Some(PREVIOUS_TAG.to_string()),
     };
 
     client
@@ -124,8 +124,8 @@ pub async fn rollback_image(client: &DockerClient) -> Result<(), DockerError> {
 
     // Re-tag previous as latest
     let options = TagImageOptions {
-        repo: IMAGE_NAME_GHCR,
-        tag: IMAGE_TAG_DEFAULT,
+        repo: Some(IMAGE_NAME_GHCR.to_string()),
+        tag: Some(IMAGE_TAG_DEFAULT.to_string()),
     };
 
     client