Compare commits
No commits in common. "b20e4bcec154c069fccefe090a7660ed7b5b6377" and "30517f161724132cdeb658c04cf5e490be07ee73" have entirely different histories.
b20e4bcec1
...
30517f1617
6 changed files with 285 additions and 973 deletions
|
|
@ -11,16 +11,8 @@ pub struct DepReport {
|
|||
|
||||
pub fn check_deps(required: &[String], optional: &[String]) -> Result<DepReport> {
|
||||
Ok(DepReport {
|
||||
missing: required
|
||||
.iter()
|
||||
.filter(|d| !dep_present(d))
|
||||
.cloned()
|
||||
.collect(),
|
||||
warnings: optional
|
||||
.iter()
|
||||
.filter(|d| !dep_present(d))
|
||||
.cloned()
|
||||
.collect(),
|
||||
missing: required.iter().filter(|d| !dep_present(d)).cloned().collect(),
|
||||
warnings: optional.iter().filter(|d| !dep_present(d)).cloned().collect(),
|
||||
})
|
||||
}
|
||||
|
||||
|
|
@ -107,24 +99,14 @@ pub fn install_hint(missing: &[String]) -> String {
|
|||
|
||||
/// Print a formatted doctor report for a package's system deps.
|
||||
/// Returns true if all *required* deps are satisfied.
|
||||
pub fn report(
|
||||
package_name: &str,
|
||||
required: &[String],
|
||||
optional: &[String],
|
||||
name_width: usize,
|
||||
) -> bool {
|
||||
pub fn report(package_name: &str, required: &[String], optional: &[String]) -> bool {
|
||||
if required.is_empty() && optional.is_empty() {
|
||||
ui::check_row(true, package_name, name_width, "no system deps required");
|
||||
println!(" {}", ui::ok(&format!("{package_name}: no system deps required")));
|
||||
return true;
|
||||
}
|
||||
match check_deps(required, optional) {
|
||||
Err(e) => {
|
||||
ui::check_row(
|
||||
false,
|
||||
package_name,
|
||||
name_width,
|
||||
&format!("error running doctor: {e}"),
|
||||
);
|
||||
eprintln!(" {}", ui::fail(&format!("error running doctor for {package_name}: {e}")));
|
||||
false
|
||||
}
|
||||
Ok(rep) => {
|
||||
|
|
@ -141,24 +123,17 @@ pub fn report(
|
|||
);
|
||||
}
|
||||
if rep.missing.is_empty() {
|
||||
ui::check_row(
|
||||
true,
|
||||
package_name,
|
||||
name_width,
|
||||
"all required system deps satisfied",
|
||||
);
|
||||
println!(" {}", ui::ok(&format!("{package_name}: all required system deps satisfied")));
|
||||
true
|
||||
} else {
|
||||
ui::check_row(
|
||||
false,
|
||||
package_name,
|
||||
name_width,
|
||||
&format!("missing: {}", rep.missing.join(", ")),
|
||||
);
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::dim(&format!("install with: {}", install_hint(&rep.missing)))
|
||||
ui::fail(&format!(
|
||||
"{package_name}: missing system deps: {}",
|
||||
rep.missing.join(", ")
|
||||
))
|
||||
);
|
||||
eprintln!(" install with: {}", install_hint(&rep.missing));
|
||||
false
|
||||
}
|
||||
}
|
||||
|
|
@ -212,14 +187,22 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn missing_required_dep_detected() {
|
||||
let rep = check_deps(&["this-package-does-not-exist-xyzzy42".to_string()], &[]).unwrap();
|
||||
let rep = check_deps(
|
||||
&["this-package-does-not-exist-xyzzy42".to_string()],
|
||||
&[],
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(rep.missing.len(), 1);
|
||||
assert!(rep.warnings.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_optional_dep_becomes_warning_not_error() {
|
||||
let rep = check_deps(&[], &["this-package-does-not-exist-xyzzy42".to_string()]).unwrap();
|
||||
let rep = check_deps(
|
||||
&[],
|
||||
&["this-package-does-not-exist-xyzzy42".to_string()],
|
||||
)
|
||||
.unwrap();
|
||||
assert!(rep.missing.is_empty());
|
||||
assert_eq!(rep.warnings.len(), 1);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,7 +3,6 @@ use sha2::{Digest, Sha256};
|
|||
use std::path::Path;
|
||||
|
||||
use crate::manifest::{fetch_binary, Binary};
|
||||
use crate::ui;
|
||||
|
||||
/// Download a binary, verify its SHA-256, then atomically write it into
|
||||
/// place (fsynced, temp-in-same-dir-with-unique-name then rename — see
|
||||
|
|
@ -13,7 +12,7 @@ use crate::ui;
|
|||
/// bytes a second time — `verify_sha256` already confirmed `bytes` matches
|
||||
/// `binary.sha256`, so that's the value to return.
|
||||
pub fn fetch_and_place(binary: &Binary, dest: &Path) -> Result<String> {
|
||||
ui::step("downloading", &binary.name);
|
||||
println!(" downloading {}…", binary.name);
|
||||
let bytes = fetch_binary(&binary.dl_url, &binary.github_url)
|
||||
.with_context(|| format!("downloading {}", binary.name))?;
|
||||
|
||||
|
|
@ -22,7 +21,7 @@ pub fn fetch_and_place(binary: &Binary, dest: &Path) -> Result<String> {
|
|||
|
||||
bread_utils::atomic::write_atomic_bytes(dest, &bytes, Some(0o755))
|
||||
.with_context(|| format!("placing binary at {}", dest.display()))?;
|
||||
ui::step("placed", &dest.display().to_string());
|
||||
println!(" installed {}", dest.display());
|
||||
Ok(binary.sha256.clone())
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -9,7 +9,6 @@ use crate::download::{fetch_and_place, verify_sha256};
|
|||
use crate::manifest::{fetch_binary, Package, Service};
|
||||
use crate::state::{InstalledPackage, State};
|
||||
use crate::track::Track;
|
||||
use crate::ui;
|
||||
|
||||
/// Rejects a filename that isn't a safe single path component — no `/`,
|
||||
/// `\`, empty, `.`, or `..`. `bin.name`/`svc.unit`/`cfg.example`/`pkg.name`/
|
||||
|
|
@ -53,7 +52,7 @@ fn confirm(prompt: &str, assume_yes: bool) -> bool {
|
|||
return false;
|
||||
}
|
||||
use std::io::Write;
|
||||
print!("{prompt} {} ", ui::dim("[y/N]"));
|
||||
print!("{prompt} [y/N] ");
|
||||
std::io::stdout().flush().ok();
|
||||
let mut buf = String::new();
|
||||
std::io::stdin().read_line(&mut buf).ok();
|
||||
|
|
@ -75,6 +74,7 @@ pub fn install_package(
|
|||
assume_yes: bool,
|
||||
) -> Result<()> {
|
||||
ensure_safe_component(&pkg.name, "package name")?;
|
||||
println!("installing {}@{}…", pkg.name, pkg.version);
|
||||
|
||||
// 1. Download and verify all binaries. On an update (not a fresh
|
||||
// install), back up the current binary first — best-effort, feeding
|
||||
|
|
@ -126,13 +126,10 @@ pub fn install_package(
|
|||
// confirmation rather than running unconditionally.
|
||||
if !pkg.post_install.is_empty() {
|
||||
if no_hooks {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::note(&format!(
|
||||
"skipped {} post_install hook(s) for {} (--no-hooks)",
|
||||
pkg.post_install.len(),
|
||||
pkg.name
|
||||
))
|
||||
println!(
|
||||
" note: skipped {} post_install hook(s) for {} (--no-hooks)",
|
||||
pkg.post_install.len(),
|
||||
pkg.name
|
||||
);
|
||||
} else if confirm(
|
||||
&format!(
|
||||
|
|
@ -146,13 +143,7 @@ pub fn install_package(
|
|||
run_hook(cmd, &pkg.name)?;
|
||||
}
|
||||
} else {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::note(&format!(
|
||||
"skipped post_install hooks for {} (declined)",
|
||||
pkg.name
|
||||
))
|
||||
);
|
||||
println!(" skipped post_install hooks for {} (declined)", pkg.name);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -172,7 +163,7 @@ pub fn install_package(
|
|||
Ok(())
|
||||
})?;
|
||||
|
||||
println!(" {}", ui::ok(&format!("{} installed", pkg.name)));
|
||||
println!(" {} installed successfully", pkg.name);
|
||||
warn_path_if_needed(bin_dir);
|
||||
Ok(())
|
||||
}
|
||||
|
|
@ -193,21 +184,13 @@ fn backup_current_binary(backup_dir: &Path, binary_name: &str, current_path: &Pa
|
|||
}
|
||||
if let Err(e) = std::fs::create_dir_all(backup_dir) {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::warn(&format!(
|
||||
"could not create backup dir {} ({e}) — rollback won't be available for this update",
|
||||
backup_dir.display()
|
||||
))
|
||||
" warning: could not create backup dir {} ({e}) — rollback won't be available for this update",
|
||||
backup_dir.display()
|
||||
);
|
||||
return;
|
||||
}
|
||||
if let Err(e) = std::fs::copy(current_path, backup_dir.join(binary_name)) {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::warn(&format!(
|
||||
"could not back up {binary_name} before update ({e}) — rollback won't be available for this update"
|
||||
))
|
||||
);
|
||||
eprintln!(" warning: could not back up {binary_name} before update ({e}) — rollback won't be available for this update");
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -216,11 +199,10 @@ pub fn remove_package(pkg_name: &str, bin_dir: &Path, assume_yes: bool, purge: b
|
|||
let installed = match installed {
|
||||
Some(p) => p,
|
||||
None => {
|
||||
eprintln!(" {}", ui::fail(&format!("{pkg_name} is not installed")));
|
||||
eprintln!("{pkg_name} is not installed");
|
||||
return Ok(());
|
||||
}
|
||||
};
|
||||
ui::action("Removing", pkg_name, Some(&installed.version));
|
||||
// State is already committed by with_lock above — everything from here
|
||||
// is best-effort file cleanup, and must all run even if part of it fails.
|
||||
|
||||
|
|
@ -232,7 +214,7 @@ pub fn remove_package(pkg_name: &str, bin_dir: &Path, assume_yes: bool, purge: b
|
|||
let path = bin_dir.join(bin);
|
||||
if path.exists() {
|
||||
match std::fs::remove_file(&path) {
|
||||
Ok(()) => ui::step("removed", &path.display().to_string()),
|
||||
Ok(()) => println!(" removed {}", path.display()),
|
||||
Err(e) => failures.push(format!("{}: {e}", path.display())),
|
||||
}
|
||||
}
|
||||
|
|
@ -253,7 +235,7 @@ pub fn remove_package(pkg_name: &str, bin_dir: &Path, assume_yes: bool, purge: b
|
|||
let _ = Command::new("systemctl")
|
||||
.args(["--user", "daemon-reload"])
|
||||
.status();
|
||||
ui::step("removed", &format!("unit {unit}"));
|
||||
println!(" removed unit {unit}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -265,7 +247,7 @@ pub fn remove_package(pkg_name: &str, bin_dir: &Path, assume_yes: bool, purge: b
|
|||
// surprise no flag should cause.
|
||||
if let Some(cfg_dir) = guess_config_dir(pkg_name) {
|
||||
if cfg_dir.exists() {
|
||||
ui::step("preserved", &format!("config {}", cfg_dir.display()));
|
||||
println!(" config preserved at {}", cfg_dir.display());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -276,34 +258,23 @@ pub fn remove_package(pkg_name: &str, bin_dir: &Path, assume_yes: bool, purge: b
|
|||
let license_dir = share_dir.join("licenses").join(pkg_name);
|
||||
remove_purged_path(&license_dir, "license dir", true, assume_yes, &mut failures);
|
||||
|
||||
let desktop_file = share_dir
|
||||
.join("applications")
|
||||
.join(format!("{pkg_name}.desktop"));
|
||||
remove_purged_path(
|
||||
&desktop_file,
|
||||
"desktop entry",
|
||||
false,
|
||||
assume_yes,
|
||||
&mut failures,
|
||||
);
|
||||
let desktop_file = share_dir.join("applications").join(format!("{pkg_name}.desktop"));
|
||||
remove_purged_path(&desktop_file, "desktop entry", false, assume_yes, &mut failures);
|
||||
|
||||
remove_purged_path(&data_dir, "data dir", true, assume_yes, &mut failures);
|
||||
} else if data_dir.exists() {
|
||||
ui::step("preserved", &format!("data {}", data_dir.display()));
|
||||
println!(" data preserved at {}", data_dir.display());
|
||||
}
|
||||
|
||||
if !failures.is_empty() {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::fail(&format!("failed to remove {} item(s):", failures.len()))
|
||||
);
|
||||
eprintln!(" failed to remove {} item(s):", failures.len());
|
||||
for f in &failures {
|
||||
eprintln!(" {f}");
|
||||
}
|
||||
bail!("{pkg_name} removed from state, but some files could not be deleted");
|
||||
}
|
||||
|
||||
println!(" {}", ui::ok(&format!("{pkg_name} removed")));
|
||||
println!(" {pkg_name} removed");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
|
@ -313,21 +284,12 @@ pub fn remove_package(pkg_name: &str, bin_dir: &Path, assume_yes: bool, purge: b
|
|||
/// in place and prints the same "preserved at" wording the non-purge path
|
||||
/// already uses. Shared by `remove_package`'s three `--purge` targets
|
||||
/// (license dir, desktop entry, data dir).
|
||||
fn remove_purged_path(
|
||||
path: &Path,
|
||||
label: &str,
|
||||
recursive: bool,
|
||||
assume_yes: bool,
|
||||
failures: &mut Vec<String>,
|
||||
) {
|
||||
fn remove_purged_path(path: &Path, label: &str, recursive: bool, assume_yes: bool, failures: &mut Vec<String>) {
|
||||
if !path.exists() {
|
||||
return;
|
||||
}
|
||||
if !confirm(
|
||||
&format!(" remove {label} at {}?", path.display()),
|
||||
assume_yes,
|
||||
) {
|
||||
ui::step("preserved", &format!("{label} {}", path.display()));
|
||||
if !confirm(&format!(" remove {label} at {}?", path.display()), assume_yes) {
|
||||
println!(" {label} preserved at {}", path.display());
|
||||
return;
|
||||
}
|
||||
let result = if recursive {
|
||||
|
|
@ -336,7 +298,7 @@ fn remove_purged_path(
|
|||
std::fs::remove_file(path)
|
||||
};
|
||||
match result {
|
||||
Ok(()) => ui::step("removed", &path.display().to_string()),
|
||||
Ok(()) => println!(" removed {}", path.display()),
|
||||
Err(e) => failures.push(format!("{}: {e}", path.display())),
|
||||
}
|
||||
}
|
||||
|
|
@ -356,48 +318,36 @@ fn scaffold_config(cfg: &crate::manifest::ConfigScaffold, pkg: &Package) -> Resu
|
|||
Ok(()) => {
|
||||
std::fs::write(&dest, &bytes)
|
||||
.with_context(|| format!("writing {}", dest.display()))?;
|
||||
ui::step("config", &dest.display().to_string());
|
||||
println!(" installed example config at {}", dest.display());
|
||||
}
|
||||
Err(e) => {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::warn(&format!(
|
||||
"checksum mismatch for example config {example}: {e} — not installed"
|
||||
))
|
||||
" warning: checksum mismatch for example config {example}: {e} — not installed"
|
||||
);
|
||||
ui::step("config", &dir.display().to_string());
|
||||
println!(" config dir created at {}", dir.display());
|
||||
}
|
||||
},
|
||||
None => {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::warn(&format!(
|
||||
"index.json has no sha256 for example config \
|
||||
{example} — refusing to install an unverified download"
|
||||
))
|
||||
" warning: index.json has no sha256 for example config \
|
||||
{example} — refusing to install an unverified download"
|
||||
);
|
||||
ui::step("config", &dir.display().to_string());
|
||||
println!(" config dir created at {}", dir.display());
|
||||
}
|
||||
},
|
||||
Err(e) => {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::warn(&format!("could not download example config {example}: {e}"))
|
||||
);
|
||||
ui::step("config", &dir.display().to_string());
|
||||
eprintln!(" warning: could not download example config {example}: {e}");
|
||||
println!(" config dir created at {}", dir.display());
|
||||
}
|
||||
}
|
||||
} else {
|
||||
ui::step("config", &dir.display().to_string());
|
||||
println!(" config dir created at {}", dir.display());
|
||||
}
|
||||
} else {
|
||||
ui::step(
|
||||
"config",
|
||||
&format!("{} already exists, skipping", dest.display()),
|
||||
);
|
||||
println!(" config at {} already exists, skipping", dest.display());
|
||||
}
|
||||
} else {
|
||||
ui::step("config", &dir.display().to_string());
|
||||
println!(" config dir created at {}", dir.display());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
|
@ -416,46 +366,32 @@ fn fetch_verify_write(
|
|||
label: &str,
|
||||
) -> Result<()> {
|
||||
let Some((primary, fallback)) = pkg.artifact_urls(filename) else {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::warn(&format!("no artifact URL to download {label} ({filename})"))
|
||||
);
|
||||
eprintln!(" warning: no artifact URL to download {label} ({filename})");
|
||||
return Ok(());
|
||||
};
|
||||
let bytes = match fetch_binary(&primary, &fallback) {
|
||||
Ok(b) => b,
|
||||
Err(e) => {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::warn(&format!("could not download {label} {filename}: {e}"))
|
||||
);
|
||||
eprintln!(" warning: could not download {label} {filename}: {e}");
|
||||
return Ok(());
|
||||
}
|
||||
};
|
||||
let Some(expected) = sha256 else {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::warn(&format!(
|
||||
"index.json has no sha256 for {label} {filename} — \
|
||||
refusing to install an unverified download"
|
||||
))
|
||||
" warning: index.json has no sha256 for {label} {filename} — \
|
||||
refusing to install an unverified download"
|
||||
);
|
||||
return Ok(());
|
||||
};
|
||||
if let Err(e) = verify_sha256(&bytes, expected) {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::warn(&format!(
|
||||
"checksum mismatch for {label} {filename}: {e} — not installed"
|
||||
))
|
||||
);
|
||||
eprintln!(" warning: checksum mismatch for {label} {filename}: {e} — not installed");
|
||||
return Ok(());
|
||||
}
|
||||
if let Some(parent) = dest.parent() {
|
||||
std::fs::create_dir_all(parent)?;
|
||||
}
|
||||
std::fs::write(dest, &bytes).with_context(|| format!("writing {}", dest.display()))?;
|
||||
ui::step("installed", &format!("{label} {}", dest.display()));
|
||||
println!(" installed {label} at {}", dest.display());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
|
@ -475,13 +411,7 @@ fn install_desktop_file(pkg: &Package, filename: &str) -> Result<()> {
|
|||
.unwrap_or_else(|| PathBuf::from("~/.local/share"))
|
||||
.join("applications")
|
||||
.join(format!("{}.desktop", pkg.name));
|
||||
fetch_verify_write(
|
||||
pkg,
|
||||
filename,
|
||||
&pkg.desktop_file_sha256,
|
||||
&dest,
|
||||
"desktop entry",
|
||||
)
|
||||
fetch_verify_write(pkg, filename, &pkg.desktop_file_sha256, &dest, "desktop entry")
|
||||
}
|
||||
|
||||
fn install_data_archive(pkg: &Package, filename: &str) -> Result<()> {
|
||||
|
|
@ -538,15 +468,9 @@ fn fetch_extract_archive(
|
|||
// `tmp_archive` (a `TempPath` guard) deletes the file when it drops here.
|
||||
|
||||
if status.success() {
|
||||
ui::step(
|
||||
"extracted",
|
||||
&format!("{filename} → {}", dest_dir.display()),
|
||||
);
|
||||
println!(" extracted {filename} to {}", dest_dir.display());
|
||||
} else {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::warn(&format!("tar exited with {status} extracting {filename}"))
|
||||
);
|
||||
eprintln!(" warning: tar exited with {status} extracting {filename}");
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
|
@ -628,24 +552,18 @@ fn install_service(svc: &Service, bin_dir: &Path, pkg: &Package) -> Result<()> {
|
|||
Ok(bytes) => {
|
||||
std::fs::write(&unit_path, &bytes)
|
||||
.with_context(|| format!("writing {}", unit_path.display()))?;
|
||||
ui::step("unit", &unit_path.display().to_string());
|
||||
println!(" downloaded unit {}", unit_path.display());
|
||||
}
|
||||
Err(e) => {
|
||||
if had_existing {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::warn(&format!(
|
||||
"could not refresh unit {} ({e}) — keeping existing copy",
|
||||
svc.unit
|
||||
))
|
||||
" warning: could not refresh unit {} ({e}) — keeping existing copy",
|
||||
svc.unit
|
||||
);
|
||||
} else {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::warn(&format!(
|
||||
"unit file {} not found ({e}) — skipping service setup",
|
||||
svc.unit
|
||||
))
|
||||
" warning: unit file {} not found ({e}) — skipping service setup",
|
||||
svc.unit
|
||||
);
|
||||
return Ok(());
|
||||
}
|
||||
|
|
@ -660,7 +578,7 @@ fn install_service(svc: &Service, bin_dir: &Path, pkg: &Package) -> Result<()> {
|
|||
.map(|s| s.success())
|
||||
.unwrap_or(false)
|
||||
{
|
||||
eprintln!(" {}", ui::warn("systemctl daemon-reload failed"));
|
||||
eprintln!(" warning: systemctl daemon-reload failed");
|
||||
}
|
||||
|
||||
if svc.enable {
|
||||
|
|
@ -677,9 +595,9 @@ fn install_service(svc: &Service, bin_dir: &Path, pkg: &Package) -> Result<()> {
|
|||
.map(|s| s.success())
|
||||
.unwrap_or(false)
|
||||
{
|
||||
ui::step("restarted", &svc.unit);
|
||||
println!(" {} restarted", svc.unit);
|
||||
} else {
|
||||
eprintln!(" {}", ui::warn(&format!("failed to restart {}", svc.unit)));
|
||||
eprintln!(" warning: failed to restart {}", svc.unit);
|
||||
}
|
||||
} else if Command::new("systemctl")
|
||||
.args(["--user", "enable", "--now", &svc.unit])
|
||||
|
|
@ -687,9 +605,9 @@ fn install_service(svc: &Service, bin_dir: &Path, pkg: &Package) -> Result<()> {
|
|||
.map(|s| s.success())
|
||||
.unwrap_or(false)
|
||||
{
|
||||
ui::step("enabled", &svc.unit);
|
||||
println!(" {} enabled and started", svc.unit);
|
||||
} else {
|
||||
eprintln!(" {}", ui::warn(&format!("failed to enable {}", svc.unit)));
|
||||
eprintln!(" warning: failed to enable {}", svc.unit);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -732,13 +650,13 @@ fn patch_exec_start(unit_path: &Path, bin_dir: &Path) -> Result<()> {
|
|||
}
|
||||
|
||||
fn run_hook(cmd: &str, pkg_name: &str) -> Result<()> {
|
||||
ui::step("hook", cmd);
|
||||
println!(" running post_install hook: {cmd}");
|
||||
let status = Command::new("sh")
|
||||
.args(["-c", cmd])
|
||||
.status()
|
||||
.with_context(|| format!("running post_install hook for {pkg_name}"))?;
|
||||
if !status.success() {
|
||||
eprintln!(" {}", ui::warn(&format!("hook exited with {status}")));
|
||||
eprintln!(" warning: hook exited with {status}");
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
|
@ -781,14 +699,11 @@ fn warn_path_if_needed(bin_dir: &Path) {
|
|||
let path_var = std::env::var("PATH").unwrap_or_default();
|
||||
let bin_str = bin_dir.to_string_lossy();
|
||||
if !path_var.split(':').any(|p| p == bin_str) {
|
||||
eprintln!();
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::note(&format!(
|
||||
"{bin_str} is not in PATH — add to your shell profile:"
|
||||
))
|
||||
println!(
|
||||
"\n note: {} is not in PATH — add to your shell profile:",
|
||||
bin_str
|
||||
);
|
||||
println!(" export PATH=\"{bin_str}:$PATH\"");
|
||||
println!(" export PATH=\"{}:$PATH\"", bin_str);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -813,7 +728,10 @@ mod tests {
|
|||
if let Ok((mut stream, _)) = listener.accept() {
|
||||
let mut buf = [0u8; 1024];
|
||||
let _ = stream.read(&mut buf);
|
||||
let response = format!("HTTP/1.0 200 OK\r\nContent-Length: {}\r\n\r\n", body.len());
|
||||
let response = format!(
|
||||
"HTTP/1.0 200 OK\r\nContent-Length: {}\r\n\r\n",
|
||||
body.len()
|
||||
);
|
||||
let _ = stream.write_all(response.as_bytes());
|
||||
let _ = stream.write_all(body);
|
||||
}
|
||||
|
|
@ -830,7 +748,10 @@ mod tests {
|
|||
if let Ok((mut stream, _)) = listener.accept() {
|
||||
let mut buf = [0u8; 1024];
|
||||
let _ = stream.read(&mut buf);
|
||||
let response = format!("HTTP/1.0 200 OK\r\nContent-Length: {}\r\n\r\n", body.len());
|
||||
let response = format!(
|
||||
"HTTP/1.0 200 OK\r\nContent-Length: {}\r\n\r\n",
|
||||
body.len()
|
||||
);
|
||||
let _ = stream.write_all(response.as_bytes());
|
||||
let _ = stream.write_all(&body);
|
||||
}
|
||||
|
|
@ -876,14 +797,8 @@ mod tests {
|
|||
|
||||
let dir = tempdir().unwrap();
|
||||
let dest = dir.path().join("LICENSE");
|
||||
fetch_verify_write(
|
||||
&pkg,
|
||||
"LICENSE",
|
||||
&pkg.license_file_sha256.clone(),
|
||||
&dest,
|
||||
"license",
|
||||
)
|
||||
.unwrap();
|
||||
fetch_verify_write(&pkg, "LICENSE", &pkg.license_file_sha256.clone(), &dest, "license")
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(fs::read(&dest).unwrap(), license_bytes);
|
||||
}
|
||||
|
|
@ -921,14 +836,8 @@ mod tests {
|
|||
|
||||
let dir = tempdir().unwrap();
|
||||
let dest = dir.path().join("LICENSE");
|
||||
fetch_verify_write(
|
||||
&pkg,
|
||||
"LICENSE",
|
||||
&pkg.license_file_sha256.clone(),
|
||||
&dest,
|
||||
"license",
|
||||
)
|
||||
.unwrap();
|
||||
fetch_verify_write(&pkg, "LICENSE", &pkg.license_file_sha256.clone(), &dest, "license")
|
||||
.unwrap();
|
||||
|
||||
// Refused, not erred (matches scaffold_config's warn-and-continue
|
||||
// posture) — the file must not have been written.
|
||||
|
|
@ -976,7 +885,8 @@ mod tests {
|
|||
let pkg = test_package(&base_url);
|
||||
|
||||
let dest_dir = tempdir().unwrap();
|
||||
fetch_extract_archive(&pkg, "content.tar.gz", &Some(sha256_hex), dest_dir.path()).unwrap();
|
||||
fetch_extract_archive(&pkg, "content.tar.gz", &Some(sha256_hex), dest_dir.path())
|
||||
.unwrap();
|
||||
|
||||
let extracted = dest_dir.path().join("content/tours/onboarding.toml");
|
||||
assert_eq!(fs::read(&extracted).unwrap(), b"[[step]]\n");
|
||||
|
|
@ -1133,10 +1043,7 @@ mod tests {
|
|||
|
||||
backup_current_binary(&backup_dir, "mypkg", ¤t);
|
||||
|
||||
assert_eq!(
|
||||
fs::read(backup_dir.join("mypkg")).unwrap(),
|
||||
b"old version bytes"
|
||||
);
|
||||
assert_eq!(fs::read(backup_dir.join("mypkg")).unwrap(), b"old version bytes");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
|
|
@ -14,12 +14,7 @@ use std::path::{Path, PathBuf};
|
|||
use track::Track;
|
||||
|
||||
#[derive(Parser)]
|
||||
#[command(
|
||||
name = "bakery",
|
||||
about = "Package manager for the bread ecosystem",
|
||||
version,
|
||||
styles = ui::CLAP_STYLES
|
||||
)]
|
||||
#[command(name = "bakery", about = "Package manager for the bread ecosystem", version)]
|
||||
struct Cli {
|
||||
#[command(subcommand)]
|
||||
command: Cmd,
|
||||
|
|
@ -68,9 +63,13 @@ enum Cmd {
|
|||
installed: bool,
|
||||
},
|
||||
/// Show details for a package
|
||||
Info { package: String },
|
||||
Info {
|
||||
package: String,
|
||||
},
|
||||
/// Search package names and descriptions
|
||||
Search { query: String },
|
||||
Search {
|
||||
query: String,
|
||||
},
|
||||
/// Check system dependencies for installed or requested packages
|
||||
Doctor {
|
||||
/// Package to check; omit to check all installed packages
|
||||
|
|
@ -83,11 +82,15 @@ enum Cmd {
|
|||
},
|
||||
/// Roll back a package to its previously installed version, from a
|
||||
/// local pre-update backup (not a re-download)
|
||||
Rollback { package: String },
|
||||
Rollback {
|
||||
package: String,
|
||||
},
|
||||
/// Update bakery itself
|
||||
SelfUpdate,
|
||||
/// Generate a shell completion script
|
||||
Completions { shell: clap_complete::Shell },
|
||||
Completions {
|
||||
shell: clap_complete::Shell,
|
||||
},
|
||||
/// View or switch which build track bakery follows (stable/beta/dev)
|
||||
Track {
|
||||
#[command(subcommand)]
|
||||
|
|
@ -127,15 +130,9 @@ fn main() -> Result<()> {
|
|||
Ok(())
|
||||
}
|
||||
Cmd::Remove { package, purge } => cmd_remove(&package, &bin_dir, assume_yes, purge),
|
||||
Cmd::Update { package, all } => cmd_update(
|
||||
package.as_deref(),
|
||||
all,
|
||||
&bin_dir,
|
||||
track,
|
||||
no_hooks,
|
||||
assume_yes,
|
||||
dry_run,
|
||||
),
|
||||
Cmd::Update { package, all } => {
|
||||
cmd_update(package.as_deref(), all, &bin_dir, track, no_hooks, assume_yes, dry_run)
|
||||
}
|
||||
Cmd::List { installed } => cmd_list(installed, track),
|
||||
Cmd::Info { package } => cmd_info(&package, track),
|
||||
Cmd::Search { query } => cmd_search(&query, track),
|
||||
|
|
@ -147,15 +144,7 @@ fn main() -> Result<()> {
|
|||
// bakery's own running binary via a normal update already works
|
||||
// (rename-over-running-binary is safe on Linux) but wasn't a real
|
||||
// first-class command.
|
||||
Cmd::SelfUpdate => cmd_update(
|
||||
Some("bakery"),
|
||||
false,
|
||||
&bin_dir,
|
||||
track,
|
||||
no_hooks,
|
||||
assume_yes,
|
||||
dry_run,
|
||||
),
|
||||
Cmd::SelfUpdate => cmd_update(Some("bakery"), false, &bin_dir, track, no_hooks, assume_yes, dry_run),
|
||||
Cmd::Completions { shell } => cmd_completions(shell),
|
||||
Cmd::Track { action } => cmd_track(action),
|
||||
}
|
||||
|
|
@ -170,11 +159,11 @@ fn cmd_track(action: TrackCmd) -> Result<()> {
|
|||
let state = state::State::load()?;
|
||||
match action {
|
||||
TrackCmd::Show => {
|
||||
ui::heading("Track", &[&ui::style(state.track.as_str(), ui::CYAN)]);
|
||||
println!("current track: {}", ui::style(state.track.as_str(), ui::CYAN));
|
||||
}
|
||||
TrackCmd::Set { track } => {
|
||||
if state.track == track {
|
||||
println!("{}", ui::unchanged(&format!("already on track {track}")));
|
||||
println!("already on track {track}");
|
||||
return Ok(());
|
||||
}
|
||||
// Fail fast on a bad/unreachable track rather than silently
|
||||
|
|
@ -185,10 +174,10 @@ fn cmd_track(action: TrackCmd) -> Result<()> {
|
|||
state.set_track(track);
|
||||
Ok(())
|
||||
})?;
|
||||
ui::action("Switched", track.as_str(), None);
|
||||
ui::step(
|
||||
"next",
|
||||
&format!("bakery update --all to install {track} builds"),
|
||||
println!(
|
||||
"switched to {} — run 'bakery update --all' to install {} builds",
|
||||
ui::style(track.as_str(), ui::CYAN),
|
||||
track
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
@ -206,16 +195,7 @@ fn cmd_install(
|
|||
dry_run: bool,
|
||||
) -> Result<()> {
|
||||
let mut visited = HashSet::new();
|
||||
install_with_deps(
|
||||
index,
|
||||
name,
|
||||
bin_dir,
|
||||
track,
|
||||
no_hooks,
|
||||
assume_yes,
|
||||
dry_run,
|
||||
&mut visited,
|
||||
)
|
||||
install_with_deps(index, name, bin_dir, track, no_hooks, assume_yes, dry_run, &mut visited)
|
||||
}
|
||||
|
||||
/// Recursively installs `name` and any bread_deps, skipping already-installed
|
||||
|
|
@ -243,10 +223,8 @@ fn install_with_deps(
|
|||
let state = state::State::load()?;
|
||||
for dep in pkg.bread_deps.clone() {
|
||||
if !state.is_installed(&dep) {
|
||||
ui::step(if dry_run { "would need" } else { "dependency" }, &dep);
|
||||
install_with_deps(
|
||||
index, &dep, bin_dir, track, no_hooks, assume_yes, dry_run, visited,
|
||||
)?;
|
||||
println!("{} bread dependency: {dep}", if dry_run { "would install" } else { "installing" });
|
||||
install_with_deps(index, &dep, bin_dir, track, no_hooks, assume_yes, dry_run, visited)?;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -259,59 +237,26 @@ fn install_with_deps(
|
|||
if let Some(installed) = previous {
|
||||
if !is_newer(&installed.version, &pkg.version) {
|
||||
println!(
|
||||
" {}",
|
||||
ui::unchanged(&format!(
|
||||
"{name} already at {} (index has {})",
|
||||
installed.version, pkg.version
|
||||
))
|
||||
"{name} already installed at {} (index has {})",
|
||||
installed.version, pkg.version
|
||||
);
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
|
||||
ui::action(
|
||||
if dry_run {
|
||||
if previous.is_some() {
|
||||
"Would update"
|
||||
} else {
|
||||
"Would install"
|
||||
}
|
||||
} else if previous.is_some() {
|
||||
"Updating"
|
||||
} else {
|
||||
"Installing"
|
||||
},
|
||||
name,
|
||||
Some(&pkg.version),
|
||||
);
|
||||
ui::step("checking", "system dependencies");
|
||||
println!("checking system dependencies for {name}…");
|
||||
let rep = doctor::check_deps(&pkg.system_deps, &pkg.optional_system_deps)?;
|
||||
for warn in &rep.warnings {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::note(&format!("optional dep not installed: {warn}"))
|
||||
);
|
||||
eprintln!(" note: optional dep not installed: {warn}");
|
||||
}
|
||||
if !rep.missing.is_empty() {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::fail(&format!(
|
||||
"missing system deps for {name}: {}",
|
||||
rep.missing.join(", ")
|
||||
))
|
||||
);
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::dim(&format!(
|
||||
"install with: {}",
|
||||
doctor::install_hint(&rep.missing)
|
||||
))
|
||||
);
|
||||
eprintln!("missing system deps for {name}: {}", rep.missing.join(", "));
|
||||
eprintln!("install with: {}", doctor::install_hint(&rep.missing));
|
||||
bail!("system deps not satisfied");
|
||||
}
|
||||
|
||||
if dry_run {
|
||||
print_dry_run_plan(pkg);
|
||||
print_dry_run_plan(pkg, previous);
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
|
|
@ -323,23 +268,22 @@ fn install_with_deps(
|
|||
/// already been made — this only renders that decision, it never
|
||||
/// recomputes it, so dry-run and real runs can't drift apart on "would this
|
||||
/// update happen at all".
|
||||
fn print_dry_run_plan(pkg: &manifest::Package) {
|
||||
ui::kv(
|
||||
"binaries",
|
||||
&pkg.binaries
|
||||
.iter()
|
||||
.map(|b| b.name.as_str())
|
||||
.collect::<Vec<_>>()
|
||||
.join(", "),
|
||||
fn print_dry_run_plan(pkg: &manifest::Package, previous: Option<&state::InstalledPackage>) {
|
||||
let verb = if previous.is_some() { "update" } else { "install" };
|
||||
println!(
|
||||
" {} would {verb} {} to {}",
|
||||
ui::style("dry-run:", ui::DIM),
|
||||
pkg.name,
|
||||
ui::style(&pkg.version, ui::BOLD)
|
||||
);
|
||||
println!(
|
||||
" binaries: {}",
|
||||
pkg.binaries.iter().map(|b| b.name.as_str()).collect::<Vec<_>>().join(", ")
|
||||
);
|
||||
if !pkg.services.is_empty() {
|
||||
ui::kv(
|
||||
"services",
|
||||
&pkg.services
|
||||
.iter()
|
||||
.map(|s| s.unit.as_str())
|
||||
.collect::<Vec<_>>()
|
||||
.join(", "),
|
||||
println!(
|
||||
" services: {}",
|
||||
pkg.services.iter().map(|s| s.unit.as_str()).collect::<Vec<_>>().join(", ")
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
@ -367,16 +311,10 @@ fn cmd_update(
|
|||
};
|
||||
|
||||
if targets.is_empty() {
|
||||
println!("{}", ui::dim("no packages installed"));
|
||||
println!("no packages installed");
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let mut targets = targets;
|
||||
targets.sort();
|
||||
if all {
|
||||
ui::heading("Update", &[&format!("{} packages", targets.len())]);
|
||||
}
|
||||
|
||||
let mut any_failed = false;
|
||||
let mut updated = 0u32;
|
||||
let mut unchanged = 0u32;
|
||||
|
|
@ -384,10 +322,7 @@ fn cmd_update(
|
|||
let installed = match state.packages.get(pkg_name.as_str()) {
|
||||
Some(p) => p,
|
||||
None => {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::fail(&format!("{pkg_name} is not installed, skipping"))
|
||||
);
|
||||
eprintln!("{pkg_name} is not installed, skipping");
|
||||
any_failed = true;
|
||||
continue;
|
||||
}
|
||||
|
|
@ -395,10 +330,7 @@ fn cmd_update(
|
|||
let latest = match index.get(pkg_name) {
|
||||
Some(p) => p,
|
||||
None => {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::fail(&format!("{pkg_name} not found in index, skipping"))
|
||||
);
|
||||
eprintln!("{pkg_name} not found in index, skipping");
|
||||
any_failed = true;
|
||||
continue;
|
||||
}
|
||||
|
|
@ -418,86 +350,57 @@ fn cmd_update(
|
|||
// under a terminal palette that maps ANSI colors unusually.
|
||||
println!(
|
||||
" {}",
|
||||
ui::unchanged(&format!("{pkg_name} already at {}", installed.version))
|
||||
ui::unchanged(&format!("{pkg_name} is already at {}", installed.version))
|
||||
);
|
||||
unchanged += 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
ui::action(
|
||||
if dry_run { "Would update" } else { "Updating" },
|
||||
pkg_name,
|
||||
Some(&latest.version),
|
||||
);
|
||||
if track_switch {
|
||||
ui::step(
|
||||
"track",
|
||||
&format!(
|
||||
"{} {} {}",
|
||||
ui::dim(installed.track.as_str()),
|
||||
ui::style("→", ui::CYAN),
|
||||
ui::bold(track.as_str()),
|
||||
),
|
||||
println!(
|
||||
"{pkg_name} switching track {} {} {}, installing {}",
|
||||
ui::style(installed.track.as_str(), ui::DIM),
|
||||
ui::style("→", ui::CYAN),
|
||||
ui::style(track.as_str(), ui::BOLD),
|
||||
ui::style(&latest.version, ui::BOLD)
|
||||
);
|
||||
} else {
|
||||
ui::step(
|
||||
"version",
|
||||
&format!(
|
||||
"{} {} {}",
|
||||
ui::dim(&installed.version),
|
||||
ui::style("→", ui::CYAN),
|
||||
ui::bold(&latest.version)
|
||||
),
|
||||
println!(
|
||||
"updating {pkg_name} {} {} {}",
|
||||
ui::style(&installed.version, ui::DIM),
|
||||
ui::style("→", ui::CYAN),
|
||||
ui::style(&latest.version, ui::BOLD)
|
||||
);
|
||||
}
|
||||
|
||||
let rep = match doctor::check_deps(&latest.system_deps, &latest.optional_system_deps) {
|
||||
Ok(r) => r,
|
||||
Err(e) => {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::fail(&format!("doctor check failed for {pkg_name}: {e}"))
|
||||
);
|
||||
eprintln!(" doctor check failed for {pkg_name}: {e}");
|
||||
any_failed = true;
|
||||
continue;
|
||||
}
|
||||
};
|
||||
for warn in &rep.warnings {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::note(&format!("optional dep not installed: {warn}"))
|
||||
);
|
||||
eprintln!(" note: optional dep not installed: {warn}");
|
||||
}
|
||||
if !rep.missing.is_empty() {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::fail(&format!(
|
||||
"missing deps for {pkg_name}: {} — skipping update",
|
||||
rep.missing.join(", ")
|
||||
))
|
||||
" missing deps for {pkg_name}: {} — skipping update",
|
||||
rep.missing.join(", ")
|
||||
);
|
||||
any_failed = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
if dry_run {
|
||||
print_dry_run_plan(latest);
|
||||
print_dry_run_plan(latest, Some(installed));
|
||||
updated += 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
if let Err(e) = install::install_package(
|
||||
latest,
|
||||
bin_dir,
|
||||
track,
|
||||
Some(installed),
|
||||
no_hooks,
|
||||
assume_yes,
|
||||
) {
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::fail(&format!("failed to update {pkg_name}: {e}"))
|
||||
);
|
||||
if let Err(e) = install::install_package(latest, bin_dir, track, Some(installed), no_hooks, assume_yes) {
|
||||
eprintln!(" failed to update {pkg_name}: {e}");
|
||||
any_failed = true;
|
||||
} else {
|
||||
updated += 1;
|
||||
|
|
@ -507,14 +410,12 @@ fn cmd_update(
|
|||
// Only for --all: a single named update already makes its own outcome
|
||||
// obvious, and "1 updated, 0 already up to date" isn't a useful takeaway.
|
||||
if all {
|
||||
let updated_s = format!("{updated} updated");
|
||||
let unchanged_s = format!("{unchanged} already current");
|
||||
let mut parts: Vec<&str> = Vec::new();
|
||||
let mut parts = Vec::new();
|
||||
if updated > 0 {
|
||||
parts.push(&updated_s);
|
||||
parts.push(format!("{updated} updated"));
|
||||
}
|
||||
parts.push(&unchanged_s);
|
||||
ui::summary(&parts);
|
||||
parts.push(format!("{unchanged} already up to date"));
|
||||
println!("{}", ui::style(&parts.join(", "), ui::BOLD));
|
||||
}
|
||||
|
||||
if any_failed {
|
||||
|
|
@ -526,12 +427,7 @@ fn cmd_update(
|
|||
/// Whether `pkg_name` should be updated: always true on a track switch
|
||||
/// (an explicit user action that must take effect regardless of version
|
||||
/// ordering), otherwise a real semver comparison via [`is_newer`].
|
||||
fn should_update(
|
||||
installed_version: &str,
|
||||
installed_track: Track,
|
||||
active_track: Track,
|
||||
latest_version: &str,
|
||||
) -> bool {
|
||||
fn should_update(installed_version: &str, installed_track: Track, active_track: Track, latest_version: &str) -> bool {
|
||||
if installed_track != active_track {
|
||||
return true;
|
||||
}
|
||||
|
|
@ -545,10 +441,7 @@ fn should_update(
|
|||
/// (with a warning) for any version string that isn't valid semver, rather
|
||||
/// than hard-erroring on packages built before this convention existed.
|
||||
fn is_newer(installed: &str, latest: &str) -> bool {
|
||||
match (
|
||||
semver::Version::parse(installed),
|
||||
semver::Version::parse(latest),
|
||||
) {
|
||||
match (semver::Version::parse(installed), semver::Version::parse(latest)) {
|
||||
(Ok(i), Ok(l)) => l > i,
|
||||
_ => {
|
||||
if installed != latest {
|
||||
|
|
@ -562,14 +455,15 @@ fn is_newer(installed: &str, latest: &str) -> bool {
|
|||
}
|
||||
}
|
||||
|
||||
fn catalog_row(pkg: &manifest::Package, state: &state::State) -> ui::CatalogRow {
|
||||
ui::CatalogRow {
|
||||
name: pkg.name.clone(),
|
||||
version: pkg.version.clone(),
|
||||
installed: state.is_installed(&pkg.name),
|
||||
detail: pkg.description.clone(),
|
||||
aside: String::new(),
|
||||
}
|
||||
/// Prints one index entry in the shared `list`/`search` format: name,
|
||||
/// version, description, and an `[installed <version>]` tag when applicable.
|
||||
fn print_index_entry(pkg: &manifest::Package, state: &state::State) {
|
||||
let tag = if state.is_installed(&pkg.name) {
|
||||
ui::style(&format!(" [installed {}]", state.packages[&pkg.name].version), ui::GREEN)
|
||||
} else {
|
||||
String::new()
|
||||
};
|
||||
println!(" {:<14} {:<10} — {}{}", pkg.name, pkg.version, pkg.description, tag);
|
||||
}
|
||||
|
||||
fn cmd_list(installed_only: bool, track: Track) -> Result<()> {
|
||||
|
|
@ -577,44 +471,24 @@ fn cmd_list(installed_only: bool, track: Track) -> Result<()> {
|
|||
|
||||
if installed_only {
|
||||
if state.packages.is_empty() {
|
||||
println!("{}", ui::dim("no packages installed"));
|
||||
return Ok(());
|
||||
println!("no packages installed");
|
||||
}
|
||||
for pkg in state.packages.values() {
|
||||
println!(" {} {} (installed {})", pkg.name, pkg.version, pkg.installed_at);
|
||||
}
|
||||
let mut pkgs: Vec<_> = state.packages.values().collect();
|
||||
pkgs.sort_by(|a, b| a.name.cmp(&b.name));
|
||||
ui::heading("Installed", &[&pkgs.len().to_string()]);
|
||||
let rows: Vec<ui::CatalogRow> = pkgs
|
||||
.iter()
|
||||
.map(|pkg| ui::CatalogRow {
|
||||
name: pkg.name.clone(),
|
||||
version: pkg.version.clone(),
|
||||
installed: true,
|
||||
detail: String::new(),
|
||||
aside: ui::short_date(&pkg.installed_at),
|
||||
})
|
||||
.collect();
|
||||
ui::print_catalog(&rows);
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
if !matches!(track, Track::Stable) {
|
||||
println!("tracking:{}\n", ui::track_badge(track));
|
||||
}
|
||||
|
||||
let index = manifest::load(false, track)?;
|
||||
let mut names: Vec<&str> = index.packages.keys().map(|s| s.as_str()).collect();
|
||||
names.sort();
|
||||
let installed = names.iter().filter(|n| state.is_installed(n)).count();
|
||||
let track_part = ui::track_tag(track);
|
||||
ui::heading(
|
||||
"Packages",
|
||||
&[
|
||||
&format!("{} in index", names.len()),
|
||||
&format!("{installed} installed"),
|
||||
&track_part,
|
||||
],
|
||||
);
|
||||
let rows: Vec<ui::CatalogRow> = names
|
||||
.iter()
|
||||
.map(|name| catalog_row(&index.packages[*name], &state))
|
||||
.collect();
|
||||
ui::print_catalog(&rows);
|
||||
for name in names {
|
||||
print_index_entry(&index.packages[name], &state);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
|
@ -639,19 +513,13 @@ fn cmd_search(query: &str, track: Track) -> Result<()> {
|
|||
names.sort();
|
||||
|
||||
if names.is_empty() {
|
||||
println!("{}", ui::dim(&format!("no packages matched '{query}'")));
|
||||
println!("no packages matched '{query}'");
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
ui::heading(
|
||||
"Search",
|
||||
&[&format!("'{query}'"), &format!("{} matches", names.len())],
|
||||
);
|
||||
let rows: Vec<ui::CatalogRow> = names
|
||||
.iter()
|
||||
.map(|name| catalog_row(&index.packages[*name], &state))
|
||||
.collect();
|
||||
ui::print_catalog(&rows);
|
||||
for name in names {
|
||||
print_index_entry(&index.packages[name], &state);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
|
@ -663,45 +531,41 @@ fn cmd_info(name: &str, track: Track) -> Result<()> {
|
|||
|
||||
let state = state::State::load()?;
|
||||
let status = if let Some(inst) = state.packages.get(name) {
|
||||
ui::style(&format!("installed {}", inst.version), ui::GREEN)
|
||||
ui::style(&format!("installed ({})", inst.version), ui::GREEN)
|
||||
} else {
|
||||
ui::style("not installed", ui::DIM)
|
||||
};
|
||||
|
||||
let track_part = ui::track_tag(track);
|
||||
ui::heading(&pkg.name, &[&ui::dim(&pkg.version), &track_part]);
|
||||
println!(" {}\n", pkg.description);
|
||||
ui::kv("status", &status);
|
||||
ui::kv(
|
||||
"binaries",
|
||||
&pkg.binaries
|
||||
println!("{}{} {}", ui::style(&pkg.name, ui::BOLD), ui::track_badge(track), pkg.version);
|
||||
println!(" {}", pkg.description);
|
||||
println!(" status: {status}");
|
||||
println!(
|
||||
" binaries: {}",
|
||||
pkg.binaries
|
||||
.iter()
|
||||
.map(|b| b.name.as_str())
|
||||
.collect::<Vec<_>>()
|
||||
.join(", "),
|
||||
.join(", ")
|
||||
);
|
||||
if !pkg.system_deps.is_empty() {
|
||||
ui::kv("system deps", &pkg.system_deps.join(", "));
|
||||
println!(" system deps: {}", pkg.system_deps.join(", "));
|
||||
}
|
||||
if !pkg.optional_system_deps.is_empty() {
|
||||
ui::kv("optional", &pkg.optional_system_deps.join(", "));
|
||||
println!(" optional deps: {}", pkg.optional_system_deps.join(", "));
|
||||
}
|
||||
if !pkg.bread_deps.is_empty() {
|
||||
ui::kv("bread deps", &pkg.bread_deps.join(", "));
|
||||
println!(" bread deps: {}", pkg.bread_deps.join(", "));
|
||||
}
|
||||
if !pkg.services.is_empty() {
|
||||
ui::kv(
|
||||
"services",
|
||||
&pkg.services
|
||||
println!(
|
||||
" services: {}",
|
||||
pkg.services
|
||||
.iter()
|
||||
.map(|s| s.unit.as_str())
|
||||
.collect::<Vec<_>>()
|
||||
.join(", "),
|
||||
.join(", ")
|
||||
);
|
||||
}
|
||||
if let Some(inst) = state.packages.get(name) {
|
||||
ui::kv("installed", &ui::short_date(&inst.installed_at));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
|
@ -720,33 +584,18 @@ fn cmd_doctor(name: Option<&str>, track: Track, bin_dir: &std::path::Path) -> Re
|
|||
};
|
||||
|
||||
if targets.is_empty() {
|
||||
println!("{}", ui::dim("no packages installed — nothing to check"));
|
||||
println!("no packages installed — nothing to check");
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let mut targets = targets;
|
||||
targets.sort();
|
||||
ui::heading("Doctor", &[&format!("{} packages", targets.len())]);
|
||||
let name_w = ui::name_width(&targets);
|
||||
|
||||
let mut all_ok = true;
|
||||
for pkg_name in &targets {
|
||||
if let Some(pkg) = index.get(pkg_name) {
|
||||
if !doctor::report(
|
||||
pkg_name,
|
||||
&pkg.system_deps,
|
||||
&pkg.optional_system_deps,
|
||||
name_w,
|
||||
) {
|
||||
if !doctor::report(pkg_name, &pkg.system_deps, &pkg.optional_system_deps) {
|
||||
all_ok = false;
|
||||
}
|
||||
} else {
|
||||
ui::check_row(
|
||||
false,
|
||||
pkg_name,
|
||||
name_w,
|
||||
"not found in index (removed from registry?)",
|
||||
);
|
||||
eprintln!(" {pkg_name}: not found in index (removed from registry?)");
|
||||
all_ok = false;
|
||||
}
|
||||
|
||||
|
|
@ -772,7 +621,7 @@ fn cmd_doctor(name: Option<&str>, track: Track, bin_dir: &std::path::Path) -> Re
|
|||
}
|
||||
|
||||
if all_ok {
|
||||
ui::summary(&[&ui::ok("all checks passed")]);
|
||||
println!("{}", ui::ok("all checks passed"));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
|
@ -825,47 +674,38 @@ fn cmd_verify(name: Option<&str>, bin_dir: &std::path::Path) -> Result<()> {
|
|||
};
|
||||
|
||||
if targets.is_empty() {
|
||||
println!("{}", ui::dim("no packages installed — nothing to verify"));
|
||||
println!("no packages installed — nothing to verify");
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let mut targets = targets;
|
||||
targets.sort();
|
||||
ui::heading("Verify", &[&format!("{} packages", targets.len())]);
|
||||
let name_w = ui::name_width(&targets);
|
||||
|
||||
let mut any_bad = false;
|
||||
for pkg_name in &targets {
|
||||
let installed = &state.packages[pkg_name];
|
||||
if installed.binary_sha256.is_empty() {
|
||||
ui::unknown_row(
|
||||
pkg_name,
|
||||
name_w,
|
||||
"no recorded checksums (installed before verify support)",
|
||||
println!(
|
||||
" {} {pkg_name}: no recorded checksums (installed before 'bakery verify' support)",
|
||||
ui::style("?", ui::DIM)
|
||||
);
|
||||
continue;
|
||||
}
|
||||
for bin in &installed.binaries {
|
||||
match verify_binary(bin_dir, bin, installed.binary_sha256.get(bin)) {
|
||||
VerifyStatus::Ok => ui::check_row(true, pkg_name, name_w, bin),
|
||||
VerifyStatus::Ok => println!(" {}", ui::ok(&format!("{pkg_name}: {bin}"))),
|
||||
VerifyStatus::Missing => {
|
||||
ui::check_row(false, pkg_name, name_w, &format!("{bin} missing"));
|
||||
eprintln!(" {}", ui::fail(&format!("{pkg_name}: {bin} — MISSING")));
|
||||
any_bad = true;
|
||||
}
|
||||
VerifyStatus::Tampered => {
|
||||
ui::check_row(
|
||||
false,
|
||||
pkg_name,
|
||||
name_w,
|
||||
&format!("{bin} tampered (checksum mismatch)"),
|
||||
eprintln!(
|
||||
" {}",
|
||||
ui::fail(&format!("{pkg_name}: {bin} — TAMPERED (checksum mismatch)"))
|
||||
);
|
||||
any_bad = true;
|
||||
}
|
||||
VerifyStatus::Unknown => {
|
||||
ui::unknown_row(
|
||||
pkg_name,
|
||||
name_w,
|
||||
&format!("{bin} no recorded checksum for this binary"),
|
||||
println!(
|
||||
" {} {pkg_name}: {bin} — UNKNOWN (no recorded checksum for this binary)",
|
||||
ui::style("?", ui::DIM)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
@ -875,7 +715,7 @@ fn cmd_verify(name: Option<&str>, bin_dir: &std::path::Path) -> Result<()> {
|
|||
if any_bad {
|
||||
bail!("verification failed for one or more binaries");
|
||||
}
|
||||
ui::summary(&[&ui::ok("all recorded checksums match")]);
|
||||
println!("{}", ui::ok("all recorded checksums match"));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
|
@ -888,19 +728,12 @@ fn cmd_verify(name: Option<&str>, bin_dir: &std::path::Path) -> Result<()> {
|
|||
/// why rollback is backup-based rather than a network re-pin in the first
|
||||
/// place. Pure with respect to global state (caller supplies both dirs), so
|
||||
/// this is the piece of `bakery rollback` that's directly unit-testable.
|
||||
fn restore_binaries(
|
||||
backup_dir: &Path,
|
||||
binaries: &[String],
|
||||
bin_dir: &Path,
|
||||
) -> Result<HashMap<String, String>> {
|
||||
fn restore_binaries(backup_dir: &Path, binaries: &[String], bin_dir: &Path) -> Result<HashMap<String, String>> {
|
||||
let mut sha256 = HashMap::new();
|
||||
for bin in binaries {
|
||||
let backup_path = backup_dir.join(bin);
|
||||
if !backup_path.exists() {
|
||||
bail!(
|
||||
"backup for binary '{bin}' is missing at {}",
|
||||
backup_path.display()
|
||||
);
|
||||
bail!("backup for binary '{bin}' is missing at {}", backup_path.display());
|
||||
}
|
||||
let bytes = std::fs::read(&backup_path)
|
||||
.with_context(|| format!("reading backup {}", backup_path.display()))?;
|
||||
|
|
@ -934,8 +767,6 @@ fn cmd_rollback(pkg_name: &str, bin_dir: &std::path::Path) -> Result<()> {
|
|||
anyhow::anyhow!("no previous version recorded for {pkg_name} — nothing to roll back to")
|
||||
})?;
|
||||
|
||||
ui::action("Rolling back", pkg_name, Some(&target_version));
|
||||
|
||||
let backup_dir = state::backup_dir(pkg_name, &target_version);
|
||||
if !backup_dir.exists() {
|
||||
bail!(
|
||||
|
|
@ -963,10 +794,7 @@ fn cmd_rollback(pkg_name: &str, bin_dir: &std::path::Path) -> Result<()> {
|
|||
|
||||
println!(
|
||||
" {}",
|
||||
ui::ok(&format!(
|
||||
"rolled back {pkg_name} {} → {target_version}",
|
||||
ui::dim(&from_version)
|
||||
))
|
||||
ui::ok(&format!("rolled back {pkg_name} {from_version} → {target_version}"))
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
|
@ -1010,33 +838,18 @@ mod tests {
|
|||
fn should_update_true_on_track_switch_even_if_not_newer_by_semver() {
|
||||
// "bakery track set stable && bakery update --all" from beta must
|
||||
// always take effect, even though 0.3.0 < 0.4.0-beta by strict semver.
|
||||
assert!(should_update(
|
||||
"0.4.0-beta",
|
||||
Track::Beta,
|
||||
Track::Stable,
|
||||
"0.3.0"
|
||||
));
|
||||
assert!(should_update("0.4.0-beta", Track::Beta, Track::Stable, "0.3.0"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn should_update_false_when_same_track_and_not_newer() {
|
||||
assert!(!should_update(
|
||||
"0.3.1",
|
||||
Track::Stable,
|
||||
Track::Stable,
|
||||
"0.3.1"
|
||||
));
|
||||
assert!(!should_update("0.3.1", Track::Stable, Track::Stable, "0.3.1"));
|
||||
assert!(!should_update("0.3.2", Track::Dev, Track::Dev, "0.3.1"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn should_update_true_when_same_track_and_newer() {
|
||||
assert!(should_update(
|
||||
"0.3.1",
|
||||
Track::Stable,
|
||||
Track::Stable,
|
||||
"0.3.2"
|
||||
));
|
||||
assert!(should_update("0.3.1", Track::Stable, Track::Stable, "0.3.2"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1089,10 +902,7 @@ mod tests {
|
|||
let pkg = empty_binary_package(name, "9.9.9", "http://127.0.0.1:1/unreachable");
|
||||
let mut packages = std::collections::HashMap::new();
|
||||
packages.insert(name.to_string(), pkg);
|
||||
let index = manifest::Index {
|
||||
version: "1".to_string(),
|
||||
packages,
|
||||
};
|
||||
let index = manifest::Index { version: "1".to_string(), packages };
|
||||
|
||||
let bin_dir = tempdir().unwrap();
|
||||
let mut visited = HashSet::new();
|
||||
|
|
@ -1116,10 +926,7 @@ mod tests {
|
|||
let dir = tempdir().unwrap();
|
||||
fs::write(dir.path().join("mypkg"), b"good bytes").unwrap();
|
||||
let hash = hex::encode(Sha256::digest(b"good bytes"));
|
||||
assert_eq!(
|
||||
verify_binary(dir.path(), "mypkg", Some(&hash)),
|
||||
VerifyStatus::Ok
|
||||
);
|
||||
assert_eq!(verify_binary(dir.path(), "mypkg", Some(&hash)), VerifyStatus::Ok);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1127,30 +934,21 @@ mod tests {
|
|||
let dir = tempdir().unwrap();
|
||||
fs::write(dir.path().join("mypkg"), b"tampered bytes").unwrap();
|
||||
let wrong_hash = "0".repeat(64);
|
||||
assert_eq!(
|
||||
verify_binary(dir.path(), "mypkg", Some(&wrong_hash)),
|
||||
VerifyStatus::Tampered
|
||||
);
|
||||
assert_eq!(verify_binary(dir.path(), "mypkg", Some(&wrong_hash)), VerifyStatus::Tampered);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn verify_binary_missing_when_file_absent() {
|
||||
let dir = tempdir().unwrap();
|
||||
let hash = "0".repeat(64);
|
||||
assert_eq!(
|
||||
verify_binary(dir.path(), "nope", Some(&hash)),
|
||||
VerifyStatus::Missing
|
||||
);
|
||||
assert_eq!(verify_binary(dir.path(), "nope", Some(&hash)), VerifyStatus::Missing);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn verify_binary_unknown_when_no_recorded_hash() {
|
||||
let dir = tempdir().unwrap();
|
||||
fs::write(dir.path().join("mypkg"), b"bytes").unwrap();
|
||||
assert_eq!(
|
||||
verify_binary(dir.path(), "mypkg", None),
|
||||
VerifyStatus::Unknown
|
||||
);
|
||||
assert_eq!(verify_binary(dir.path(), "mypkg", None), VerifyStatus::Unknown);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1164,14 +962,8 @@ mod tests {
|
|||
|
||||
let hashes = restore_binaries(&backup_dir, &["mypkg".to_string()], &bin_dir).unwrap();
|
||||
|
||||
assert_eq!(
|
||||
fs::read(bin_dir.join("mypkg")).unwrap(),
|
||||
b"old version bytes"
|
||||
);
|
||||
assert_eq!(
|
||||
hashes["mypkg"],
|
||||
hex::encode(Sha256::digest(b"old version bytes"))
|
||||
);
|
||||
assert_eq!(fs::read(bin_dir.join("mypkg")).unwrap(), b"old version bytes");
|
||||
assert_eq!(hashes["mypkg"], hex::encode(Sha256::digest(b"old version bytes")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
|
|
@ -52,7 +52,8 @@ fn verify_index_signature(bytes: &[u8], sig_text: &str) -> Result<()> {
|
|||
/// exercise the verification logic with a throwaway keypair instead of the
|
||||
/// real production key.
|
||||
fn verify_against_key(bytes: &[u8], sig_text: &str, pubkey_b64: &str) -> Result<()> {
|
||||
let public_key = PublicKey::from_base64(pubkey_b64).context("public key is malformed")?;
|
||||
let public_key =
|
||||
PublicKey::from_base64(pubkey_b64).context("public key is malformed")?;
|
||||
let signature =
|
||||
Signature::decode(sig_text).context("index.json.minisig is malformed or unreadable")?;
|
||||
public_key
|
||||
|
|
@ -182,7 +183,9 @@ pub fn load(force_refresh: bool, track: Track) -> Result<Index> {
|
|||
match read_and_verify_cache(&cache_path, &sig_cache_path, track) {
|
||||
Ok(index) => return Ok(index),
|
||||
Err(err) => {
|
||||
eprintln!(" warning: cached index.json failed verification ({err}), re-fetching…");
|
||||
eprintln!(
|
||||
" warning: cached index.json failed verification ({err}), re-fetching…"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -208,12 +211,17 @@ pub fn load(force_refresh: bool, track: Track) -> Result<Index> {
|
|||
}
|
||||
}
|
||||
|
||||
fn read_and_verify_cache(cache_path: &Path, sig_cache_path: &Path, track: Track) -> Result<Index> {
|
||||
fn read_and_verify_cache(
|
||||
cache_path: &Path,
|
||||
sig_cache_path: &Path,
|
||||
track: Track,
|
||||
) -> Result<Index> {
|
||||
let bytes = std::fs::read(cache_path).context("reading cached index")?;
|
||||
let sig_text = std::fs::read_to_string(sig_cache_path)
|
||||
.context("reading cached index.json.minisig (cache predates signing support)")?;
|
||||
verify_index_signature(&bytes, &sig_text)
|
||||
.with_context(|| format!("cached {track} index failed signature verification"))?;
|
||||
verify_index_signature(&bytes, &sig_text).with_context(|| {
|
||||
format!("cached {track} index failed signature verification")
|
||||
})?;
|
||||
serde_json::from_slice(&bytes).context("parsing cached index")
|
||||
}
|
||||
|
||||
|
|
@ -277,10 +285,8 @@ pub fn fetch_binary(primary_url: &str, fallback_url: &str) -> Result<Vec<u8>> {
|
|||
Ok(bytes) => Ok(bytes),
|
||||
Err(primary_err) => {
|
||||
eprintln!(
|
||||
" {}",
|
||||
crate::ui::note(&format!(
|
||||
"primary URL failed ({primary_err}), trying GitHub fallback…"
|
||||
))
|
||||
" primary URL failed ({}), trying GitHub fallback…",
|
||||
primary_err
|
||||
);
|
||||
fetch_bytes(fallback_url).context("both primary and GitHub fallback failed")
|
||||
}
|
||||
|
|
@ -299,7 +305,9 @@ const CHUNK_SIZE: usize = 64 * 1024;
|
|||
|
||||
fn fetch_bytes(url: &str) -> Result<Vec<u8>> {
|
||||
use std::io::{IsTerminal, Read};
|
||||
let resp = ureq::get(url).call().map_err(|e| anyhow::anyhow!("{e}"))?;
|
||||
let resp = ureq::get(url)
|
||||
.call()
|
||||
.map_err(|e| anyhow::anyhow!("{e}"))?;
|
||||
let status = resp.status();
|
||||
if status != 200 {
|
||||
bail!("HTTP {status} from {url}");
|
||||
|
|
@ -312,11 +320,7 @@ fn fetch_bytes(url: &str) -> Result<Vec<u8>> {
|
|||
// is what makes printing partway through the download possible, without
|
||||
// pulling in a progress-bar crate for what's meant to just be reassurance.
|
||||
let content_length: Option<u64> = resp.header("Content-Length").and_then(|v| v.parse().ok());
|
||||
// Progress is reassurance for multi-MB binaries. A 4 KB index fetch
|
||||
// drawing a 100% / 0.0 MB bar is noise, not feedback.
|
||||
const MIN_PROGRESS_BYTES: u64 = 256 * 1024;
|
||||
let show_progress =
|
||||
content_length.is_some_and(|n| n >= MIN_PROGRESS_BYTES) && std::io::stderr().is_terminal();
|
||||
let show_progress = content_length.is_some() && std::io::stderr().is_terminal();
|
||||
|
||||
let mut buf = Vec::new();
|
||||
let mut reader = resp.into_reader();
|
||||
|
|
@ -332,17 +336,27 @@ fn fetch_bytes(url: &str) -> Result<Vec<u8>> {
|
|||
bail!("response from {url} exceeds the {MAX_RESPONSE_BYTES}-byte limit");
|
||||
}
|
||||
if show_progress && last_print.elapsed() >= PROGRESS_THROTTLE {
|
||||
crate::ui::print_progress(buf.len() as u64, content_length.unwrap());
|
||||
print_progress(buf.len() as u64, content_length.unwrap());
|
||||
last_print = std::time::Instant::now();
|
||||
}
|
||||
}
|
||||
if show_progress {
|
||||
crate::ui::print_progress(buf.len() as u64, content_length.unwrap());
|
||||
crate::ui::finish_progress();
|
||||
print_progress(buf.len() as u64, content_length.unwrap());
|
||||
eprintln!();
|
||||
}
|
||||
Ok(buf)
|
||||
}
|
||||
|
||||
fn print_progress(downloaded: u64, total: u64) {
|
||||
use std::io::Write;
|
||||
eprint!(
|
||||
"\r ⇣ {:.1}/{:.1} MB",
|
||||
downloaded as f64 / 1_048_576.0,
|
||||
total as f64 / 1_048_576.0
|
||||
);
|
||||
let _ = std::io::stderr().flush();
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
|
@ -394,7 +408,10 @@ znmVfINB4jFDR2a4wuY8rOKlUBeSDOFjMkHYDXV3vxvAjK+r4V12ae9ZRQkfVtQ1YIEmFXbnJfbxywg+
|
|||
fn stable_cache_path_matches_pre_track_filename() {
|
||||
// Must stay exactly "index.json" so an existing warm cache from a
|
||||
// pre-track bakery binary is still used after an upgrade.
|
||||
assert_eq!(cache_path(Track::Stable).file_name().unwrap(), "index.json");
|
||||
assert_eq!(
|
||||
cache_path(Track::Stable).file_name().unwrap(),
|
||||
"index.json"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -411,22 +428,13 @@ znmVfINB4jFDR2a4wuY8rOKlUBeSDOFjMkHYDXV3vxvAjK+r4V12ae9ZRQkfVtQ1YIEmFXbnJfbxywg+
|
|||
|
||||
#[test]
|
||||
fn stable_url_has_no_track_prefix() {
|
||||
assert_eq!(
|
||||
primary_url(Track::Stable),
|
||||
format!("{}/index.json", base_url())
|
||||
);
|
||||
assert_eq!(primary_url(Track::Stable), format!("{}/index.json", base_url()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn beta_and_dev_urls_are_track_prefixed() {
|
||||
assert_eq!(
|
||||
primary_url(Track::Beta),
|
||||
format!("{}/beta/index.json", base_url())
|
||||
);
|
||||
assert_eq!(
|
||||
primary_url(Track::Dev),
|
||||
format!("{}/dev/index.json", base_url())
|
||||
);
|
||||
assert_eq!(primary_url(Track::Beta), format!("{}/beta/index.json", base_url()));
|
||||
assert_eq!(primary_url(Track::Dev), format!("{}/dev/index.json", base_url()));
|
||||
}
|
||||
|
||||
fn minimal_package_json() -> &'static str {
|
||||
|
|
|
|||
385
bakery/src/ui.rs
385
bakery/src/ui.rs
|
|
@ -1,6 +1,5 @@
|
|||
use crate::track::Track;
|
||||
use clap::builder::styling::{AnsiColor, Effects, Styles};
|
||||
use std::io::{IsTerminal, Write};
|
||||
use std::io::IsTerminal;
|
||||
|
||||
pub const RESET: &str = "\x1b[0m";
|
||||
pub const BOLD: &str = "\x1b[1m";
|
||||
|
|
@ -10,19 +9,6 @@ pub const GREEN: &str = "\x1b[32m";
|
|||
pub const YELLOW: &str = "\x1b[33m";
|
||||
pub const CYAN: &str = "\x1b[36m";
|
||||
pub const MAGENTA: &str = "\x1b[35m";
|
||||
pub const BOLD_CYAN: &str = "\x1b[1;36m";
|
||||
|
||||
/// Clap help styling — same cyan headers / green literals / dim placeholders
|
||||
/// as the rest of bakery, so `bakery --help` doesn't look like a different
|
||||
/// program from `bakery list`.
|
||||
pub const CLAP_STYLES: Styles = Styles::styled()
|
||||
.header(AnsiColor::Cyan.on_default().effects(Effects::BOLD))
|
||||
.usage(AnsiColor::Cyan.on_default().effects(Effects::BOLD))
|
||||
.literal(AnsiColor::Green.on_default().effects(Effects::BOLD))
|
||||
.placeholder(AnsiColor::BrightBlack.on_default())
|
||||
.error(AnsiColor::Red.on_default().effects(Effects::BOLD))
|
||||
.valid(AnsiColor::Green.on_default().effects(Effects::BOLD))
|
||||
.invalid(AnsiColor::Yellow.on_default().effects(Effects::BOLD));
|
||||
|
||||
/// Colors are on only when stdout is a real terminal and `NO_COLOR` isn't
|
||||
/// set — the ecosystem's existing CLI (breadcrumbs) hardcodes ANSI
|
||||
|
|
@ -32,52 +18,21 @@ pub fn colors_enabled() -> bool {
|
|||
std::env::var_os("NO_COLOR").is_none() && std::io::stdout().is_terminal()
|
||||
}
|
||||
|
||||
pub fn colors_enabled_err() -> bool {
|
||||
std::env::var_os("NO_COLOR").is_none() && std::io::stderr().is_terminal()
|
||||
}
|
||||
|
||||
pub fn style(s: &str, code: &str) -> String {
|
||||
paint(s, code, colors_enabled())
|
||||
}
|
||||
|
||||
fn style_err(s: &str, code: &str) -> String {
|
||||
paint(s, code, colors_enabled_err())
|
||||
}
|
||||
|
||||
fn paint(s: &str, code: &str, on: bool) -> String {
|
||||
if on {
|
||||
if colors_enabled() {
|
||||
format!("{code}{s}{RESET}")
|
||||
} else {
|
||||
s.to_string()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn bold(s: &str) -> String {
|
||||
style(s, BOLD)
|
||||
}
|
||||
|
||||
pub fn dim(s: &str) -> String {
|
||||
style(s, DIM)
|
||||
}
|
||||
|
||||
/// `" [beta]"` / `" [dev]"`, colored — empty string for `Stable` so the
|
||||
/// common-case output is unchanged.
|
||||
#[allow(dead_code)]
|
||||
pub fn track_badge(track: Track) -> String {
|
||||
let tag = track_tag(track);
|
||||
if tag.is_empty() {
|
||||
tag
|
||||
} else {
|
||||
format!(" {tag}")
|
||||
}
|
||||
}
|
||||
|
||||
/// `[beta]` / `[dev]` with no leading space; empty for `Stable`.
|
||||
pub fn track_tag(track: Track) -> String {
|
||||
match track {
|
||||
Track::Stable => String::new(),
|
||||
Track::Beta => style("[beta]", YELLOW),
|
||||
Track::Dev => style("[dev]", MAGENTA),
|
||||
Track::Beta => format!(" {}", style("[beta]", YELLOW)),
|
||||
Track::Dev => format!(" {}", style("[dev]", MAGENTA)),
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -99,278 +54,6 @@ pub fn unchanged(s: &str) -> String {
|
|||
style(&format!("· {s}"), DIM)
|
||||
}
|
||||
|
||||
pub fn warn(s: &str) -> String {
|
||||
style(&format!("warning: {s}"), YELLOW)
|
||||
}
|
||||
|
||||
pub fn note(s: &str) -> String {
|
||||
style(&format!("note: {s}"), DIM)
|
||||
}
|
||||
|
||||
/// Cyan verb + bold name + dim version — the install/update/remove banner.
|
||||
pub fn action(verb: &str, name: &str, version: Option<&str>) {
|
||||
let mut line = format!("{} {}", style(verb, BOLD_CYAN), style(name, BOLD));
|
||||
if let Some(v) = version {
|
||||
line.push_str(" ");
|
||||
line.push_str(&style(v, DIM));
|
||||
}
|
||||
println!("{line}");
|
||||
}
|
||||
|
||||
/// Section title plus dim meta (`Packages 16 · 15 installed`).
|
||||
pub fn heading(title: &str, parts: &[&str]) {
|
||||
let mut line = style(title, BOLD_CYAN);
|
||||
let visible: Vec<&str> = parts.iter().copied().filter(|p| !p.is_empty()).collect();
|
||||
for (i, part) in visible.iter().enumerate() {
|
||||
line.push_str(" ");
|
||||
if i > 0 {
|
||||
line.push_str(&style("·", DIM));
|
||||
line.push_str(" ");
|
||||
}
|
||||
line.push_str(part);
|
||||
}
|
||||
println!("{line}");
|
||||
println!();
|
||||
}
|
||||
|
||||
pub fn summary(parts: &[&str]) {
|
||||
let visible: Vec<&str> = parts.iter().copied().filter(|p| !p.is_empty()).collect();
|
||||
if visible.is_empty() {
|
||||
return;
|
||||
}
|
||||
println!();
|
||||
println!("{}", style(&visible.join(" · "), BOLD));
|
||||
}
|
||||
|
||||
/// Left-aligned verb column so install chatter (`downloading` / `placed` /
|
||||
/// `unit`) lines up instead of drifting with the verb length.
|
||||
pub fn step(verb: &str, detail: &str) {
|
||||
println!(" {:<12} {}", dim(verb), detail);
|
||||
}
|
||||
|
||||
pub fn kv(key: &str, value: &str) {
|
||||
println!(" {:<12} {}", dim(key), value);
|
||||
}
|
||||
|
||||
pub fn check_row(ok_flag: bool, name: &str, name_width: usize, message: &str) {
|
||||
let glyph = if ok_flag {
|
||||
style("✓", GREEN)
|
||||
} else {
|
||||
style("✗", RED)
|
||||
};
|
||||
println!(" {glyph} {:<name_width$} {message}", name);
|
||||
}
|
||||
|
||||
pub fn unknown_row(name: &str, name_width: usize, message: &str) {
|
||||
println!(
|
||||
" {} {:<name_width$} {}",
|
||||
style("?", DIM),
|
||||
name,
|
||||
dim(message)
|
||||
);
|
||||
}
|
||||
|
||||
pub struct CatalogRow {
|
||||
pub name: String,
|
||||
pub version: String,
|
||||
pub installed: bool,
|
||||
/// Wrapped onto following lines (descriptions).
|
||||
pub detail: String,
|
||||
/// Same-line suffix after the version (short dates). Empty for catalog
|
||||
/// views that already use `detail`.
|
||||
pub aside: String,
|
||||
}
|
||||
|
||||
/// Two-line catalog: status glyph + aligned name/version, then a hanging
|
||||
/// description (or date) wrapped to the terminal width. Column widths are
|
||||
/// computed from the row set so long `-dev.` versions no longer smash the
|
||||
/// old `{: <10}` pad.
|
||||
pub fn print_catalog(rows: &[CatalogRow]) {
|
||||
for line in format_catalog(rows, term_width()) {
|
||||
println!("{line}");
|
||||
}
|
||||
}
|
||||
|
||||
pub fn format_catalog(rows: &[CatalogRow], width: usize) -> Vec<String> {
|
||||
if rows.is_empty() {
|
||||
return Vec::new();
|
||||
}
|
||||
let name_w = rows.iter().map(|r| r.name.len()).max().unwrap_or(0);
|
||||
let indent = 5; // " ✓ " / " "
|
||||
let detail_width = width.saturating_sub(indent).max(24);
|
||||
|
||||
let mut lines = Vec::new();
|
||||
for row in rows {
|
||||
let glyph = if row.installed {
|
||||
style("✓", GREEN)
|
||||
} else {
|
||||
" ".to_string()
|
||||
};
|
||||
let name = style(&format!("{:<name_w$}", row.name), BOLD);
|
||||
let version = style(&row.version, DIM);
|
||||
let mut line = format!(" {glyph} {name} {version}");
|
||||
if !row.aside.is_empty() {
|
||||
line.push_str(" ");
|
||||
line.push_str(&dim(&row.aside));
|
||||
}
|
||||
lines.push(line);
|
||||
if !row.detail.is_empty() {
|
||||
for wrapped in wrap_words(&row.detail, detail_width) {
|
||||
lines.push(format!(" {}", dim(&wrapped)));
|
||||
}
|
||||
}
|
||||
}
|
||||
lines
|
||||
}
|
||||
|
||||
pub fn wrap_words(text: &str, width: usize) -> Vec<String> {
|
||||
if width == 0 {
|
||||
return vec![text.to_string()];
|
||||
}
|
||||
let mut lines = Vec::new();
|
||||
let mut cur = String::new();
|
||||
for word in text.split_whitespace() {
|
||||
if cur.is_empty() {
|
||||
cur = word.to_string();
|
||||
} else if cur.len() + 1 + word.len() <= width {
|
||||
cur.push(' ');
|
||||
cur.push_str(word);
|
||||
} else {
|
||||
lines.push(std::mem::take(&mut cur));
|
||||
cur = word.to_string();
|
||||
}
|
||||
}
|
||||
if !cur.is_empty() {
|
||||
lines.push(cur);
|
||||
}
|
||||
lines
|
||||
}
|
||||
|
||||
pub fn short_date(rfc3339: &str) -> String {
|
||||
chrono::DateTime::parse_from_rfc3339(rfc3339)
|
||||
.map(|dt| dt.format("%Y-%m-%d").to_string())
|
||||
.unwrap_or_else(|_| rfc3339.to_string())
|
||||
}
|
||||
|
||||
pub fn name_width<S: AsRef<str>>(names: impl IntoIterator<Item = S>) -> usize {
|
||||
names
|
||||
.into_iter()
|
||||
.map(|s| s.as_ref().len())
|
||||
.max()
|
||||
.unwrap_or(0)
|
||||
}
|
||||
|
||||
/// `\r`-overwritten download bar on stderr. Pads to a stable width so a
|
||||
/// shorter later frame doesn't leave leftover characters from a longer one.
|
||||
pub fn print_progress(downloaded: u64, total: u64) {
|
||||
let width = term_width().clamp(40, 72);
|
||||
let line = progress_line(downloaded, total, 20);
|
||||
let padded = fit_width(&line, width);
|
||||
eprint!("\r{padded}");
|
||||
let _ = std::io::stderr().flush();
|
||||
}
|
||||
|
||||
pub fn finish_progress() {
|
||||
eprintln!();
|
||||
}
|
||||
|
||||
pub fn progress_line(downloaded: u64, total: u64, bar_width: usize) -> String {
|
||||
let dl = downloaded as f64 / 1_048_576.0;
|
||||
let tot = total as f64 / 1_048_576.0;
|
||||
let frac = if total == 0 {
|
||||
0.0
|
||||
} else {
|
||||
(downloaded as f64 / total as f64).clamp(0.0, 1.0)
|
||||
};
|
||||
let filled = ((bar_width as f64) * frac).round() as usize;
|
||||
let filled = filled.min(bar_width);
|
||||
let bar = format!("{}{}", "█".repeat(filled), "░".repeat(bar_width - filled));
|
||||
let pct = (frac * 100.0).round() as u32;
|
||||
format!(
|
||||
" ⇣ {} {:>3}% {:.1}/{:.1} MB",
|
||||
style_err(&bar, CYAN),
|
||||
pct,
|
||||
dl,
|
||||
tot
|
||||
)
|
||||
}
|
||||
|
||||
fn fit_width(s: &str, width: usize) -> String {
|
||||
let visible = visible_len(s);
|
||||
if visible >= width {
|
||||
return s.to_string();
|
||||
}
|
||||
format!("{s}{}", " ".repeat(width - visible))
|
||||
}
|
||||
|
||||
fn visible_len(s: &str) -> usize {
|
||||
let mut n = 0;
|
||||
let mut chars = s.chars().peekable();
|
||||
while let Some(c) = chars.next() {
|
||||
if c == '\u{1b}' {
|
||||
if chars.peek() == Some(&'[') {
|
||||
chars.next();
|
||||
for next in chars.by_ref() {
|
||||
if next.is_ascii_alphabetic() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
n += 1;
|
||||
}
|
||||
n
|
||||
}
|
||||
|
||||
pub fn term_width() -> usize {
|
||||
if let Ok(w) = std::env::var("COLUMNS") {
|
||||
if let Ok(n) = w.parse::<usize>() {
|
||||
if n >= 40 {
|
||||
return n;
|
||||
}
|
||||
}
|
||||
}
|
||||
ioctl_width().filter(|&n| n >= 40).unwrap_or(80)
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
fn ioctl_width() -> Option<usize> {
|
||||
use std::os::fd::AsRawFd;
|
||||
|
||||
#[repr(C)]
|
||||
struct WinSize {
|
||||
row: u16,
|
||||
col: u16,
|
||||
x: u16,
|
||||
y: u16,
|
||||
}
|
||||
|
||||
unsafe extern "C" {
|
||||
fn ioctl(fd: i32, request: u64, argp: *mut WinSize) -> i32;
|
||||
}
|
||||
|
||||
let mut ws = WinSize {
|
||||
row: 0,
|
||||
col: 0,
|
||||
x: 0,
|
||||
y: 0,
|
||||
};
|
||||
// TIOCGWINSZ on Linux.
|
||||
let fd = std::io::stdout().as_raw_fd();
|
||||
let ret = unsafe { ioctl(fd, 0x5413, &mut ws) };
|
||||
if ret == 0 && ws.col > 0 {
|
||||
Some(ws.col as usize)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(unix))]
|
||||
fn ioctl_width() -> Option<usize> {
|
||||
None
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
|
@ -394,64 +77,4 @@ mod tests {
|
|||
assert!(!ok("foo").contains('·'));
|
||||
assert!(!fail("foo").contains('·'));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn catalog_aligns_names_and_versions() {
|
||||
let lines = format_catalog(
|
||||
&[
|
||||
CatalogRow {
|
||||
name: "bakery".into(),
|
||||
version: "0.7.2-dev.20260815142350+30517f1".into(),
|
||||
installed: true,
|
||||
detail: "Package manager".into(),
|
||||
aside: String::new(),
|
||||
},
|
||||
CatalogRow {
|
||||
name: "breadarr".into(),
|
||||
version: "0.1.2".into(),
|
||||
installed: false,
|
||||
detail: "Homelab arr stack".into(),
|
||||
aside: String::new(),
|
||||
},
|
||||
],
|
||||
80,
|
||||
);
|
||||
assert_eq!(lines.len(), 4);
|
||||
assert!(lines[0].contains("bakery"));
|
||||
assert!(lines[0].contains("0.7.2-dev.20260815142350+30517f1"));
|
||||
assert!(lines[1].contains("Package manager"));
|
||||
// Shorter version is padded so the columns stay a block, not a
|
||||
// ragged list — the long bakery version used to overflow `{: <10}`.
|
||||
// Compare display columns, not byte offsets: the installed glyph
|
||||
// is a 3-byte checkmark sitting in a 1-column slot.
|
||||
let bakery_col = visible_len(&lines[0][..lines[0].find("0.7.2-dev").unwrap()]);
|
||||
let breadarr_col = visible_len(&lines[2][..lines[2].find("0.1.2").unwrap()]);
|
||||
assert_eq!(bakery_col, breadarr_col);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wrap_words_breaks_on_width() {
|
||||
let lines = wrap_words("one two three four", 9);
|
||||
assert_eq!(lines, vec!["one two", "three", "four"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn progress_line_has_bar_and_percent() {
|
||||
let line = progress_line(1_048_576, 2_097_152, 10);
|
||||
assert!(line.contains('█'));
|
||||
assert!(line.contains('░'));
|
||||
assert!(line.contains("50%"));
|
||||
assert!(line.contains("1.0/2.0 MB"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn visible_len_ignores_ansi() {
|
||||
assert_eq!(visible_len("hello"), 5);
|
||||
assert_eq!(visible_len(&format!("{CYAN}hello{RESET}")), 5);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn short_date_from_rfc3339() {
|
||||
assert_eq!(short_date("2026-08-15T14:23:50+00:00"), "2026-08-15");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue