use std::path::{Path, PathBuf};
use std::process::Command;
use std::time::Duration;
use ureq::config::{ConfigBuilder, RedirectAuthHeaders};
use ureq::http::{StatusCode, Uri};
use ureq::typestate::AgentScope;
const REPO_API_LATEST: &str = "https://api.github.com/repos/zakuro-ai/zc/releases/latest";
const REPO_CLONE_HOST: &str = "github.com/zakuro-ai/zc";
const OCTET_STREAM: &str = "application/octet-stream";
const MAX_BINARY_BYTES: u64 = 256 * 1024 * 1024;
const PRIVATE_RELEASES: &str = "zc releases are private. Sign in with `gh auth login` (or set GH_PAT / GITHUB_TOKEN) and run zc update again.";
const FROM_SOURCE_FALLBACK: &str = "Fallback: try building from source instead — `zc update --from-source` (it also needs a GitHub token with access to zakuro-ai/zc).";
fn asset_name() -> &'static str {
match (cfg!(target_os = "macos"), cfg!(target_arch = "aarch64")) {
(true, true) => "zc-darwin-arm64",
(true, false) => "zc-darwin-x86_64",
(false, true) => "zc-linux-arm64",
(false, false) => "zc-linux-x86_64",
}
}
const MIN_GNU_GLIBC: (u32, u32) = (2, 31);
fn choose_linux_asset(
arm64: bool,
has_nvidia: bool,
glibc: Option<(u32, u32)>,
assets: &[String],
) -> String {
let musl = if arm64 {
"zc-linux-arm64"
} else {
"zc-linux-x86_64"
};
let gnu = format!("{musl}-gnu");
let glibc_ok = glibc.is_some_and(|v| v >= MIN_GNU_GLIBC);
if has_nvidia && glibc_ok && assets.contains(&gnu) {
gnu
} else {
musl.to_string()
}
}
fn gpu_musl_fallback_reason(
arm64: bool,
has_nvidia: bool,
glibc: Option<(u32, u32)>,
assets: &[String],
) -> Option<&'static str> {
if !has_nvidia {
return None;
}
if glibc.is_none_or(|v| v < MIN_GNU_GLIBC) {
return Some("glibc < 2.31 or not detected");
}
let gnu = if arm64 {
"zc-linux-arm64-gnu"
} else {
"zc-linux-x86_64-gnu"
};
if !assets.iter().any(|a| a == gnu) {
return Some("no glibc asset in this release");
}
None
}
fn parse_glibc_version(ldd_output: &str) -> Option<(u32, u32)> {
let first = ldd_output.lines().next()?;
let lower = first.to_lowercase();
if !lower.contains("glibc") && !lower.contains("gnu libc") {
return None;
}
let ver = first.split_whitespace().last()?;
let mut it = ver.split('.');
let major = it.next()?.parse().ok()?;
let minor = it.next()?.parse().ok()?;
Some((major, minor))
}
#[cfg(target_os = "linux")]
fn host_glibc_version() -> Option<(u32, u32)> {
let out = Command::new("ldd").arg("--version").output().ok()?;
let mut text = String::from_utf8_lossy(&out.stdout).into_owned();
text.push_str(&String::from_utf8_lossy(&out.stderr));
parse_glibc_version(&text)
}
#[cfg(target_os = "linux")]
fn host_has_nvidia() -> bool {
if Path::new("/dev/nvidiactl").exists() {
return true;
}
if let Ok(out) = Command::new("ldconfig").arg("-p").output() {
if String::from_utf8_lossy(&out.stdout).contains("libcuda.so.1") {
return true;
}
}
[
"/usr/lib/x86_64-linux-gnu",
"/usr/lib/aarch64-linux-gnu",
"/usr/lib64",
"/usr/lib",
"/usr/local/nvidia/lib64",
"/usr/lib/wsl/lib",
]
.iter()
.any(|d| Path::new(d).join("libcuda.so.1").exists())
}
fn asset_names(release: &serde_json::Value) -> Vec<String> {
release
.get("assets")
.and_then(|a| a.as_array())
.map(|a| {
a.iter()
.filter_map(|x| x.get("name").and_then(|n| n.as_str()).map(str::to_string))
.collect()
})
.unwrap_or_default()
}
fn asset_name_for(release: &serde_json::Value) -> String {
#[cfg(target_os = "linux")]
{
let arm64 = cfg!(target_arch = "aarch64");
let (nvidia, glibc, assets) = (
host_has_nvidia(),
host_glibc_version(),
asset_names(release),
);
if let Some(reason) = gpu_musl_fallback_reason(arm64, nvidia, glibc, &assets) {
println!(
"GPU host but using the musl build ({reason}): GPU benchmarking/CUDA unavailable"
);
}
choose_linux_asset(arm64, nvidia, glibc, &assets)
}
#[cfg(not(target_os = "linux"))]
{
let _ = release;
asset_name().to_string()
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Mode {
PrebuiltRelease,
FromSource,
}
pub fn parse_mode(args: &[String]) -> Mode {
if args.iter().any(|a| a == "--from-source") {
Mode::FromSource
} else {
Mode::PrebuiltRelease
}
}
pub fn resolve_token<F1, F2>(try_gh: F1, get_env: F2) -> Option<String>
where
F1: FnOnce() -> Option<String>,
F2: Fn(&str) -> Option<String>,
{
if let Some(t) = try_gh() {
if !t.trim().is_empty() {
return Some(t.trim().to_string());
}
}
if let Some(t) = get_env("GH_PAT") {
if !t.trim().is_empty() {
return Some(t.trim().to_string());
}
}
if let Some(t) = get_env("GITHUB_TOKEN") {
if !t.trim().is_empty() {
return Some(t.trim().to_string());
}
}
None
}
fn gh_auth_token() -> Option<String> {
let out = Command::new("gh").args(["auth", "token"]).output().ok()?;
if !out.status.success() {
return None;
}
let token = String::from_utf8_lossy(&out.stdout).trim().to_string();
if token.is_empty() {
None
} else {
Some(token)
}
}
fn real_env(key: &str) -> Option<String> {
std::env::var(key).ok()
}
pub fn run_cli(args: &[String]) -> i32 {
match parse_mode(args) {
Mode::PrebuiltRelease => update_from_release(),
Mode::FromSource => update_from_source(),
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum InstallChoice {
Gnu,
Musl,
KeepOld,
}
fn decide_install(gnu_ok: Option<bool>, musl_ok: Option<bool>) -> InstallChoice {
if gnu_ok == Some(true) {
InstallChoice::Gnu
} else if musl_ok == Some(true) {
InstallChoice::Musl
} else {
InstallChoice::KeepOld
}
}
pub(crate) fn binary_runs(exe_path: &Path, bytes: &[u8]) -> bool {
let dir = exe_path.parent().unwrap_or_else(|| Path::new("."));
let probe: PathBuf = dir.join(format!(".zc-update-verify-{}.tmp", std::process::id()));
if std::fs::write(&probe, bytes).is_err() {
return false;
}
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
if std::fs::set_permissions(&probe, std::fs::Permissions::from_mode(0o755)).is_err() {
let _ = std::fs::remove_file(&probe);
return false;
}
}
let ok = match Command::new(&probe)
.arg("--version")
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.spawn()
{
Ok(mut child) => {
let deadline = std::time::Instant::now() + Duration::from_secs(10);
loop {
match child.try_wait() {
Ok(Some(status)) => break status.success(),
Ok(None) if std::time::Instant::now() < deadline => {
std::thread::sleep(Duration::from_millis(50));
}
_ => {
let _ = child.kill();
let _ = child.wait();
break false;
}
}
}
}
Err(_) => false,
};
let _ = std::fs::remove_file(&probe);
ok
}
pub(crate) fn binary_version(exe_path: &Path, bytes: &[u8]) -> Option<String> {
let dir = exe_path.parent().unwrap_or_else(|| Path::new("."));
let probe: PathBuf = dir.join(format!(".zc-update-version-{}.tmp", std::process::id()));
std::fs::write(&probe, bytes).ok()?;
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
if std::fs::set_permissions(&probe, std::fs::Permissions::from_mode(0o755)).is_err() {
let _ = std::fs::remove_file(&probe);
return None;
}
}
let child = Command::new(&probe)
.arg("--version")
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::null())
.spawn();
let out = match child {
Ok(mut c) => {
let deadline = std::time::Instant::now() + Duration::from_secs(10);
loop {
match c.try_wait() {
Ok(Some(_)) => break c.wait_with_output().ok(),
Ok(None) if std::time::Instant::now() < deadline => {
std::thread::sleep(Duration::from_millis(50));
}
_ => {
let _ = c.kill();
let _ = c.wait();
break None;
}
}
}
}
Err(_) => None,
};
let _ = std::fs::remove_file(&probe);
parse_version_output(&String::from_utf8_lossy(&out?.stdout))
}
pub(crate) fn parse_version_output(text: &str) -> Option<String> {
let mut it = text.lines().next()?.split_whitespace();
(it.next()? == "zc" && it.next()? == "version").then_some(())?;
it.next().map(str::to_string)
}
pub(crate) fn replace_binary_atomic(exe_path: &Path, bytes: &[u8]) -> std::io::Result<()> {
let dir = exe_path.parent().unwrap_or_else(|| Path::new("."));
let tmp_path: PathBuf = dir.join(format!(".zc-update-{}.tmp", std::process::id()));
std::fs::write(&tmp_path, bytes)?;
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
std::fs::set_permissions(&tmp_path, std::fs::Permissions::from_mode(0o755))?;
}
std::fs::rename(&tmp_path, exe_path)?;
Ok(())
}
fn current_exe_or_bail() -> Option<PathBuf> {
match std::env::current_exe() {
Ok(p) => Some(p),
Err(e) => {
eprintln!(
"Error: could not determine the current executable path: {}",
e
);
None
}
}
}
pub(crate) fn dir_writable(dir: &Path) -> bool {
let probe = dir.join(format!(".zc-write-probe-{}", std::process::id()));
match std::fs::File::create(&probe) {
Ok(_) => {
let _ = std::fs::remove_file(&probe);
true
}
Err(_) => false,
}
}
fn local_bin_zc() -> PathBuf {
let home = std::env::var("HOME").unwrap_or_else(|_| ".".into());
PathBuf::from(home).join(".local").join("bin").join("zc")
}
fn resolve_install_target() -> (PathBuf, bool) {
if let Ok(exe) = std::env::current_exe() {
if let Some(dir) = exe.parent() {
if dir_writable(dir) {
return (exe, false);
}
}
}
(local_bin_zc(), true)
}
fn append_line_once(path: &Path, line: &str) -> std::io::Result<bool> {
let existing = std::fs::read_to_string(path).unwrap_or_default();
if existing.lines().any(|l| l.trim() == line.trim()) {
return Ok(false);
}
use std::io::Write;
let mut f = std::fs::OpenOptions::new()
.create(true)
.append(true)
.open(path)?;
let sep = if existing.is_empty() || existing.ends_with('\n') {
""
} else {
"\n"
};
writeln!(
f,
"{}# added by `zc update` — put ~/.local/bin on PATH\n{}",
sep, line
)?;
Ok(true)
}
fn shell_rc_path() -> Option<PathBuf> {
let home = std::env::var("HOME").ok()?;
let shell = std::env::var("SHELL").unwrap_or_default();
let file = if shell.contains("zsh") {
".zshrc"
} else if shell.contains("bash") {
".bashrc"
} else {
".profile"
};
Some(PathBuf::from(home).join(file))
}
fn ensure_local_bin_on_path(installed: &Path) {
let bin_dir = installed
.parent()
.map(|p| p.display().to_string())
.unwrap_or_default();
let on_path = std::env::var("PATH")
.map(|p| p.split(':').any(|d| d == bin_dir))
.unwrap_or(false);
if on_path {
println!("Installed to {}.", installed.display());
println!("Run `hash -r` (or open a new terminal) so your shell uses the new binary.");
return;
}
let export = "export PATH=\"$HOME/.local/bin:$PATH\"".to_string();
let appended = shell_rc_path().and_then(|rc| {
let ok = append_line_once(&rc, &export).unwrap_or(false);
ok.then_some(rc)
});
println!("Installed to {}.", installed.display());
match appended {
Some(rc) => {
println!("Added ~/.local/bin to your PATH in {}.", rc.display());
println!(
"Open a new terminal (or `source {}`) and run `zc`.",
rc.display()
);
}
None => {
println!("Add ~/.local/bin to your PATH so `zc` is found:");
println!(" {}", export);
}
}
}
#[derive(Debug, PartialEq, Eq)]
struct AssetSource {
url: String,
accept: &'static str,
}
fn select_asset(release: &serde_json::Value, name: &str) -> Option<AssetSource> {
let asset = release
.get("assets")?
.as_array()?
.iter()
.find(|a| a.get("name").and_then(|n| n.as_str()) == Some(name))?;
let field = |key: &str| asset.get(key).and_then(|v| v.as_str()).map(str::to_string);
match field("url") {
Some(url) => Some(AssetSource {
url,
accept: OCTET_STREAM,
}),
None => field("browser_download_url").map(|url| AssetSource { url, accept: "*/*" }),
}
}
fn token_for<'a>(url: &str, token: Option<&'a str>) -> Option<&'a str> {
let uri: Uri = url.parse().ok()?;
let github_api = uri.scheme_str() == Some("https")
&& uri
.host()
.is_some_and(|h| h.eq_ignore_ascii_case("api.github.com"));
token.filter(|_| github_api)
}
fn github_headers(accept: &str, token: Option<&str>) -> Vec<(&'static str, String)> {
let mut headers = vec![
("User-Agent", "zc-update".to_string()),
("Accept", accept.to_string()),
];
if let Some(t) = token {
headers.push(("Authorization", format!("Bearer {t}")));
}
headers
}
fn api_config() -> ConfigBuilder<AgentScope> {
ureq::Agent::config_builder()
.timeout_connect(Some(Duration::from_secs(10)))
.timeout_global(Some(Duration::from_secs(30)))
.http_status_as_error(false)
}
fn download_config() -> ConfigBuilder<AgentScope> {
ureq::Agent::config_builder()
.timeout_connect(Some(Duration::from_secs(10)))
.timeout_global(Some(Duration::from_secs(300)))
.http_status_as_error(false)
.redirect_auth_headers(RedirectAuthHeaders::Never)
}
fn api_status_message(status: StatusCode, have_token: bool) -> String {
if status != StatusCode::NOT_FOUND {
format!("GitHub releases API returned HTTP {status}\n{FROM_SOURCE_FALLBACK}")
} else if !have_token {
PRIVATE_RELEASES.to_string()
} else {
format!(
"GitHub releases API returned HTTP {status}: the GitHub token zc found may not have access to zakuro-ai/zc (the repo is private), or there is no release yet.\n\
Check its account with `gh auth status`; zc uses gh's token first, then GH_PAT, then GITHUB_TOKEN.\n\
{FROM_SOURCE_FALLBACK}"
)
}
}
fn download(
agent: &ureq::Agent,
src: &AssetSource,
token: Option<&str>,
) -> Result<Vec<u8>, String> {
let mut req = agent.get(&src.url);
for (name, value) in github_headers(src.accept, token) {
req = req.header(name, value);
}
let resp = req
.call()
.map_err(|e| format!("Failed to download release asset: {e}"))?;
if resp.status() != StatusCode::OK {
return Err(format!("Download failed: HTTP {}", resp.status()));
}
resp.into_body()
.with_config()
.limit(MAX_BINARY_BYTES)
.read_to_vec()
.map_err(|e| format!("Failed to read downloaded binary: {e}"))
}
pub(crate) const MIRROR_BASE: &str = "https://get.zakuro-ai.com/zc";
pub(crate) const ENV_UPDATE_URL: &str = "ZAKURO_UPDATE_URL";
pub(crate) fn normalize_mirror_base(raw: &str) -> Result<String, String> {
let mut b = raw.trim().trim_end_matches('/').to_string();
let rest = if let Some(r) = b.strip_prefix("https://") {
r
} else if let Some(r) = b.strip_prefix("http://") {
let host = r.split(['/', ':']).next().unwrap_or("");
if host != "127.0.0.1" && host != "localhost" {
return Err(format!("{ENV_UPDATE_URL} must be https:// (got {raw:?})"));
}
r
} else {
return Err(format!(
"{ENV_UPDATE_URL} must be an https:// URL (got {raw:?})"
));
};
if rest.is_empty() || rest.starts_with('/') {
return Err(format!("{ENV_UPDATE_URL} has no host (got {raw:?})"));
}
if !(b.ends_with("/zc")) {
b.push_str("/zc");
}
Ok(b)
}
pub(crate) fn mirror_base() -> Result<String, String> {
match crate::profile::resolve().mirror_base {
(v, crate::profile::Source::Override(_)) => normalize_mirror_base(&v),
(v, crate::profile::Source::Profile) => Ok(v),
}
}
#[allow(dead_code)]
fn release_signing_pubkey() -> &'static str {
crate::profile::active().update_trust_root
}
#[derive(Debug, PartialEq, Eq)]
pub(crate) enum MirrorError {
Unreachable(String),
Unsupported(String),
Integrity(String),
Other(String),
}
#[derive(Debug, PartialEq, Eq)]
pub(crate) enum FetchError {
Transport(String),
Status(u16),
}
pub(crate) trait Fetcher {
fn get(&self, url: &str) -> Result<Vec<u8>, FetchError>;
}
pub(crate) struct UreqFetcher(ureq::Agent, String);
impl UreqFetcher {
pub(crate) fn new() -> Self {
Self::with_user_agent("zc-update")
}
pub(crate) fn with_user_agent(ua: &str) -> Self {
Self(
ureq::Agent::new_with_config(download_config().build()),
ua.to_string(),
)
}
}
impl Fetcher for UreqFetcher {
fn get(&self, url: &str) -> Result<Vec<u8>, FetchError> {
let resp = self
.0
.get(url)
.header("User-Agent", self.1.as_str())
.call()
.map_err(|e| FetchError::Transport(e.to_string()))?;
if resp.status() != StatusCode::OK {
return Err(FetchError::Status(resp.status().as_u16()));
}
resp.into_body()
.with_config()
.limit(MAX_BINARY_BYTES)
.read_to_vec()
.map_err(|e| FetchError::Transport(e.to_string()))
}
}
#[derive(Debug, PartialEq, Eq)]
pub(crate) struct Manifest {
pub(crate) version: String,
sha256: String,
}
pub(crate) fn parse_manifest(body: &[u8]) -> Result<Manifest, String> {
let v: serde_json::Value =
serde_json::from_slice(body).map_err(|e| format!("invalid manifest JSON: {e}"))?;
let field = |k: &str| {
v.get(k)
.and_then(|x| x.as_str())
.map(str::trim)
.filter(|x| !x.is_empty())
.map(str::to_string)
.ok_or_else(|| format!("manifest has no \"{k}\""))
};
let version = field("version")?;
let sha256 = field("sha256")?.to_ascii_lowercase();
if parse_version(&version).is_none()
|| !version
.chars()
.all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '+' | '_'))
{
return Err(format!(
"manifest version {version:?} is not a release version"
));
}
if sha256.len() != 64 || !sha256.chars().all(|c| c.is_ascii_hexdigit()) {
return Err("manifest sha256 is not 64 hex characters".to_string());
}
Ok(Manifest { version, sha256 })
}
fn parse_version(v: &str) -> Option<(u64, u64, u64)> {
let core = v.trim().trim_start_matches('v');
let core = core.split(['-', '+']).next()?;
let mut it = core.split('.');
let t = (
it.next()?.parse().ok()?,
it.next()?.parse().ok()?,
it.next()?.parse().ok()?,
);
it.next().is_none().then_some(t)
}
fn is_newer(candidate: &str, current: &str) -> Result<bool, String> {
match (parse_version(candidate), parse_version(current)) {
(Some(c), Some(cur)) => Ok(c > cur),
_ => Err(format!(
"cannot compare versions {candidate:?} and {current:?}"
)),
}
}
fn mirror_platforms(
macos: bool,
arm64: bool,
has_nvidia: bool,
glibc: Option<(u32, u32)>,
) -> Option<Vec<String>> {
match (macos, arm64) {
(true, true) => Some(vec!["darwin_arm64".to_string()]),
(true, false) => None,
(false, _) => {
let base = if arm64 { "linux_arm64" } else { "linux_amd64" };
let mut v = Vec::new();
if has_nvidia && glibc.is_some_and(|g| g >= MIN_GNU_GLIBC) {
v.push(format!("{base}_gnu"));
}
v.push(base.to_string());
Some(v)
}
}
}
pub(crate) fn host_mirror_platforms() -> Option<Vec<String>> {
#[cfg(target_os = "linux")]
let (nvidia, glibc) = (host_has_nvidia(), host_glibc_version());
#[cfg(not(target_os = "linux"))]
let (nvidia, glibc) = (false, None);
mirror_platforms(
cfg!(target_os = "macos"),
cfg!(target_arch = "aarch64"),
nvidia,
glibc,
)
}
#[derive(Debug, PartialEq, Eq)]
pub(crate) enum MirrorOutcome {
UpToDate(String),
Installed { version: String, platform: String },
}
fn verify_sha256(what: &str, bytes: &[u8], expected: &str) -> Result<(), String> {
let actual = crate::dataset::sha256_hex(bytes);
if actual.eq_ignore_ascii_case(expected.trim()) {
Ok(())
} else {
Err(format!(
"{what}: sha256 mismatch (expected {expected}, got {actual}); refusing to install"
))
}
}
pub(crate) fn update_via_mirror(
fetch: &dyn Fetcher,
base: &str,
platforms: &[String],
current: &str,
exe_path: &Path,
runs: &dyn Fn(&Path, &[u8]) -> bool,
) -> Result<MirrorOutcome, MirrorError> {
let mut last = MirrorError::Unsupported(format!("no mirror build for {platforms:?}"));
for (i, platform) in platforms.iter().enumerate() {
let is_last = i + 1 == platforms.len();
let murl = format!("{base}/manifest/{platform}");
let body = match fetch.get(&murl) {
Ok(b) => b,
Err(FetchError::Status(400 | 404)) => {
last = MirrorError::Unsupported(format!(
"the mirror has no {platform} build (HTTP 404)"
));
continue;
}
Err(FetchError::Status(s)) => {
return Err(MirrorError::Unreachable(format!("{murl}: HTTP {s}")))
}
Err(FetchError::Transport(e)) => {
return Err(MirrorError::Unreachable(format!("{murl}: {e}")))
}
};
let m = parse_manifest(&body)
.map_err(|e| MirrorError::Other(format!("{platform} manifest: {e}")))?;
if !is_newer(&m.version, current).map_err(MirrorError::Other)? {
return Ok(MirrorOutcome::UpToDate(current.to_string()));
}
println!("Downloading zc {} ({platform})...", m.version);
let durl = format!("{base}/download/{platform}?version={}", m.version);
let bytes = fetch.get(&durl).map_err(|e| match e {
FetchError::Transport(e) => MirrorError::Unreachable(format!("{durl}: {e}")),
FetchError::Status(s) => MirrorError::Unreachable(format!("{durl}: HTTP {s}")),
})?;
verify_sha256(&format!("{platform} {}", m.version), &bytes, &m.sha256)
.map_err(MirrorError::Integrity)?;
if !runs(exe_path, &bytes) {
let msg = format!("the {platform} build does not run on this host");
if !is_last {
eprintln!("{msg}; trying the next build.");
}
last = MirrorError::Other(msg);
continue;
}
println!("Installing to {}...", exe_path.display());
replace_binary_atomic(exe_path, &bytes)
.map_err(|e| MirrorError::Other(format!("Failed to install the new binary: {e}")))?;
return Ok(MirrorOutcome::Installed {
version: m.version,
platform: platform.clone(),
});
}
Err(last)
}
#[derive(Debug, PartialEq, Eq)]
enum Fallback {
GitHub,
Fail(String),
}
fn fallback_decision(err: &MirrorError, has_token: bool) -> Fallback {
match err {
MirrorError::Integrity(m) | MirrorError::Other(m) => Fallback::Fail(m.clone()),
MirrorError::Unreachable(m) | MirrorError::Unsupported(m) => {
if has_token {
Fallback::GitHub
} else {
Fallback::Fail(format!(
"{m}\nCould not update from get.zakuro-ai.com and no GitHub token was found for the fallback. Try again later, or re-run the installer: curl -fsSL https://get.zakuro-ai.com/zc | bash"
))
}
}
}
}
fn asset_digest(release: &serde_json::Value, name: &str) -> Option<String> {
release
.get("assets")?
.as_array()?
.iter()
.find(|a| a.get("name").and_then(|n| n.as_str()) == Some(name))?
.get("digest")?
.as_str()?
.strip_prefix("sha256:")
.map(str::to_string)
}
fn verify_asset_digest(
release: &serde_json::Value,
name: &str,
bytes: &[u8],
) -> Result<(), String> {
match asset_digest(release, name) {
Some(d) => verify_sha256(name, bytes, &d),
None => Err(format!(
"{name}: the release publishes no sha256 digest for it; refusing to install an unverified binary"
)),
}
}
fn update_from_release() -> i32 {
let base = match mirror_base() {
Ok(b) => b,
Err(e) => {
eprintln!("{e}");
return 1;
}
};
let host = base
.trim_start_matches("https://")
.trim_start_matches("http://")
.trim_end_matches("/zc");
println!("Checking latest zc release ({host})...");
if base != MIRROR_BASE {
let from = match crate::profile::resolve().mirror_base.1 {
crate::profile::Source::Override(v) => v.to_string(),
crate::profile::Source::Profile => {
format!("{} profile", crate::profile::active().env.name())
}
};
println!("Using mirror {base} ({from})");
}
let platforms = host_mirror_platforms();
let (exe_path, to_local_bin) = resolve_install_target();
if let Some(parent) = exe_path.parent() {
let _ = std::fs::create_dir_all(parent);
}
let result = match &platforms {
Some(p) => update_via_mirror(
&UreqFetcher::new(),
&base,
p,
env!("CARGO_PKG_VERSION"),
&exe_path,
&binary_runs,
),
None => Err(MirrorError::Unsupported(
"get.zakuro-ai.com has no build for this OS/architecture".to_string(),
)),
};
match result {
Ok(MirrorOutcome::UpToDate(v)) => {
println!("zc {v} is already up to date.");
0
}
Ok(MirrorOutcome::Installed { version, .. }) => {
if to_local_bin {
ensure_local_bin_on_path(&exe_path);
}
println!("updated to {}", version);
0
}
Err(e) if !crate::profile::active().github_update_fallback => {
let (MirrorError::Unreachable(m)
| MirrorError::Unsupported(m)
| MirrorError::Integrity(m)
| MirrorError::Other(m)) = &e;
eprintln!("{m}");
eprintln!(
"No GitHub fallback under the {} profile.",
crate::profile::active().env.name()
);
1
}
Err(e) => {
let token = if matches!(e, MirrorError::Integrity(_) | MirrorError::Other(_)) {
None
} else {
resolve_token(gh_auth_token, real_env)
};
match fallback_decision(&e, token.is_some()) {
Fallback::GitHub => {
if let MirrorError::Unreachable(m) | MirrorError::Unsupported(m) = &e {
eprintln!("{m}");
}
eprintln!("Falling back to the GitHub releases (token found).");
update_from_github(token)
}
Fallback::Fail(m) => {
eprintln!("{m}");
1
}
}
}
}
}
fn update_from_github(token: Option<String>) -> i32 {
println!("Checking latest zc release on GitHub...");
let api = ureq::Agent::new_with_config(api_config().build());
let mut req = api.get(REPO_API_LATEST);
let api_token = token_for(REPO_API_LATEST, token.as_deref());
for (name, value) in github_headers("application/vnd.github+json", api_token) {
req = req.header(name, value);
}
let resp = match req.call() {
Ok(r) => r,
Err(e) => {
eprintln!("Failed to reach GitHub releases API: {}", e);
eprintln!("{FROM_SOURCE_FALLBACK}");
return 1;
}
};
if resp.status() != StatusCode::OK {
eprintln!("{}", api_status_message(resp.status(), api_token.is_some()));
return 1;
}
let body = match resp.into_body().read_to_string() {
Ok(s) => s,
Err(e) => {
eprintln!("Failed to read releases API response: {}", e);
return 1;
}
};
let data: serde_json::Value = match serde_json::from_str(&body) {
Ok(v) => v,
Err(e) => {
eprintln!("Failed to parse releases API response: {}", e);
return 1;
}
};
let version = data
.get("tag_name")
.and_then(|v| v.as_str())
.unwrap_or("unknown")
.to_string();
let asset = asset_name_for(&data);
let src = match select_asset(&data, &asset) {
Some(s) => s,
None => {
eprintln!("No {} asset found on release {}.", asset, version);
eprintln!("{FROM_SOURCE_FALLBACK}");
return 1;
}
};
println!("Downloading {} ({})...", asset, version);
let downloader = ureq::Agent::new_with_config(download_config().build());
let bytes = match download(&downloader, &src, token_for(&src.url, token.as_deref())) {
Ok(b) => b,
Err(e) => {
eprintln!("{e}");
eprintln!("{FROM_SOURCE_FALLBACK}");
return 1;
}
};
if let Err(e) = verify_asset_digest(&data, &asset, &bytes) {
eprintln!("{e}");
return 1;
}
let (exe_path, to_local_bin) = resolve_install_target();
if let Some(parent) = exe_path.parent() {
let _ = std::fs::create_dir_all(parent);
}
let primary_ok = binary_runs(&exe_path, &bytes);
let is_gnu = asset.ends_with("-gnu");
let mut musl_bytes: Option<Vec<u8>> = None;
let mut musl_ok = None;
if !primary_ok {
if is_gnu {
eprintln!("The {asset} build does not run on this host; falling back to musl.");
let musl_name = asset.trim_end_matches("-gnu");
musl_bytes = select_asset(&data, musl_name)
.and_then(|m| download(&downloader, &m, token_for(&m.url, token.as_deref())).ok())
.filter(|b| verify_asset_digest(&data, musl_name, b).is_ok());
musl_ok = Some(
musl_bytes
.as_ref()
.is_some_and(|b| binary_runs(&exe_path, b)),
);
} else {
musl_ok = Some(false);
}
}
let (choice, install_bytes) = if is_gnu {
(decide_install(Some(primary_ok), musl_ok), &bytes)
} else {
(decide_install(None, Some(primary_ok)), &bytes)
};
let to_install: &[u8] = match choice {
InstallChoice::Gnu => install_bytes,
InstallChoice::Musl if is_gnu => musl_bytes.as_deref().unwrap_or_default(),
InstallChoice::Musl => install_bytes,
InstallChoice::KeepOld => {
eprintln!(
"The downloaded binary does not run on this host; keeping the existing zc ({}).",
exe_path.display()
);
eprintln!("{FROM_SOURCE_FALLBACK}");
return 1;
}
};
println!("Installing to {}...", exe_path.display());
if let Err(e) = replace_binary_atomic(&exe_path, to_install) {
eprintln!("Failed to install the new binary: {}", e);
return 1;
}
if to_local_bin {
ensure_local_bin_on_path(&exe_path);
}
println!("updated to {}", version);
0
}
fn update_from_source() -> i32 {
let token = match resolve_token(gh_auth_token, real_env) {
Some(t) => t,
None => {
eprintln!("no GitHub token found; run `gh auth login` or set GH_PAT/GITHUB_TOKEN");
return 1;
}
};
let (exe_path, to_local_bin) = resolve_install_target();
if let Some(parent) = exe_path.parent() {
let _ = std::fs::create_dir_all(parent);
}
let tmp_dir = std::env::temp_dir().join(format!("zc-update-src-{}", std::process::id()));
if let Err(e) = std::fs::create_dir_all(&tmp_dir) {
eprintln!("Failed to create temp dir {}: {}", tmp_dir.display(), e);
return 1;
}
println!("Cloning zakuro-ai/zc (source build)...");
let clone_url = format!("https://x-access-token:{}@{}", token, REPO_CLONE_HOST);
let clone_status = Command::new("git")
.args(["clone", "--depth", "1", &clone_url, "."])
.current_dir(&tmp_dir)
.status();
match clone_status {
Ok(s) if s.success() => {}
Ok(s) => {
eprintln!("git clone failed (exit {}).", s);
let _ = std::fs::remove_dir_all(&tmp_dir);
return 1;
}
Err(e) => {
eprintln!("Failed to run git clone: {}", e);
let _ = std::fs::remove_dir_all(&tmp_dir);
return 1;
}
}
println!("Building (cargo build --release)... this can take a few minutes.");
let (prog, pre_args) = cargo_invocation();
let build_output = Command::new(&prog)
.args(pre_args.iter().map(String::as_str))
.args(["build", "--release"])
.current_dir(&tmp_dir)
.output();
let build_output = match build_output {
Ok(o) => o,
Err(e) => {
eprintln!("Failed to run cargo build: {}", e);
let _ = std::fs::remove_dir_all(&tmp_dir);
return 1;
}
};
if !build_output.status.success() {
let stderr = String::from_utf8_lossy(&build_output.stderr);
let tail: String = stderr
.lines()
.rev()
.take(30)
.collect::<Vec<_>>()
.into_iter()
.rev()
.collect::<Vec<_>>()
.join("\n");
eprintln!("cargo build --release failed. Build output (tail):");
eprintln!("{}", tail);
if stderr.contains("lock file version") {
eprintln!();
eprintln!(
"This is a toolchain problem, not a code problem: the cargo that ran is\n\
too old to read this repo's Cargo.lock (v4 needs Rust >= 1.78).\n\
Install rustup so the pinned `stable` toolchain is used, or run the\n\
build yourself with a newer cargo:\n\
\n\
\trustup run stable cargo build --release"
);
}
let _ = std::fs::remove_dir_all(&tmp_dir);
return 1;
}
let mut built_bin: Option<PathBuf> = None;
for c in ["zc", "zc2"] {
let p = tmp_dir.join("target/release").join(c);
if p.is_file() {
built_bin = Some(p);
break;
}
}
let built_bin = match built_bin {
Some(p) => p,
None => {
eprintln!("Build finished but no zc binary found under target/release/.");
let _ = std::fs::remove_dir_all(&tmp_dir);
return 1;
}
};
let bytes = match std::fs::read(&built_bin) {
Ok(b) => b,
Err(e) => {
eprintln!("Failed to read built binary: {}", e);
let _ = std::fs::remove_dir_all(&tmp_dir);
return 1;
}
};
println!("Installing to {}...", exe_path.display());
if let Err(e) = replace_binary_atomic(&exe_path, &bytes) {
eprintln!("Failed to install the new binary: {}", e);
let _ = std::fs::remove_dir_all(&tmp_dir);
return 1;
}
if to_local_bin {
ensure_local_bin_on_path(&exe_path);
}
let version = Command::new(&exe_path)
.arg("--version")
.output()
.ok()
.filter(|o| o.status.success())
.and_then(|o| {
String::from_utf8_lossy(&o.stdout)
.lines()
.next()
.map(|l| l.trim().to_string())
})
.unwrap_or_else(|| "source build".to_string());
let _ = std::fs::remove_dir_all(&tmp_dir);
println!("updated to {}", version);
0
}
fn cargo_invocation() -> (String, Vec<String>) {
let rustup_ok = Command::new("rustup")
.arg("--version")
.output()
.map(|o| o.status.success())
.unwrap_or(false);
if rustup_ok {
(
"rustup".to_string(),
["run", "stable", "cargo"]
.iter()
.map(|s| s.to_string())
.collect(),
)
} else {
("cargo".to_string(), Vec::new())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn append_line_once_is_idempotent() {
let dir = std::env::temp_dir().join(format!("zc-rc-test-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let rc = dir.join("rc");
let line = "export PATH=\"$HOME/.local/bin:$PATH\"";
assert!(super::append_line_once(&rc, line).unwrap()); assert!(!super::append_line_once(&rc, line).unwrap()); let body = std::fs::read_to_string(&rc).unwrap();
assert_eq!(body.matches(line).count(), 1);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn parse_mode_default_is_prebuilt_release() {
let args: Vec<String> = vec![];
assert_eq!(parse_mode(&args), Mode::PrebuiltRelease);
}
#[test]
fn parse_mode_other_flags_still_prebuilt_release() {
let args: Vec<String> = vec!["--verbose".to_string()];
assert_eq!(parse_mode(&args), Mode::PrebuiltRelease);
}
#[test]
fn parse_mode_from_source_flag_selects_source_build() {
let args: Vec<String> = vec!["--from-source".to_string()];
assert_eq!(parse_mode(&args), Mode::FromSource);
}
#[test]
fn parse_mode_from_source_among_other_args() {
let args: Vec<String> = vec!["--verbose".to_string(), "--from-source".to_string()];
assert_eq!(parse_mode(&args), Mode::FromSource);
}
#[test]
fn resolve_token_prefers_gh() {
let t = resolve_token(
|| Some("gh-token".to_string()),
|k| match k {
"GH_PAT" => Some("pat-token".to_string()),
"GITHUB_TOKEN" => Some("gh-env-token".to_string()),
_ => None,
},
);
assert_eq!(t.as_deref(), Some("gh-token"));
}
#[test]
fn resolve_token_falls_back_to_gh_pat() {
let t = resolve_token(
|| None,
|k| match k {
"GH_PAT" => Some("pat-token".to_string()),
"GITHUB_TOKEN" => Some("gh-env-token".to_string()),
_ => None,
},
);
assert_eq!(t.as_deref(), Some("pat-token"));
}
#[test]
fn resolve_token_falls_back_to_github_token() {
let t = resolve_token(
|| None,
|k| match k {
"GH_PAT" => None,
"GITHUB_TOKEN" => Some("gh-env-token".to_string()),
_ => None,
},
);
assert_eq!(t.as_deref(), Some("gh-env-token"));
}
#[test]
fn resolve_token_none_found() {
let t = resolve_token(|| None, |_k| None);
assert_eq!(t, None);
}
#[test]
fn resolve_token_skips_blank_values() {
let t = resolve_token(
|| Some(" ".to_string()),
|k| match k {
"GH_PAT" => Some("".to_string()),
"GITHUB_TOKEN" => Some("real-token".to_string()),
_ => None,
},
);
assert_eq!(t.as_deref(), Some("real-token"));
}
fn names(v: &[&str]) -> Vec<String> {
v.iter().map(|s| s.to_string()).collect()
}
#[test]
fn linux_gpu_host_with_new_enough_glibc_gets_the_gnu_build() {
let assets = names(&["zc-linux-x86_64", "zc-linux-x86_64-gnu"]);
assert_eq!(
choose_linux_asset(false, true, Some((2, 35)), &assets),
"zc-linux-x86_64-gnu"
);
let assets = names(&["zc-linux-arm64", "zc-linux-arm64-gnu"]);
assert_eq!(
choose_linux_asset(true, true, Some((2, 31)), &assets),
"zc-linux-arm64-gnu"
);
}
#[test]
fn linux_keeps_musl_without_a_gpu_or_with_old_or_unknown_glibc() {
let assets = names(&["zc-linux-x86_64", "zc-linux-x86_64-gnu"]);
assert_eq!(
choose_linux_asset(false, false, Some((2, 39)), &assets),
"zc-linux-x86_64"
);
assert_eq!(
choose_linux_asset(false, true, Some((2, 28)), &assets),
"zc-linux-x86_64"
);
assert_eq!(
choose_linux_asset(false, true, None, &assets),
"zc-linux-x86_64"
);
}
#[test]
fn linux_falls_back_to_musl_when_the_release_has_no_gnu_asset() {
let assets = names(&["zc-linux-x86_64", "zc-linux-arm64"]);
assert_eq!(
choose_linux_asset(false, true, Some((2, 39)), &assets),
"zc-linux-x86_64"
);
assert_eq!(
choose_linux_asset(true, true, Some((2, 39)), &assets),
"zc-linux-arm64"
);
}
#[test]
fn install_decision_never_replaces_with_a_binary_that_does_not_run() {
use InstallChoice::*;
assert_eq!(decide_install(Some(true), None), Gnu);
assert_eq!(decide_install(Some(true), Some(true)), Gnu);
assert_eq!(decide_install(Some(false), Some(true)), Musl);
assert_eq!(decide_install(Some(false), Some(false)), KeepOld);
assert_eq!(decide_install(Some(false), None), KeepOld);
assert_eq!(decide_install(None, Some(true)), Musl);
assert_eq!(decide_install(None, Some(false)), KeepOld);
}
#[test]
fn gpu_musl_fallback_is_explained_only_for_gpu_hosts() {
let with = names(&["zc-linux-x86_64", "zc-linux-x86_64-gnu"]);
let without = names(&["zc-linux-x86_64"]);
assert_eq!(
gpu_musl_fallback_reason(false, false, Some((2, 35)), &without),
None
);
assert_eq!(
gpu_musl_fallback_reason(false, true, Some((2, 35)), &with),
None
);
assert!(
gpu_musl_fallback_reason(false, true, Some((2, 35)), &without)
.unwrap()
.contains("no glibc asset")
);
assert!(gpu_musl_fallback_reason(false, true, Some((2, 28)), &with)
.unwrap()
.contains("glibc < 2.31"));
assert!(gpu_musl_fallback_reason(false, true, None, &with).is_some());
}
#[test]
fn glibc_version_is_parsed_from_ldd_output() {
assert_eq!(
parse_glibc_version("ldd (Ubuntu GLIBC 2.35-0ubuntu3.8) 2.35\nCopyright"),
Some((2, 35))
);
assert_eq!(parse_glibc_version("ldd (GNU libc) 2.31\n"), Some((2, 31)));
assert_eq!(
parse_glibc_version("musl libc (x86_64)\nVersion 1.2.5\n"),
None
);
assert_eq!(parse_glibc_version(""), None);
}
const API_ASSET: &str = "https://api.github.com/repos/zakuro-ai/zc/releases/assets/2";
const BROWSER_ASSET: &str =
"https://github.com/zakuro-ai/zc/releases/download/v0.0.26/zc-darwin-arm64";
#[test]
fn asset_selection_prefers_the_api_url_with_octet_stream() {
let release = serde_json::json!({ "tag_name": "v0.0.26", "assets": [
{
"name": "zc-linux-x86_64",
"url": "https://api.github.com/repos/zakuro-ai/zc/releases/assets/1",
"browser_download_url": "https://github.com/zakuro-ai/zc/releases/download/v0.0.26/zc-linux-x86_64",
},
{ "name": "zc-darwin-arm64", "url": API_ASSET, "browser_download_url": BROWSER_ASSET },
]});
assert_eq!(
select_asset(&release, "zc-darwin-arm64"),
Some(AssetSource {
url: API_ASSET.to_string(),
accept: "application/octet-stream",
})
);
assert_eq!(select_asset(&release, "zc-linux-arm64"), None);
}
#[test]
fn asset_selection_falls_back_to_the_browser_download_url() {
let release = serde_json::json!({ "assets": [
{ "name": "zc-darwin-arm64", "browser_download_url": BROWSER_ASSET },
]});
assert_eq!(
select_asset(&release, "zc-darwin-arm64"),
Some(AssetSource {
url: BROWSER_ASSET.to_string(),
accept: "*/*",
})
);
}
#[test]
fn a_token_becomes_an_authorization_header_on_github_requests_only() {
let with = github_headers(OCTET_STREAM, Some("t0ken"));
assert!(
with.contains(&("Authorization", "Bearer t0ken".to_string())),
"{with:?}"
);
assert!(
with.contains(&("Accept", OCTET_STREAM.to_string())),
"{with:?}"
);
assert!(
with.contains(&("User-Agent", "zc-update".to_string())),
"{with:?}"
);
let without = github_headers(OCTET_STREAM, None);
assert!(
without.iter().all(|(k, _)| *k != "Authorization"),
"{without:?}"
);
assert_eq!(
download_config().build().redirect_auth_headers(),
RedirectAuthHeaders::Never
);
}
#[test]
fn the_download_gets_300_s_and_the_api_call_30_s() {
assert_eq!(
download_config().build().timeouts().global,
Some(Duration::from_secs(300))
);
assert_eq!(
api_config().build().timeouts().global,
Some(Duration::from_secs(30))
);
}
#[test]
fn without_a_token_a_404_says_the_releases_are_private() {
assert_eq!(
api_status_message(StatusCode::NOT_FOUND, false),
"zc releases are private. Sign in with `gh auth login` (or set GH_PAT / GITHUB_TOKEN) and run zc update again."
);
for have_token in [false, true] {
let m = api_status_message(StatusCode::FORBIDDEN, have_token);
assert!(
m.starts_with("GitHub releases API returned HTTP 403 Forbidden\n"),
"{m}"
);
assert!(m.ends_with(FROM_SOURCE_FALLBACK), "{m}");
}
}
#[test]
fn with_a_token_a_404_says_it_may_lack_access_or_there_is_no_release() {
let m = api_status_message(StatusCode::NOT_FOUND, true);
for part in [
"HTTP 404 Not Found",
"may not have access to zakuro-ai/zc (the repo is private)",
"or there is no release yet",
"`gh auth status`",
"GH_PAT",
"GITHUB_TOKEN",
] {
assert!(m.contains(part), "missing {part:?} in: {m}");
}
assert!(m.ends_with(FROM_SOURCE_FALLBACK), "{m}");
}
#[test]
fn the_token_goes_to_api_github_com_only() {
let sends_token = |url: &str| {
github_headers(OCTET_STREAM, token_for(url, Some("t0ken")))
.iter()
.any(|(k, v)| *k == "Authorization" && v == "Bearer t0ken")
};
for url in [
REPO_API_LATEST,
API_ASSET,
"https://API.GitHub.com/repos/zakuro-ai/zc/releases/latest",
] {
assert!(sends_token(url), "{url} gets the token");
}
for url in [
BROWSER_ASSET, "https://objects.githubusercontent.com/github-production-release-asset/1?sig=x",
"https://api.github.com.evil.example/repos/zakuro-ai/zc", "https://evil.example/api.github.com/repos/zakuro-ai/zc", "https://api.github.com@evil.example/repos/zakuro-ai/zc", "http://api.github.com/repos/zakuro-ai/zc", "not a url",
] {
assert!(!sends_token(url), "{url} must not get the token");
}
assert_eq!(token_for(REPO_API_LATEST, None), None);
}
fn one_shot_server(response: Vec<u8>) -> (String, std::thread::JoinHandle<String>) {
use std::io::{Read, Write};
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let base = format!("http://{}", listener.local_addr().unwrap());
let handle = std::thread::spawn(move || {
let (mut s, _) = listener.accept().unwrap();
let mut head = Vec::new();
let mut b = [0u8; 1024];
while !head.windows(4).any(|w| w == b"\r\n\r\n") {
match s.read(&mut b) {
Ok(0) | Err(_) => break,
Ok(n) => head.extend_from_slice(&b[..n]),
}
}
s.write_all(&response).unwrap();
String::from_utf8_lossy(&head).into_owned()
});
(base, handle)
}
#[test]
fn the_download_follows_the_redirect_without_the_token() {
let blob = b"\x7fELF not really a zc binary".to_vec();
let mut ok = format!(
"HTTP/1.1 200 OK\r\nContent-Type: application/octet-stream\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
blob.len()
)
.into_bytes();
ok.extend_from_slice(&blob);
let (storage, storage_req) = one_shot_server(ok);
let (api, api_req) = one_shot_server(
format!(
"HTTP/1.1 302 Found\r\nLocation: {storage}/signed?sig=abc\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
)
.into_bytes(),
);
let agent = ureq::Agent::new_with_config(download_config().proxy(None).build());
let src = AssetSource {
url: format!("{api}/repos/zakuro-ai/zc/releases/assets/2"),
accept: OCTET_STREAM,
};
let bytes = download(&agent, &src, Some("t0ken")).expect("download succeeds");
assert_eq!(bytes, blob);
let api_req = api_req.join().unwrap().to_ascii_lowercase();
assert!(
api_req.contains("\r\nauthorization: bearer t0ken\r\n"),
"{api_req}"
);
assert!(
api_req.contains("\r\naccept: application/octet-stream\r\n"),
"{api_req}"
);
let storage_req = storage_req.join().unwrap().to_ascii_lowercase();
assert!(
storage_req.starts_with("get /signed?sig=abc http/1.1\r\n"),
"{storage_req}"
);
assert!(!storage_req.contains("authorization"), "{storage_req}");
}
use std::cell::RefCell;
use std::collections::HashMap;
struct MockFetcher {
routes: HashMap<String, Result<Vec<u8>, FetchError>>,
seen: RefCell<Vec<String>>,
}
impl MockFetcher {
fn new() -> Self {
Self {
routes: HashMap::new(),
seen: RefCell::new(vec![]),
}
}
fn ok(mut self, url: &str, body: &[u8]) -> Self {
self.routes.insert(url.to_string(), Ok(body.to_vec()));
self
}
fn status(mut self, url: &str, s: u16) -> Self {
self.routes
.insert(url.to_string(), Err(FetchError::Status(s)));
self
}
}
impl Fetcher for MockFetcher {
fn get(&self, url: &str) -> Result<Vec<u8>, FetchError> {
self.seen.borrow_mut().push(url.to_string());
match self.routes.get(url) {
Some(Ok(b)) => Ok(b.clone()),
Some(Err(FetchError::Status(s))) => Err(FetchError::Status(*s)),
Some(Err(FetchError::Transport(m))) => Err(FetchError::Transport(m.clone())),
None => Err(FetchError::Transport(format!("no route {url}"))),
}
}
}
const BASE: &str = "https://mirror.test/zc";
const NEW_BIN: &[u8] = b"new zc binary";
fn manifest_json(version: &str, bin: &[u8]) -> Vec<u8> {
serde_json::json!({
"version": version,
"sha256": crate::dataset::sha256_hex(bin),
"bin": "zc",
})
.to_string()
.into_bytes()
}
fn temp_exe(tag: &str) -> PathBuf {
let dir = std::env::temp_dir().join(format!("zc-mirror-test-{tag}-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let exe = dir.join("zc");
std::fs::write(&exe, b"old zc binary").unwrap();
exe
}
fn plats(p: &[&str]) -> Vec<String> {
p.iter().map(|s| s.to_string()).collect()
}
#[test]
fn manifest_parses_with_and_without_sig() {
let sha = "ab".repeat(32);
let m = parse_manifest(
format!(r#"{{"version":"0.0.35","sha256":"{sha}","bin":"zc","sig":"x"}}"#).as_bytes(),
)
.unwrap();
assert_eq!(m.version, "0.0.35");
assert_eq!(m.sha256, sha);
assert!(
parse_manifest(format!(r#"{{"version":"v0.0.35","sha256":"{sha}"}}"#).as_bytes())
.is_ok()
);
}
#[test]
fn manifest_rejects_bad_input() {
let sha = "ab".repeat(32);
assert!(parse_manifest(b"not json").is_err());
assert!(parse_manifest(br#"{"version":"0.0.35"}"#).is_err());
assert!(parse_manifest(format!(r#"{{"sha256":"{sha}"}}"#).as_bytes()).is_err());
assert!(parse_manifest(br#"{"version":"0.0.35","sha256":"abc"}"#).is_err());
let evil = format!(r#"{{"version":"0.0.35&x=1","sha256":"{sha}"}}"#);
assert!(parse_manifest(evil.as_bytes()).is_err());
}
#[test]
fn mirror_base_normalisation() {
let ok = |i: &str| normalize_mirror_base(i).unwrap();
assert_eq!(
ok("https://stg.get.zakuro-ai.com"),
"https://stg.get.zakuro-ai.com/zc"
);
assert_eq!(
ok("https://stg.get.zakuro-ai.com/"),
"https://stg.get.zakuro-ai.com/zc"
);
assert_eq!(
ok(" https://get.zakuro-ai.com/zc/ "),
"https://get.zakuro-ai.com/zc"
);
assert_eq!(ok("http://127.0.0.1:8080"), "http://127.0.0.1:8080/zc");
assert_eq!(ok("http://localhost/zc"), "http://localhost/zc");
assert!(normalize_mirror_base("http://evil.example/zc").is_err());
assert!(normalize_mirror_base("http://127.0.0.1.evil.com").is_err());
assert!(normalize_mirror_base("ftp://x").is_err());
assert!(normalize_mirror_base("get.zakuro-ai.com").is_err());
assert!(normalize_mirror_base("https://").is_err());
assert!(normalize_mirror_base("https:///zc").is_err());
}
#[test]
fn version_output_parsing() {
assert_eq!(
parse_version_output(
"zc version 0.0.39 (abc1234) built on 2026-10-08\nbinary sha256 ff"
),
Some("0.0.39".into())
);
assert_eq!(parse_version_output("other 1.0"), None);
assert_eq!(parse_version_output(""), None);
}
#[test]
fn version_compare() {
assert_eq!(parse_version("v0.0.35"), Some((0, 0, 35)));
assert_eq!(parse_version("1.2.3-rc1"), Some((1, 2, 3)));
assert_eq!(parse_version("1.2"), None);
assert_eq!(parse_version("1.2.3.4"), None);
assert_eq!(is_newer("0.0.35", "0.0.34"), Ok(true));
assert_eq!(is_newer("0.0.34", "0.0.34"), Ok(false));
assert_eq!(is_newer("0.0.33", "0.0.34"), Ok(false));
assert_eq!(is_newer("0.0.100", "0.0.34"), Ok(true));
assert_eq!(is_newer("v0.1.0", "0.0.99"), Ok(true));
assert!(is_newer("latest", "0.0.34").is_err());
}
#[test]
fn platform_mapping() {
assert_eq!(
mirror_platforms(true, true, false, None),
Some(plats(&["darwin_arm64"]))
);
assert_eq!(mirror_platforms(true, false, false, None), None);
assert_eq!(
mirror_platforms(false, false, false, None),
Some(plats(&["linux_amd64"]))
);
assert_eq!(
mirror_platforms(false, true, false, None),
Some(plats(&["linux_arm64"]))
);
assert_eq!(
mirror_platforms(false, false, true, Some((2, 35))),
Some(plats(&["linux_amd64_gnu", "linux_amd64"]))
);
assert_eq!(
mirror_platforms(false, true, true, Some((2, 31))),
Some(plats(&["linux_arm64_gnu", "linux_arm64"]))
);
assert_eq!(
mirror_platforms(false, false, true, Some((2, 28))),
Some(plats(&["linux_amd64"]))
);
assert_eq!(
mirror_platforms(false, false, true, None),
Some(plats(&["linux_amd64"]))
);
}
#[test]
fn mirror_update_installs_verified_binary() {
let exe = temp_exe("ok");
let f = MockFetcher::new()
.ok(
&format!("{BASE}/manifest/linux_amd64"),
&manifest_json("0.0.35", NEW_BIN),
)
.ok(
&format!("{BASE}/download/linux_amd64?version=0.0.35"),
NEW_BIN,
);
let out = update_via_mirror(
&f,
BASE,
&plats(&["linux_amd64"]),
"0.0.34",
&exe,
&|_, _| true,
);
assert_eq!(
out,
Ok(MirrorOutcome::Installed {
version: "0.0.35".into(),
platform: "linux_amd64".into()
})
);
assert_eq!(std::fs::read(&exe).unwrap(), NEW_BIN);
}
#[test]
fn mirror_update_sha256_mismatch_refuses_and_keeps_current_binary() {
let exe = temp_exe("mismatch");
let f = MockFetcher::new()
.ok(
&format!("{BASE}/manifest/linux_amd64"),
&manifest_json("0.0.35", NEW_BIN),
)
.ok(
&format!("{BASE}/download/linux_amd64?version=0.0.35"),
b"tampered",
);
let out = update_via_mirror(
&f,
BASE,
&plats(&["linux_amd64"]),
"0.0.34",
&exe,
&|_, _| true,
);
match out {
Err(MirrorError::Integrity(m)) => assert!(m.contains("sha256 mismatch"), "{m}"),
other => panic!("expected Integrity, got {other:?}"),
}
assert_eq!(std::fs::read(&exe).unwrap(), b"old zc binary");
}
#[test]
fn mirror_update_skips_when_up_to_date_or_newer_installed() {
for cur in ["0.0.35", "0.0.40"] {
let exe = temp_exe("uptodate");
let f = MockFetcher::new().ok(
&format!("{BASE}/manifest/linux_amd64"),
&manifest_json("0.0.35", NEW_BIN),
);
let out =
update_via_mirror(&f, BASE, &plats(&["linux_amd64"]), cur, &exe, &|_, _| true);
assert_eq!(out, Ok(MirrorOutcome::UpToDate(cur.into())));
assert_eq!(f.seen.borrow().len(), 1, "no download when up to date");
assert_eq!(std::fs::read(&exe).unwrap(), b"old zc binary");
}
}
#[test]
fn mirror_update_glibc_build_falls_back_to_musl() {
let exe = temp_exe("gnu404");
let f = MockFetcher::new()
.status(&format!("{BASE}/manifest/linux_amd64_gnu"), 404)
.ok(
&format!("{BASE}/manifest/linux_amd64"),
&manifest_json("0.0.35", NEW_BIN),
)
.ok(
&format!("{BASE}/download/linux_amd64?version=0.0.35"),
NEW_BIN,
);
let out = update_via_mirror(
&f,
BASE,
&plats(&["linux_amd64_gnu", "linux_amd64"]),
"0.0.34",
&exe,
&|_, _| true,
);
assert!(
matches!(out, Ok(MirrorOutcome::Installed { ref platform, .. }) if platform == "linux_amd64"),
"{out:?}"
);
let exe = temp_exe("gnunorun");
let gnu = b"gnu build".to_vec();
let f = MockFetcher::new()
.ok(
&format!("{BASE}/manifest/linux_amd64_gnu"),
&manifest_json("0.0.35", &gnu),
)
.ok(
&format!("{BASE}/download/linux_amd64_gnu?version=0.0.35"),
&gnu,
)
.ok(
&format!("{BASE}/manifest/linux_amd64"),
&manifest_json("0.0.35", NEW_BIN),
)
.ok(
&format!("{BASE}/download/linux_amd64?version=0.0.35"),
NEW_BIN,
);
let out = update_via_mirror(
&f,
BASE,
&plats(&["linux_amd64_gnu", "linux_amd64"]),
"0.0.34",
&exe,
&|_, b| b == NEW_BIN,
);
assert!(
matches!(out, Ok(MirrorOutcome::Installed { ref platform, .. }) if platform == "linux_amd64"),
"{out:?}"
);
assert_eq!(std::fs::read(&exe).unwrap(), NEW_BIN);
}
#[test]
fn mirror_unreachable_and_unsupported_are_classified() {
let exe = temp_exe("down");
let f = MockFetcher::new(); let out = update_via_mirror(
&f,
BASE,
&plats(&["linux_amd64"]),
"0.0.34",
&exe,
&|_, _| true,
);
assert!(matches!(out, Err(MirrorError::Unreachable(_))), "{out:?}");
let f = MockFetcher::new().status(&format!("{BASE}/manifest/linux_amd64"), 503);
let out = update_via_mirror(
&f,
BASE,
&plats(&["linux_amd64"]),
"0.0.34",
&exe,
&|_, _| true,
);
assert!(matches!(out, Err(MirrorError::Unreachable(_))), "{out:?}");
let f = MockFetcher::new().status(&format!("{BASE}/manifest/linux_amd64"), 404);
let out = update_via_mirror(
&f,
BASE,
&plats(&["linux_amd64"]),
"0.0.34",
&exe,
&|_, _| true,
);
assert!(matches!(out, Err(MirrorError::Unsupported(_))), "{out:?}");
assert_eq!(std::fs::read(&exe).unwrap(), b"old zc binary");
}
#[test]
fn fallback_selection() {
let down = MirrorError::Unreachable("x".into());
let unsupported = MirrorError::Unsupported("x".into());
assert_eq!(fallback_decision(&down, true), Fallback::GitHub);
assert_eq!(fallback_decision(&unsupported, true), Fallback::GitHub);
assert!(matches!(fallback_decision(&down, false), Fallback::Fail(_)));
assert!(matches!(
fallback_decision(&unsupported, false),
Fallback::Fail(_)
));
let bad = MirrorError::Integrity("sha256 mismatch".into());
assert!(matches!(fallback_decision(&bad, true), Fallback::Fail(_)));
assert!(matches!(
fallback_decision(&MirrorError::Other("x".into()), true),
Fallback::Fail(_)
));
}
#[test]
fn github_asset_digest_is_verified() {
let good = crate::dataset::sha256_hex(NEW_BIN);
let release = serde_json::json!({ "assets": [
{ "name": "zc-linux-x86_64", "digest": format!("sha256:{good}") },
{ "name": "zc-linux-arm64" },
]});
assert_eq!(asset_digest(&release, "zc-linux-x86_64"), Some(good));
assert!(verify_asset_digest(&release, "zc-linux-x86_64", NEW_BIN).is_ok());
let err = verify_asset_digest(&release, "zc-linux-x86_64", b"tampered").unwrap_err();
assert!(err.contains("sha256 mismatch"), "{err}");
assert!(verify_asset_digest(&release, "zc-linux-arm64", NEW_BIN).is_err());
assert!(verify_asset_digest(&release, "missing", NEW_BIN).is_err());
}
#[test]
fn ureq_fetcher_maps_status_and_never_sends_credentials() {
let (base, req) = one_shot_server(
b"HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\nConnection: close\r\n\r\n".to_vec(),
);
let f = UreqFetcher(
ureq::Agent::new_with_config(download_config().proxy(None).build()),
"zc-update".to_string(),
);
assert_eq!(
f.get(&format!("{base}/manifest/linux_amd64")),
Err(FetchError::Status(404))
);
let head = req.join().unwrap().to_ascii_lowercase();
assert!(!head.contains("authorization"), "{head}");
}
}
#[cfg(test)]
mod cargo_invocation_tests {
#[test]
fn rustup_invocation_puts_cargo_after_run_stable() {
let (prog, pre) = super::cargo_invocation();
if prog == "rustup" {
assert_eq!(pre, vec!["run", "stable", "cargo"]);
} else {
assert_eq!(prog, "cargo");
assert!(pre.is_empty(), "plain cargo takes no leading args");
}
}
}