csb 0.1.0

Sandboxed Claude Code on Apple container
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use anyhow::{Context, Result};
use std::ffi::OsStr;
use std::process::{ExitStatus, Output};

pub(crate) fn ensure_available() -> Result<()> {
    which::which("container").context(
        "Apple 'container' not found. Install: brew install container (requires macOS 26+)",
    )?;
    Ok(())
}

pub(crate) fn system_start() {
    let _ = std::process::Command::new("container")
        .args(["system", "start"])
        .stdout(std::process::Stdio::null())
        .stderr(std::process::Stdio::null())
        .status();
}

pub(crate) fn run_interactive<S: AsRef<OsStr>>(args: &[S]) -> Result<ExitStatus> {
    std::process::Command::new("container")
        .args(args)
        .status()
        .context("failed to launch container")
}

pub(crate) fn run_output(args: &[&str]) -> Result<Output> {
    std::process::Command::new("container")
        .args(args)
        .output()
        .context("failed to run container command")
}

/// Like `run_output`, but a non-zero exit is an error carrying the command's
/// stderr — so a failed `container` call can never be mistaken for empty output.
pub(crate) fn run_checked(args: &[&str]) -> Result<String> {
    let output = run_output(args)?;
    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        let detail = stderr.trim();
        anyhow::bail!(
            "`container {}` failed{}{}",
            args.join(" "),
            if detail.is_empty() { "" } else { ": " },
            detail
        );
    }
    Ok(String::from_utf8_lossy(&output.stdout).into_owned())
}

pub(crate) fn image_exists(image: &str) -> Result<bool> {
    let stdout = run_checked(&["image", "ls"])?;
    Ok(image_listed(&stdout, image))
}

pub(crate) fn builder_stop() {
    let _ = std::process::Command::new("container")
        .args(["builder", "stop"])
        .stdout(std::process::Stdio::null())
        .stderr(std::process::Stdio::null())
        .status();
}

/// Split `name[:tag]`, taking care not to mistake a registry port for a tag
/// (`ghcr.io:5000/foo` has no tag).
fn split_image_ref(image: &str) -> (&str, Option<&str>) {
    match image.rsplit_once(':') {
        Some((name, tag)) if !tag.contains('/') => (name, Some(tag)),
        _ => (image, None),
    }
}

fn is_header(line: &&str) -> bool {
    let mut cols = line.split_whitespace();
    cols.next() == Some("NAME") && cols.next() == Some("TAG")
}

/// `container image ls` prints `NAME  TAG  DIGEST`, so an image referenced with an
/// explicit tag (`claude-box:latest`) never matches the NAME column on its own.
fn image_listed(stdout: &str, image: &str) -> bool {
    let (name, tag) = split_image_ref(image);
    stdout.lines().skip_while(is_header).any(|line| {
        let mut cols = line.split_whitespace();
        if cols.next() != Some(name) {
            return false;
        }
        match tag {
            None => true,
            Some(tag) => cols.next() == Some(tag),
        }
    })
}

#[cfg(test)]
mod tests {
    use super::*;

    const LS: &str = "\
NAME                                          TAG      DIGEST
claude-box                                    latest   4f9d8d0eb9c9
node                                          22-slim  e21fc383b50d
ghcr.io/apple/container-builder-shim/builder  0.12.0   edf820e05c33
";

    #[test]
    fn image_listed_should_match_untagged_name() {
        assert!(image_listed(LS, "claude-box"));
        assert!(image_listed(LS, "node"));
    }

    #[test]
    fn image_listed_should_match_name_with_explicit_tag() {
        assert!(image_listed(LS, "claude-box:latest"));
        assert!(image_listed(LS, "node:22-slim"));
    }

    #[test]
    fn image_listed_should_reject_wrong_tag() {
        assert!(!image_listed(LS, "claude-box:v2"));
    }

    #[test]
    fn image_listed_should_reject_missing_image() {
        assert!(!image_listed(LS, "nope"));
        assert!(!image_listed("", "claude-box"));
    }

    #[test]
    fn image_listed_should_not_match_the_header_or_substrings() {
        assert!(!image_listed(LS, "NAME"));
        assert!(!image_listed(LS, "claude"));
    }

    #[test]
    fn split_image_ref_should_ignore_registry_ports() {
        assert_eq!(split_image_ref("claude-box"), ("claude-box", None));
        assert_eq!(
            split_image_ref("claude-box:latest"),
            ("claude-box", Some("latest"))
        );
        assert_eq!(
            split_image_ref("ghcr.io:5000/team/img"),
            ("ghcr.io:5000/team/img", None)
        );
    }
}