1use std::{collections::HashMap, path::PathBuf};
   2
   3use async_trait::async_trait;
   4use serde::{Deserialize, Deserializer, Serialize, de};
   5use util::command::Command;
   6
   7use crate::{
   8    command_json::evaluate_json_command, devcontainer_api::DevContainerError,
   9    devcontainer_json::MountDefinition,
  10};
  11
  12#[derive(Debug, Deserialize, Serialize, Eq, PartialEq)]
  13#[serde(rename_all = "PascalCase")]
  14pub(crate) struct DockerPs {
  15    #[serde(alias = "ID")]
  16    pub(crate) id: String,
  17}
  18
  19#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)]
  20#[serde(rename_all = "PascalCase")]
  21pub(crate) struct DockerState {
  22    pub(crate) running: bool,
  23}
  24
  25#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)]
  26#[serde(rename_all = "PascalCase")]
  27pub(crate) struct DockerInspect {
  28    pub(crate) id: String,
  29    pub(crate) config: DockerInspectConfig,
  30    pub(crate) mounts: Option<Vec<DockerInspectMount>>,
  31    pub(crate) state: Option<DockerState>,
  32}
  33
  34#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq, Default)]
  35pub(crate) struct DockerConfigLabels {
  36    #[serde(
  37        default,
  38        rename = "devcontainer.metadata",
  39        deserialize_with = "deserialize_metadata"
  40    )]
  41    pub(crate) metadata: Option<Vec<HashMap<String, serde_json_lenient::Value>>>,
  42}
  43
  44#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)]
  45#[serde(rename_all = "PascalCase")]
  46pub(crate) struct DockerInspectConfig {
  47    #[serde(default, deserialize_with = "deserialize_nullable_labels")]
  48    pub(crate) labels: DockerConfigLabels,
  49    #[serde(rename = "User")]
  50    pub(crate) image_user: Option<String>,
  51    #[serde(default)]
  52    pub(crate) env: Vec<String>,
  53}
  54
  55impl DockerInspectConfig {
  56    pub(crate) fn env_as_map(&self) -> Result<HashMap<String, String>, DevContainerError> {
  57        let mut map = HashMap::new();
  58        for env_var in &self.env {
  59            let Some((key, value)) = env_var.split_once('=') else {
  60                log::error!("Unable to parse {env_var} into an environment key-value");
  61                return Err(DevContainerError::DevContainerParseFailed);
  62            };
  63            map.insert(key.to_string(), value.to_string());
  64        }
  65        Ok(map)
  66    }
  67}
  68
  69#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)]
  70#[serde(rename_all = "PascalCase")]
  71pub(crate) struct DockerInspectMount {
  72    pub(crate) source: String,
  73    pub(crate) destination: String,
  74}
  75
  76#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq, Default)]
  77pub(crate) struct DockerComposeServiceBuild {
  78    #[serde(skip_serializing_if = "Option::is_none")]
  79    pub(crate) context: Option<String>,
  80    #[serde(skip_serializing_if = "Option::is_none")]
  81    pub(crate) dockerfile: Option<String>,
  82    #[serde(skip_serializing_if = "Option::is_none")]
  83    pub(crate) target: Option<String>,
  84    #[serde(skip_serializing_if = "Option::is_none")]
  85    pub(crate) args: Option<HashMap<String, String>>,
  86    #[serde(skip_serializing_if = "Option::is_none")]
  87    pub(crate) additional_contexts: Option<HashMap<String, String>>,
  88}
  89
  90#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq, Default)]
  91pub(crate) struct DockerComposeServicePort {
  92    #[serde(deserialize_with = "deserialize_string_or_int")]
  93    pub(crate) target: String,
  94    #[serde(deserialize_with = "deserialize_string_or_int")]
  95    pub(crate) published: String,
  96    #[serde(skip_serializing_if = "Option::is_none")]
  97    pub(crate) mode: Option<String>,
  98    #[serde(skip_serializing_if = "Option::is_none")]
  99    pub(crate) protocol: Option<String>,
 100    #[serde(skip_serializing_if = "Option::is_none")]
 101    pub(crate) host_ip: Option<String>,
 102    #[serde(skip_serializing_if = "Option::is_none")]
 103    pub(crate) app_protocol: Option<String>,
 104    #[serde(skip_serializing_if = "Option::is_none")]
 105    pub(crate) name: Option<String>,
 106}
 107
 108fn deserialize_string_or_int<'de, D>(deserializer: D) -> Result<String, D::Error>
 109where
 110    D: serde::Deserializer<'de>,
 111{
 112    use serde::Deserialize;
 113
 114    #[derive(Deserialize)]
 115    #[serde(untagged)]
 116    enum StringOrInt {
 117        String(String),
 118        Int(u32),
 119    }
 120
 121    match StringOrInt::deserialize(deserializer)? {
 122        StringOrInt::String(s) => Ok(s),
 123        StringOrInt::Int(b) => Ok(b.to_string()),
 124    }
 125}
 126
 127#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq, Default)]
 128pub(crate) struct DockerComposeService {
 129    pub(crate) image: Option<String>,
 130    #[serde(skip_serializing_if = "Option::is_none")]
 131    pub(crate) entrypoint: Option<Vec<String>>,
 132    #[serde(skip_serializing_if = "Option::is_none")]
 133    pub(crate) cap_add: Option<Vec<String>>,
 134    #[serde(skip_serializing_if = "Option::is_none")]
 135    pub(crate) security_opt: Option<Vec<String>>,
 136    #[serde(
 137        skip_serializing_if = "Option::is_none",
 138        default,
 139        deserialize_with = "deserialize_labels"
 140    )]
 141    pub(crate) labels: Option<HashMap<String, String>>,
 142    #[serde(skip_serializing_if = "Option::is_none")]
 143    pub(crate) build: Option<DockerComposeServiceBuild>,
 144    #[serde(skip_serializing_if = "Option::is_none")]
 145    pub(crate) privileged: Option<bool>,
 146    #[serde(default, skip_serializing_if = "Vec::is_empty")]
 147    pub(crate) volumes: Vec<MountDefinition>,
 148    #[serde(skip_serializing_if = "Option::is_none")]
 149    pub(crate) env_file: Option<Vec<String>>,
 150    #[serde(default, skip_serializing_if = "Vec::is_empty")]
 151    pub(crate) ports: Vec<DockerComposeServicePort>,
 152    #[serde(skip_serializing_if = "Option::is_none")]
 153    pub(crate) network_mode: Option<String>,
 154    #[serde(
 155        default,
 156        skip_serializing_if = "Vec::is_empty",
 157        deserialize_with = "deserialize_nullable_vec"
 158    )]
 159    pub(crate) command: Vec<String>,
 160}
 161
 162#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq, Default)]
 163pub(crate) struct DockerComposeVolume {
 164    pub(crate) name: String,
 165}
 166
 167#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq, Default)]
 168pub(crate) struct DockerComposeConfig {
 169    #[serde(skip_serializing_if = "Option::is_none")]
 170    pub(crate) name: Option<String>,
 171    pub(crate) services: HashMap<String, DockerComposeService>,
 172    #[serde(default)]
 173    pub(crate) volumes: HashMap<String, DockerComposeVolume>,
 174}
 175
 176pub(crate) struct Docker {
 177    docker_cli: String,
 178}
 179
 180impl DockerInspect {
 181    pub(crate) fn is_running(&self) -> bool {
 182        self.state.as_ref().map_or(false, |s| s.running)
 183    }
 184}
 185
 186impl Docker {
 187    pub(crate) fn new(docker_cli: &str) -> Self {
 188        Self {
 189            docker_cli: docker_cli.to_string(),
 190        }
 191    }
 192
 193    fn is_podman(&self) -> bool {
 194        self.docker_cli == "podman"
 195    }
 196
 197    async fn pull_image(&self, image: &String) -> Result<(), DevContainerError> {
 198        let mut command = Command::new(&self.docker_cli);
 199        command.args(&["pull", image]);
 200
 201        let output = command.output().await.map_err(|e| {
 202            log::error!("Error pulling image: {e}");
 203            DevContainerError::ResourceFetchFailed
 204        })?;
 205
 206        if !output.status.success() {
 207            let stderr = String::from_utf8_lossy(&output.stderr);
 208            log::error!("Non-success result from docker pull: {stderr}");
 209            return Err(DevContainerError::ResourceFetchFailed);
 210        }
 211        Ok(())
 212    }
 213
 214    fn create_docker_query_containers(&self, filters: Vec<String>) -> Command {
 215        let mut command = Command::new(&self.docker_cli);
 216        command.args(&["ps", "-a"]);
 217
 218        for filter in filters {
 219            command.arg("--filter");
 220            command.arg(filter);
 221        }
 222        command.arg("--format={{ json . }}");
 223        command
 224    }
 225
 226    fn create_docker_inspect(&self, id: &str) -> Command {
 227        let mut command = Command::new(&self.docker_cli);
 228        command.args(&["inspect", "--format={{json . }}", id]);
 229        command
 230    }
 231
 232    fn create_docker_compose_config_command(&self, config_files: &Vec<PathBuf>) -> Command {
 233        let mut command = Command::new(&self.docker_cli);
 234        command.arg("compose");
 235        for file_path in config_files {
 236            command.args(&["-f", &file_path.display().to_string()]);
 237        }
 238        command.args(&["config", "--format", "json"]);
 239        command
 240    }
 241}
 242
 243#[async_trait]
 244impl DockerClient for Docker {
 245    async fn inspect(&self, id: &String) -> Result<DockerInspect, DevContainerError> {
 246        // Try to pull the image, continue on failure; Image may be local only, id a reference to a running container
 247        self.pull_image(id).await.ok();
 248
 249        let command = self.create_docker_inspect(id);
 250
 251        let Some(docker_inspect): Option<DockerInspect> = evaluate_json_command(command).await?
 252        else {
 253            log::error!("Docker inspect produced no deserializable output");
 254            return Err(DevContainerError::CommandFailed(self.docker_cli.clone()));
 255        };
 256        Ok(docker_inspect)
 257    }
 258
 259    async fn get_docker_compose_config(
 260        &self,
 261        config_files: &Vec<PathBuf>,
 262    ) -> Result<Option<DockerComposeConfig>, DevContainerError> {
 263        let command = self.create_docker_compose_config_command(config_files);
 264        evaluate_json_command(command).await
 265    }
 266
 267    async fn docker_compose_build(
 268        &self,
 269        config_files: &Vec<PathBuf>,
 270        project_name: &str,
 271    ) -> Result<(), DevContainerError> {
 272        let mut command = Command::new(&self.docker_cli);
 273        if !self.is_podman() {
 274            command.env("DOCKER_BUILDKIT", "1");
 275        }
 276        command.args(&["compose", "--project-name", project_name]);
 277        for docker_compose_file in config_files {
 278            command.args(&["-f", &docker_compose_file.display().to_string()]);
 279        }
 280        command.arg("build");
 281
 282        let output = command.output().await.map_err(|e| {
 283            log::error!("Error running docker compose up: {e}");
 284            DevContainerError::CommandFailed(command.get_program().display().to_string())
 285        })?;
 286
 287        if !output.status.success() {
 288            let stderr = String::from_utf8_lossy(&output.stderr);
 289            log::error!("Non-success status from docker compose up: {}", stderr);
 290            return Err(DevContainerError::CommandFailed(
 291                command.get_program().display().to_string(),
 292            ));
 293        }
 294
 295        Ok(())
 296    }
 297    async fn run_docker_exec(
 298        &self,
 299        container_id: &str,
 300        remote_folder: &str,
 301        user: &str,
 302        env: &HashMap<String, String>,
 303        inner_command: Command,
 304    ) -> Result<(), DevContainerError> {
 305        let mut command = Command::new(&self.docker_cli);
 306
 307        command.args(&["exec", "-w", remote_folder, "-u", user]);
 308
 309        for (k, v) in env.iter() {
 310            command.arg("-e");
 311            let env_declaration = format!("{}={}", k, v);
 312            command.arg(&env_declaration);
 313        }
 314
 315        command.arg(container_id);
 316
 317        command.arg("sh");
 318
 319        let mut inner_program_script: Vec<String> =
 320            vec![inner_command.get_program().display().to_string()];
 321        let mut args: Vec<String> = inner_command
 322            .get_args()
 323            .map(|arg| arg.display().to_string())
 324            .collect();
 325        inner_program_script.append(&mut args);
 326        command.args(&["-c", &inner_program_script.join(" ")]);
 327
 328        let output = command.output().await.map_err(|e| {
 329            log::error!("Error running command {e} in container exec");
 330            DevContainerError::ContainerNotValid(container_id.to_string())
 331        })?;
 332        if !output.status.success() {
 333            let std_err = String::from_utf8_lossy(&output.stderr);
 334            log::error!("Command produced a non-successful output. StdErr: {std_err}");
 335        }
 336        let std_out = String::from_utf8_lossy(&output.stdout);
 337        log::debug!("Command output:\n {std_out}");
 338
 339        Ok(())
 340    }
 341    async fn start_container(&self, id: &str) -> Result<(), DevContainerError> {
 342        let mut command = Command::new(&self.docker_cli);
 343
 344        command.args(&["start", id]);
 345
 346        let output = command.output().await.map_err(|e| {
 347            log::error!("Error running docker start: {e}");
 348            DevContainerError::CommandFailed(command.get_program().display().to_string())
 349        })?;
 350
 351        if !output.status.success() {
 352            let stderr = String::from_utf8_lossy(&output.stderr);
 353            log::error!("Non-success status from docker start: {stderr}");
 354            return Err(DevContainerError::CommandFailed(
 355                command.get_program().display().to_string(),
 356            ));
 357        }
 358
 359        Ok(())
 360    }
 361
 362    async fn find_process_by_filters(
 363        &self,
 364        filters: Vec<String>,
 365    ) -> Result<Option<DockerPs>, DevContainerError> {
 366        let command = self.create_docker_query_containers(filters);
 367        evaluate_json_command(command).await
 368    }
 369
 370    fn docker_cli(&self) -> String {
 371        self.docker_cli.clone()
 372    }
 373
 374    fn supports_compose_buildkit(&self) -> bool {
 375        !self.is_podman()
 376    }
 377}
 378
 379#[async_trait]
 380pub(crate) trait DockerClient {
 381    async fn inspect(&self, id: &String) -> Result<DockerInspect, DevContainerError>;
 382    async fn get_docker_compose_config(
 383        &self,
 384        config_files: &Vec<PathBuf>,
 385    ) -> Result<Option<DockerComposeConfig>, DevContainerError>;
 386    async fn docker_compose_build(
 387        &self,
 388        config_files: &Vec<PathBuf>,
 389        project_name: &str,
 390    ) -> Result<(), DevContainerError>;
 391    async fn run_docker_exec(
 392        &self,
 393        container_id: &str,
 394        remote_folder: &str,
 395        user: &str,
 396        env: &HashMap<String, String>,
 397        inner_command: Command,
 398    ) -> Result<(), DevContainerError>;
 399    async fn start_container(&self, id: &str) -> Result<(), DevContainerError>;
 400    async fn find_process_by_filters(
 401        &self,
 402        filters: Vec<String>,
 403    ) -> Result<Option<DockerPs>, DevContainerError>;
 404    fn supports_compose_buildkit(&self) -> bool;
 405    /// This operates as an escape hatch for more custom uses of the docker API.
 406    /// See DevContainerManifest::create_docker_build as an example
 407    fn docker_cli(&self) -> String;
 408}
 409
 410fn deserialize_labels<'de, D>(deserializer: D) -> Result<Option<HashMap<String, String>>, D::Error>
 411where
 412    D: Deserializer<'de>,
 413{
 414    struct LabelsVisitor;
 415
 416    impl<'de> de::Visitor<'de> for LabelsVisitor {
 417        type Value = Option<HashMap<String, String>>;
 418
 419        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
 420            formatter.write_str("a sequence of strings or a map of string key-value pairs")
 421        }
 422
 423        fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
 424        where
 425            A: de::SeqAccess<'de>,
 426        {
 427            let values = Vec::<String>::deserialize(de::value::SeqAccessDeserializer::new(seq))?;
 428
 429            Ok(Some(
 430                values
 431                    .iter()
 432                    .filter_map(|v| {
 433                        let (key, value) = v.split_once('=')?;
 434                        Some((key.to_string(), value.to_string()))
 435                    })
 436                    .collect(),
 437            ))
 438        }
 439
 440        fn visit_map<M>(self, map: M) -> Result<Self::Value, M::Error>
 441        where
 442            M: de::MapAccess<'de>,
 443        {
 444            HashMap::<String, String>::deserialize(de::value::MapAccessDeserializer::new(map))
 445                .map(|v| Some(v))
 446        }
 447
 448        fn visit_none<E>(self) -> Result<Self::Value, E>
 449        where
 450            E: de::Error,
 451        {
 452            Ok(None)
 453        }
 454
 455        fn visit_unit<E>(self) -> Result<Self::Value, E>
 456        where
 457            E: de::Error,
 458        {
 459            Ok(None)
 460        }
 461    }
 462
 463    deserializer.deserialize_any(LabelsVisitor)
 464}
 465
 466fn deserialize_nullable_vec<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
 467where
 468    D: Deserializer<'de>,
 469    T: Deserialize<'de>,
 470{
 471    Option::<Vec<T>>::deserialize(deserializer).map(|opt| opt.unwrap_or_default())
 472}
 473
 474fn deserialize_nullable_labels<'de, D>(deserializer: D) -> Result<DockerConfigLabels, D::Error>
 475where
 476    D: Deserializer<'de>,
 477{
 478    Option::<DockerConfigLabels>::deserialize(deserializer).map(|opt| opt.unwrap_or_default())
 479}
 480
 481fn deserialize_metadata<'de, D>(
 482    deserializer: D,
 483) -> Result<Option<Vec<HashMap<String, serde_json_lenient::Value>>>, D::Error>
 484where
 485    D: Deserializer<'de>,
 486{
 487    let s: Option<String> = Option::deserialize(deserializer)?;
 488    match s {
 489        Some(json_string) => {
 490            let parsed: Vec<HashMap<String, serde_json_lenient::Value>> =
 491                serde_json_lenient::from_str(&json_string).map_err(|e| {
 492                    log::error!("Error deserializing metadata: {e}");
 493                    serde::de::Error::custom(e)
 494                })?;
 495            Ok(Some(parsed))
 496        }
 497        None => Ok(None),
 498    }
 499}
 500
 501pub(crate) fn get_remote_dir_from_config(
 502    config: &DockerInspect,
 503    local_dir: String,
 504) -> Result<String, DevContainerError> {
 505    let local_path = PathBuf::from(&local_dir);
 506
 507    let Some(mounts) = &config.mounts else {
 508        log::error!("No mounts defined for container");
 509        return Err(DevContainerError::ContainerNotValid(config.id.clone()));
 510    };
 511
 512    for mount in mounts {
 513        // Sometimes docker will mount the local filesystem on host_mnt for system isolation
 514        let mount_source = PathBuf::from(&mount.source.trim_start_matches("/host_mnt"));
 515        if let Ok(relative_path_to_project) = local_path.strip_prefix(&mount_source) {
 516            let remote_dir = format!(
 517                "{}/{}",
 518                &mount.destination,
 519                relative_path_to_project.display()
 520            );
 521            return Ok(remote_dir);
 522        }
 523        if mount.source == local_dir {
 524            return Ok(mount.destination.clone());
 525        }
 526    }
 527    log::error!("No mounts to local folder");
 528    Err(DevContainerError::ContainerNotValid(config.id.clone()))
 529}
 530
 531#[cfg(test)]
 532mod test {
 533    use std::{
 534        collections::HashMap,
 535        ffi::OsStr,
 536        process::{ExitStatus, Output},
 537    };
 538
 539    use crate::{
 540        command_json::deserialize_json_output,
 541        devcontainer_json::MountDefinition,
 542        docker::{
 543            Docker, DockerComposeConfig, DockerComposeService, DockerComposeServicePort,
 544            DockerComposeVolume, DockerInspect, DockerPs, get_remote_dir_from_config,
 545        },
 546    };
 547
 548    #[test]
 549    fn should_parse_simple_env_var() {
 550        let config = super::DockerInspectConfig {
 551            labels: super::DockerConfigLabels { metadata: None },
 552            image_user: None,
 553            env: vec!["KEY=value".to_string()],
 554        };
 555
 556        let map = config.env_as_map().unwrap();
 557        assert_eq!(map.get("KEY").unwrap(), "value");
 558    }
 559
 560    #[test]
 561    fn should_parse_env_var_with_equals_in_value() {
 562        let config = super::DockerInspectConfig {
 563            labels: super::DockerConfigLabels { metadata: None },
 564            image_user: None,
 565            env: vec!["COMPLEX=key=val other>=1.0".to_string()],
 566        };
 567
 568        let map = config.env_as_map().unwrap();
 569        assert_eq!(map.get("COMPLEX").unwrap(), "key=val other>=1.0");
 570    }
 571
 572    #[test]
 573    fn should_parse_simple_label() {
 574        let json = r#"{"volumes": [], "labels": ["com.example.key=value"]}"#;
 575        let service: DockerComposeService = serde_json_lenient::from_str(json).unwrap();
 576        let labels = service.labels.unwrap();
 577        assert_eq!(labels.get("com.example.key").unwrap(), "value");
 578    }
 579
 580    #[test]
 581    fn should_parse_label_with_equals_in_value() {
 582        let json = r#"{"volumes": [], "labels": ["com.example.key=value=with=equals"]}"#;
 583        let service: DockerComposeService = serde_json_lenient::from_str(json).unwrap();
 584        let labels = service.labels.unwrap();
 585        assert_eq!(labels.get("com.example.key").unwrap(), "value=with=equals");
 586    }
 587
 588    #[test]
 589    fn should_create_docker_inspect_command() {
 590        let docker = Docker::new("docker");
 591        let given_id = "given_docker_id";
 592
 593        let command = docker.create_docker_inspect(given_id);
 594
 595        assert_eq!(
 596            command.get_args().collect::<Vec<&OsStr>>(),
 597            vec![
 598                OsStr::new("inspect"),
 599                OsStr::new("--format={{json . }}"),
 600                OsStr::new(given_id)
 601            ]
 602        )
 603    }
 604
 605    #[test]
 606    fn should_deserialize_docker_ps_with_filters() {
 607        // First, deserializes empty
 608        let empty_output = Output {
 609            status: ExitStatus::default(),
 610            stderr: vec![],
 611            stdout: String::from("").into_bytes(),
 612        };
 613
 614        let result: Option<DockerPs> = deserialize_json_output(empty_output).unwrap();
 615
 616        assert!(result.is_none());
 617
 618        let full_output = Output {
 619                status: ExitStatus::default(),
 620                stderr: vec![],
 621                stdout: String::from(r#"
 622    {
 623        "Command": "\"/bin/sh -c 'echo Co…\"",
 624        "CreatedAt": "2026-02-04 15:44:21 -0800 PST",
 625        "ID": "abdb6ab59573",
 626        "Image": "mcr.microsoft.com/devcontainers/base:ubuntu",
 627        "Labels": "desktop.docker.io/mounts/0/Source=/somepath/cli,desktop.docker.io/mounts/0/SourceKind=hostFile,desktop.docker.io/mounts/0/Target=/workspaces/cli,desktop.docker.io/ports.scheme=v2,dev.containers.features=common,dev.containers.id=base-ubuntu,dev.containers.release=v0.4.24,dev.containers.source=https://github.com/devcontainers/images,dev.containers.timestamp=Fri, 30 Jan 2026 16:52:34 GMT,dev.containers.variant=noble,devcontainer.config_file=/somepath/cli/.devcontainer/dev_container_2/devcontainer.json,devcontainer.local_folder=/somepath/cli,devcontainer.metadata=[{\"id\":\"ghcr.io/devcontainers/features/common-utils:2\"},{\"id\":\"ghcr.io/devcontainers/features/git:1\",\"customizations\":{\"vscode\":{\"settings\":{\"github.copilot.chat.codeGeneration.instructions\":[{\"text\":\"This dev container includes an up-to-date version of Git, built from source as needed, pre-installed and available on the `PATH`.\"}]}}}},{\"remoteUser\":\"vscode\"}],org.opencontainers.image.ref.name=ubuntu,org.opencontainers.image.version=24.04,version=2.1.6",
 628        "LocalVolumes": "0",
 629        "Mounts": "/host_mnt/User…",
 630        "Names": "objective_haslett",
 631        "Networks": "bridge",
 632        "Platform": {
 633        "architecture": "arm64",
 634        "os": "linux"
 635        },
 636        "Ports": "",
 637        "RunningFor": "47 hours ago",
 638        "Size": "0B",
 639        "State": "running",
 640        "Status": "Up 47 hours"
 641    }
 642                    "#).into_bytes(),
 643            };
 644
 645        let result: Option<DockerPs> = deserialize_json_output(full_output).unwrap();
 646
 647        assert!(result.is_some());
 648        let result = result.unwrap();
 649        assert_eq!(result.id, "abdb6ab59573".to_string());
 650
 651        // Podman variant (Id, not ID)
 652        let full_output = Output {
 653                status: ExitStatus::default(),
 654                stderr: vec![],
 655                stdout: String::from(r#"
 656    {
 657        "Command": "\"/bin/sh -c 'echo Co…\"",
 658        "CreatedAt": "2026-02-04 15:44:21 -0800 PST",
 659        "Id": "abdb6ab59573",
 660        "Image": "mcr.microsoft.com/devcontainers/base:ubuntu",
 661        "Labels": "desktop.docker.io/mounts/0/Source=/somepath/cli,desktop.docker.io/mounts/0/SourceKind=hostFile,desktop.docker.io/mounts/0/Target=/workspaces/cli,desktop.docker.io/ports.scheme=v2,dev.containers.features=common,dev.containers.id=base-ubuntu,dev.containers.release=v0.4.24,dev.containers.source=https://github.com/devcontainers/images,dev.containers.timestamp=Fri, 30 Jan 2026 16:52:34 GMT,dev.containers.variant=noble,devcontainer.config_file=/somepath/cli/.devcontainer/dev_container_2/devcontainer.json,devcontainer.local_folder=/somepath/cli,devcontainer.metadata=[{\"id\":\"ghcr.io/devcontainers/features/common-utils:2\"},{\"id\":\"ghcr.io/devcontainers/features/git:1\",\"customizations\":{\"vscode\":{\"settings\":{\"github.copilot.chat.codeGeneration.instructions\":[{\"text\":\"This dev container includes an up-to-date version of Git, built from source as needed, pre-installed and available on the `PATH`.\"}]}}}},{\"remoteUser\":\"vscode\"}],org.opencontainers.image.ref.name=ubuntu,org.opencontainers.image.version=24.04,version=2.1.6",
 662        "LocalVolumes": "0",
 663        "Mounts": "/host_mnt/User…",
 664        "Names": "objective_haslett",
 665        "Networks": "bridge",
 666        "Platform": {
 667        "architecture": "arm64",
 668        "os": "linux"
 669        },
 670        "Ports": "",
 671        "RunningFor": "47 hours ago",
 672        "Size": "0B",
 673        "State": "running",
 674        "Status": "Up 47 hours"
 675    }
 676                    "#).into_bytes(),
 677            };
 678
 679        let result: Option<DockerPs> = deserialize_json_output(full_output).unwrap();
 680
 681        assert!(result.is_some());
 682        let result = result.unwrap();
 683        assert_eq!(result.id, "abdb6ab59573".to_string());
 684    }
 685
 686    #[test]
 687    fn should_get_target_dir_from_docker_inspect() {
 688        let given_config = r#"
 689    {
 690      "Id": "abdb6ab59573659b11dac9f4973796741be35b642c9b48960709304ce46dbf85",
 691      "Created": "2026-02-04T23:44:21.802688084Z",
 692      "Path": "/bin/sh",
 693      "Args": [
 694        "-c",
 695        "echo Container started\ntrap \"exit 0\" 15\n\nexec \"$@\"\nwhile sleep 1 & wait $!; do :; done",
 696        "-"
 697      ],
 698      "State": {
 699        "Status": "running",
 700        "Running": true,
 701        "Paused": false,
 702        "Restarting": false,
 703        "OOMKilled": false,
 704        "Dead": false,
 705        "Pid": 23087,
 706        "ExitCode": 0,
 707        "Error": "",
 708        "StartedAt": "2026-02-04T23:44:21.954875084Z",
 709        "FinishedAt": "0001-01-01T00:00:00Z"
 710      },
 711      "Image": "sha256:3dcb059253b2ebb44de3936620e1cff3dadcd2c1c982d579081ca8128c1eb319",
 712      "ResolvConfPath": "/var/lib/docker/containers/abdb6ab59573659b11dac9f4973796741be35b642c9b48960709304ce46dbf85/resolv.conf",
 713      "HostnamePath": "/var/lib/docker/containers/abdb6ab59573659b11dac9f4973796741be35b642c9b48960709304ce46dbf85/hostname",
 714      "HostsPath": "/var/lib/docker/containers/abdb6ab59573659b11dac9f4973796741be35b642c9b48960709304ce46dbf85/hosts",
 715      "LogPath": "/var/lib/docker/containers/abdb6ab59573659b11dac9f4973796741be35b642c9b48960709304ce46dbf85/abdb6ab59573659b11dac9f4973796741be35b642c9b48960709304ce46dbf85-json.log",
 716      "Name": "/objective_haslett",
 717      "RestartCount": 0,
 718      "Driver": "overlayfs",
 719      "Platform": "linux",
 720      "MountLabel": "",
 721      "ProcessLabel": "",
 722      "AppArmorProfile": "",
 723      "ExecIDs": [
 724        "008019d93df4107fcbba78bcc6e1ed7e121844f36c26aca1a56284655a6adb53"
 725      ],
 726      "HostConfig": {
 727        "Binds": null,
 728        "ContainerIDFile": "",
 729        "LogConfig": {
 730          "Type": "json-file",
 731          "Config": {}
 732        },
 733        "NetworkMode": "bridge",
 734        "PortBindings": {},
 735        "RestartPolicy": {
 736          "Name": "no",
 737          "MaximumRetryCount": 0
 738        },
 739        "AutoRemove": false,
 740        "VolumeDriver": "",
 741        "VolumesFrom": null,
 742        "ConsoleSize": [
 743          0,
 744          0
 745        ],
 746        "CapAdd": null,
 747        "CapDrop": null,
 748        "CgroupnsMode": "private",
 749        "Dns": [],
 750        "DnsOptions": [],
 751        "DnsSearch": [],
 752        "ExtraHosts": null,
 753        "GroupAdd": null,
 754        "IpcMode": "private",
 755        "Cgroup": "",
 756        "Links": null,
 757        "OomScoreAdj": 0,
 758        "PidMode": "",
 759        "Privileged": false,
 760        "PublishAllPorts": false,
 761        "ReadonlyRootfs": false,
 762        "SecurityOpt": null,
 763        "UTSMode": "",
 764        "UsernsMode": "",
 765        "ShmSize": 67108864,
 766        "Runtime": "runc",
 767        "Isolation": "",
 768        "CpuShares": 0,
 769        "Memory": 0,
 770        "NanoCpus": 0,
 771        "CgroupParent": "",
 772        "BlkioWeight": 0,
 773        "BlkioWeightDevice": [],
 774        "BlkioDeviceReadBps": [],
 775        "BlkioDeviceWriteBps": [],
 776        "BlkioDeviceReadIOps": [],
 777        "BlkioDeviceWriteIOps": [],
 778        "CpuPeriod": 0,
 779        "CpuQuota": 0,
 780        "CpuRealtimePeriod": 0,
 781        "CpuRealtimeRuntime": 0,
 782        "CpusetCpus": "",
 783        "CpusetMems": "",
 784        "Devices": [],
 785        "DeviceCgroupRules": null,
 786        "DeviceRequests": null,
 787        "MemoryReservation": 0,
 788        "MemorySwap": 0,
 789        "MemorySwappiness": null,
 790        "OomKillDisable": null,
 791        "PidsLimit": null,
 792        "Ulimits": [],
 793        "CpuCount": 0,
 794        "CpuPercent": 0,
 795        "IOMaximumIOps": 0,
 796        "IOMaximumBandwidth": 0,
 797        "Mounts": [
 798          {
 799            "Type": "bind",
 800            "Source": "/somepath/cli",
 801            "Target": "/workspaces/cli",
 802            "Consistency": "cached"
 803          }
 804        ],
 805        "MaskedPaths": [
 806          "/proc/asound",
 807          "/proc/acpi",
 808          "/proc/interrupts",
 809          "/proc/kcore",
 810          "/proc/keys",
 811          "/proc/latency_stats",
 812          "/proc/timer_list",
 813          "/proc/timer_stats",
 814          "/proc/sched_debug",
 815          "/proc/scsi",
 816          "/sys/firmware",
 817          "/sys/devices/virtual/powercap"
 818        ],
 819        "ReadonlyPaths": [
 820          "/proc/bus",
 821          "/proc/fs",
 822          "/proc/irq",
 823          "/proc/sys",
 824          "/proc/sysrq-trigger"
 825        ]
 826      },
 827      "GraphDriver": {
 828        "Data": null,
 829        "Name": "overlayfs"
 830      },
 831      "Mounts": [
 832        {
 833          "Type": "bind",
 834          "Source": "/somepath/cli",
 835          "Destination": "/workspaces/cli",
 836          "Mode": "",
 837          "RW": true,
 838          "Propagation": "rprivate"
 839        }
 840      ],
 841      "Config": {
 842        "Hostname": "abdb6ab59573",
 843        "Domainname": "",
 844        "User": "root",
 845        "AttachStdin": false,
 846        "AttachStdout": true,
 847        "AttachStderr": true,
 848        "Tty": false,
 849        "OpenStdin": false,
 850        "StdinOnce": false,
 851        "Env": [
 852          "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
 853        ],
 854        "Cmd": [
 855          "-c",
 856          "echo Container started\ntrap \"exit 0\" 15\n\nexec \"$@\"\nwhile sleep 1 & wait $!; do :; done",
 857          "-"
 858        ],
 859        "Image": "mcr.microsoft.com/devcontainers/base:ubuntu",
 860        "Volumes": null,
 861        "WorkingDir": "",
 862        "Entrypoint": [
 863          "/bin/sh"
 864        ],
 865        "OnBuild": null,
 866        "Labels": {
 867          "dev.containers.features": "common",
 868          "dev.containers.id": "base-ubuntu",
 869          "dev.containers.release": "v0.4.24",
 870          "dev.containers.source": "https://github.com/devcontainers/images",
 871          "dev.containers.timestamp": "Fri, 30 Jan 2026 16:52:34 GMT",
 872          "dev.containers.variant": "noble",
 873          "devcontainer.config_file": "/somepath/cli/.devcontainer/dev_container_2/devcontainer.json",
 874          "devcontainer.local_folder": "/somepath/cli",
 875          "devcontainer.metadata": "[{\"id\":\"ghcr.io/devcontainers/features/common-utils:2\"},{\"id\":\"ghcr.io/devcontainers/features/git:1\",\"customizations\":{\"vscode\":{\"settings\":{\"github.copilot.chat.codeGeneration.instructions\":[{\"text\":\"This dev container includes an up-to-date version of Git, built from source as needed, pre-installed and available on the `PATH`.\"}]}}}},{\"remoteUser\":\"vscode\"}]",
 876          "org.opencontainers.image.ref.name": "ubuntu",
 877          "org.opencontainers.image.version": "24.04",
 878          "version": "2.1.6"
 879        },
 880        "StopTimeout": 1
 881      },
 882      "NetworkSettings": {
 883        "Bridge": "",
 884        "SandboxID": "2a94990d542fe532deb75f1cc67f761df2d669e3b41161f914079e88516cc54b",
 885        "SandboxKey": "/var/run/docker/netns/2a94990d542f",
 886        "Ports": {},
 887        "HairpinMode": false,
 888        "LinkLocalIPv6Address": "",
 889        "LinkLocalIPv6PrefixLen": 0,
 890        "SecondaryIPAddresses": null,
 891        "SecondaryIPv6Addresses": null,
 892        "EndpointID": "ef5b35a8fbb145565853e1a1d960e737fcc18c20920e96494e4c0cfc55683570",
 893        "Gateway": "172.17.0.1",
 894        "GlobalIPv6Address": "",
 895        "GlobalIPv6PrefixLen": 0,
 896        "IPAddress": "172.17.0.3",
 897        "IPPrefixLen": 16,
 898        "IPv6Gateway": "",
 899        "MacAddress": "",
 900        "Networks": {
 901          "bridge": {
 902            "IPAMConfig": null,
 903            "Links": null,
 904            "Aliases": null,
 905            "MacAddress": "9a:ec:af:8a:ac:81",
 906            "DriverOpts": null,
 907            "GwPriority": 0,
 908            "NetworkID": "51bb8ccc4d1281db44f16d915963fc728619d4a68e2f90e5ea8f1cb94885063e",
 909            "EndpointID": "ef5b35a8fbb145565853e1a1d960e737fcc18c20920e96494e4c0cfc55683570",
 910            "Gateway": "172.17.0.1",
 911            "IPAddress": "172.17.0.3",
 912            "IPPrefixLen": 16,
 913            "IPv6Gateway": "",
 914            "GlobalIPv6Address": "",
 915            "GlobalIPv6PrefixLen": 0,
 916            "DNSNames": null
 917          }
 918        }
 919      },
 920      "ImageManifestDescriptor": {
 921        "mediaType": "application/vnd.oci.image.manifest.v1+json",
 922        "digest": "sha256:39c3436527190561948236894c55b59fa58aa08d68d8867e703c8d5ab72a3593",
 923        "size": 2195,
 924        "platform": {
 925          "architecture": "arm64",
 926          "os": "linux"
 927        }
 928      }
 929    }
 930                "#;
 931        let config = serde_json_lenient::from_str::<DockerInspect>(given_config).unwrap();
 932
 933        let target_dir = get_remote_dir_from_config(&config, "/somepath/cli".to_string());
 934
 935        assert!(target_dir.is_ok());
 936        assert_eq!(target_dir.unwrap(), "/workspaces/cli/".to_string());
 937    }
 938
 939    #[test]
 940    fn should_deserialize_docker_compose_config() {
 941        let given_config = r#"
 942    {
 943        "name": "devcontainer",
 944        "networks": {
 945        "default": {
 946            "name": "devcontainer_default",
 947            "ipam": {}
 948        }
 949        },
 950        "services": {
 951            "app": {
 952                "command": [
 953                "sleep",
 954                "infinity"
 955                ],
 956                "depends_on": {
 957                "db": {
 958                    "condition": "service_started",
 959                    "restart": true,
 960                    "required": true
 961                }
 962                },
 963                "entrypoint": null,
 964                "environment": {
 965                "POSTGRES_DB": "postgres",
 966                "POSTGRES_HOSTNAME": "localhost",
 967                "POSTGRES_PASSWORD": "postgres",
 968                "POSTGRES_PORT": "5432",
 969                "POSTGRES_USER": "postgres"
 970                },
 971                "ports": [
 972                    {
 973                        "target": "5443",
 974                        "published": "5442"
 975                    },
 976                    {
 977                        "name": "custom port",
 978                        "protocol": "udp",
 979                        "host_ip": "127.0.0.1",
 980                        "app_protocol": "http",
 981                        "mode": "host",
 982                        "target": "8081",
 983                        "published": "8083"
 984
 985                    }
 986                ],
 987                "image": "mcr.microsoft.com/devcontainers/rust:2-1-bookworm",
 988                "network_mode": "service:db",
 989                "volumes": [
 990                {
 991                    "type": "bind",
 992                    "source": "/path/to",
 993                    "target": "/workspaces",
 994                    "bind": {
 995                    "create_host_path": true
 996                    }
 997                }
 998                ]
 999            },
1000            "db": {
1001                "command": null,
1002                "entrypoint": null,
1003                "environment": {
1004                "POSTGRES_DB": "postgres",
1005                "POSTGRES_HOSTNAME": "localhost",
1006                "POSTGRES_PASSWORD": "postgres",
1007                "POSTGRES_PORT": "5432",
1008                "POSTGRES_USER": "postgres"
1009                },
1010                "image": "postgres:14.1",
1011                "networks": {
1012                "default": null
1013                },
1014                "restart": "unless-stopped",
1015                "volumes": [
1016                {
1017                    "type": "volume",
1018                    "source": "postgres-data",
1019                    "target": "/var/lib/postgresql/data",
1020                    "volume": {}
1021                }
1022                ]
1023            }
1024        },
1025        "volumes": {
1026        "postgres-data": {
1027            "name": "devcontainer_postgres-data"
1028        }
1029        }
1030    }
1031                "#;
1032
1033        let docker_compose_config: DockerComposeConfig =
1034            serde_json_lenient::from_str(given_config).unwrap();
1035
1036        let expected_config = DockerComposeConfig {
1037            name: Some("devcontainer".to_string()),
1038            services: HashMap::from([
1039                (
1040                    "app".to_string(),
1041                    DockerComposeService {
1042                        command: vec!["sleep".to_string(), "infinity".to_string()],
1043                        image: Some(
1044                            "mcr.microsoft.com/devcontainers/rust:2-1-bookworm".to_string(),
1045                        ),
1046                        volumes: vec![MountDefinition {
1047                            mount_type: Some("bind".to_string()),
1048                            source: Some("/path/to".to_string()),
1049                            target: "/workspaces".to_string(),
1050                        }],
1051                        network_mode: Some("service:db".to_string()),
1052
1053                        ports: vec![
1054                            DockerComposeServicePort {
1055                                target: "5443".to_string(),
1056                                published: "5442".to_string(),
1057                                ..Default::default()
1058                            },
1059                            DockerComposeServicePort {
1060                                target: "8081".to_string(),
1061                                published: "8083".to_string(),
1062                                mode: Some("host".to_string()),
1063                                protocol: Some("udp".to_string()),
1064                                host_ip: Some("127.0.0.1".to_string()),
1065                                app_protocol: Some("http".to_string()),
1066                                name: Some("custom port".to_string()),
1067                            },
1068                        ],
1069                        ..Default::default()
1070                    },
1071                ),
1072                (
1073                    "db".to_string(),
1074                    DockerComposeService {
1075                        image: Some("postgres:14.1".to_string()),
1076                        volumes: vec![MountDefinition {
1077                            mount_type: Some("volume".to_string()),
1078                            source: Some("postgres-data".to_string()),
1079                            target: "/var/lib/postgresql/data".to_string(),
1080                        }],
1081                        ..Default::default()
1082                    },
1083                ),
1084            ]),
1085            volumes: HashMap::from([(
1086                "postgres-data".to_string(),
1087                DockerComposeVolume {
1088                    name: "devcontainer_postgres-data".to_string(),
1089                },
1090            )]),
1091        };
1092
1093        assert_eq!(docker_compose_config, expected_config);
1094    }
1095
1096    #[test]
1097    fn should_deserialize_compose_labels_as_map() {
1098        let given_config = r#"
1099        {
1100            "name": "devcontainer",
1101            "services": {
1102                "app": {
1103                    "image": "node:22-alpine",
1104                    "volumes": [],
1105                    "labels": {
1106                        "com.example.test": "value",
1107                        "another.label": "another-value"
1108                    }
1109                }
1110            }
1111        }
1112        "#;
1113
1114        let config: DockerComposeConfig = serde_json_lenient::from_str(given_config).unwrap();
1115        let service = config.services.get("app").unwrap();
1116        let labels = service.labels.clone().unwrap();
1117        assert_eq!(
1118            labels,
1119            HashMap::from([
1120                ("another.label".to_string(), "another-value".to_string()),
1121                ("com.example.test".to_string(), "value".to_string())
1122            ])
1123        );
1124    }
1125
1126    #[test]
1127    fn should_deserialize_compose_labels_as_array() {
1128        let given_config = r#"
1129        {
1130            "name": "devcontainer",
1131            "services": {
1132                "app": {
1133                    "image": "node:22-alpine",
1134                    "volumes": [],
1135                    "labels": ["com.example.test=value"]
1136                }
1137            }
1138        }
1139        "#;
1140
1141        let config: DockerComposeConfig = serde_json_lenient::from_str(given_config).unwrap();
1142        let service = config.services.get("app").unwrap();
1143        assert_eq!(
1144            service.labels,
1145            Some(HashMap::from([(
1146                "com.example.test".to_string(),
1147                "value".to_string()
1148            )]))
1149        );
1150    }
1151
1152    #[test]
1153    fn should_deserialize_compose_without_volumes() {
1154        let given_config = r#"
1155        {
1156            "name": "devcontainer",
1157            "services": {
1158                "app": {
1159                    "image": "node:22-alpine",
1160                    "volumes": []
1161                }
1162            }
1163        }
1164        "#;
1165
1166        let config: DockerComposeConfig = serde_json_lenient::from_str(given_config).unwrap();
1167        assert!(config.volumes.is_empty());
1168    }
1169
1170    #[test]
1171    fn should_deserialize_compose_with_missing_volumes_field() {
1172        let given_config = r#"
1173        {
1174            "name": "devcontainer",
1175            "services": {
1176                "sidecar": {
1177                    "image": "ubuntu:24.04"
1178                }
1179            }
1180        }
1181        "#;
1182
1183        let config: DockerComposeConfig = serde_json_lenient::from_str(given_config).unwrap();
1184        let service = config.services.get("sidecar").unwrap();
1185        assert!(service.volumes.is_empty());
1186    }
1187
1188    #[test]
1189    fn should_deserialize_compose_volume_without_source() {
1190        let given_config = r#"
1191        {
1192            "name": "devcontainer",
1193            "services": {
1194                "app": {
1195                    "image": "ubuntu:24.04",
1196                    "volumes": [
1197                        {
1198                            "type": "tmpfs",
1199                            "target": "/tmp"
1200                        }
1201                    ]
1202                }
1203            }
1204        }
1205        "#;
1206
1207        let config: DockerComposeConfig = serde_json_lenient::from_str(given_config).unwrap();
1208        let service = config.services.get("app").unwrap();
1209        assert_eq!(service.volumes.len(), 1);
1210        assert_eq!(service.volumes[0].source, None);
1211        assert_eq!(service.volumes[0].target, "/tmp");
1212        assert_eq!(service.volumes[0].mount_type, Some("tmpfs".to_string()));
1213    }
1214
1215    #[test]
1216    fn should_deserialize_inspect_without_labels() {
1217        let given_config = r#"
1218        {
1219            "Id": "sha256:abc123",
1220            "Config": {
1221                "Env": ["PATH=/usr/bin"],
1222                "Cmd": ["node"],
1223                "WorkingDir": "/"
1224            }
1225        }
1226        "#;
1227
1228        let inspect: DockerInspect = serde_json_lenient::from_str(given_config).unwrap();
1229        assert!(inspect.config.labels.metadata.is_none());
1230        assert!(inspect.config.image_user.is_none());
1231    }
1232
1233    #[test]
1234    fn should_deserialize_inspect_with_null_labels() {
1235        let given_config = r#"
1236        {
1237            "Id": "sha256:abc123",
1238            "Config": {
1239                "Labels": null,
1240                "Env": ["PATH=/usr/bin"]
1241            }
1242        }
1243        "#;
1244
1245        let inspect: DockerInspect = serde_json_lenient::from_str(given_config).unwrap();
1246        assert!(inspect.config.labels.metadata.is_none());
1247    }
1248
1249    #[test]
1250    fn should_deserialize_inspect_with_labels_but_no_metadata() {
1251        let given_config = r#"
1252        {
1253            "Id": "sha256:abc123",
1254            "Config": {
1255                "Labels": {
1256                    "com.example.test": "value"
1257                },
1258                "Env": ["PATH=/usr/bin"]
1259            }
1260        }
1261        "#;
1262
1263        let inspect: DockerInspect = serde_json_lenient::from_str(given_config).unwrap();
1264        assert!(inspect.config.labels.metadata.is_none());
1265    }
1266}