use clap::{ArgAction, Args};
use is_terminal::IsTerminal;
use semver::Version;
pub(crate) const REPO_OWNER: &str = "byx-darwin";
pub(crate) const REPO_NAME: &str = "gitflow-cli";
pub(crate) const BIN_NAME: &str = "gf";
#[cfg(not(feature = "skip-verify"))]
const VERIFYING_KEY: [u8; 32] = [
115, 185, 47, 145, 23, 237, 255, 233, 186, 137, 155, 236, 246, 152, 123, 129, 154, 24, 245,
229, 138, 7, 69, 74, 76, 175, 104, 136, 203, 153, 193, 194,
];
fn parse_version(s: &str) -> Option<Version> {
Version::parse(s.trim_start_matches('v')).ok()
}
fn is_prerelease(v: &Version) -> bool {
!v.pre.is_empty()
}
fn select_target_version<'a>(
candidates: impl Iterator<Item = &'a str>,
current: &Version,
include_prerelease: bool,
) -> Option<String> {
candidates
.filter_map(parse_version)
.filter(|v| *v > *current && (include_prerelease || !is_prerelease(v)))
.max()
.map(|v| v.to_string())
}
fn current_version() -> String {
crate::built_info::PKG_VERSION.to_string()
}
fn target_triple() -> String {
self_update::get_target().to_string()
}
#[derive(Debug, Args)]
pub struct UpdateArgs {
#[arg(long, action = ArgAction::SetTrue)]
pub pre: bool,
#[arg(long, action = ArgAction::SetTrue)]
pub check: bool,
#[arg(short = 'y', long = "yes", action = ArgAction::SetTrue)]
pub yes: bool,
}
pub fn handle_update(args: &UpdateArgs) -> miette::Result<()> {
handle_update_with(args, fetch_release_versions)
}
fn handle_update_with(
args: &UpdateArgs,
fetch_versions: impl Fn(&str) -> miette::Result<Vec<String>>,
) -> miette::Result<()> {
let current = current_version();
let current_v =
parse_version(¤t).ok_or_else(|| miette::miette!("当前版本号无法解析: {current}"))?;
let target = target_triple();
let versions = fetch_versions(&target)?;
let Some(latest) =
select_target_version(versions.iter().map(String::as_str), ¤t_v, args.pre)
else {
println!("✅ 已是最新版本 v{current}");
return Ok(());
};
if args.check {
println!("当前版本: v{current}");
println!("最新版本: v{latest}");
return Ok(());
}
if !args.yes && !crate::commands::skills::confirm(&format!("是否更新到 v{latest}?"), true)?
{
println!("已取消更新");
return Ok(());
}
let mut updater = self_update::backends::github::Update::configure();
let builder = updater
.repo_owner(REPO_OWNER)
.repo_name(REPO_NAME)
.bin_name(BIN_NAME)
.current_version(¤t)
.target_version_tag(&format!("v{latest}"))
.target(&target)
.show_download_progress(true)
.show_output(true)
.no_confirm(true);
#[cfg(not(feature = "skip-verify"))]
{
builder.verifying_keys(vec![VERIFYING_KEY]);
}
let status = builder
.build()
.map_err(|e| miette::miette!("配置更新器失败: {e}"))?
.update()
.map_err(|e| miette::miette!("更新失败: {e}"))?;
println!("✅ gf 已更新到 v{}", status.version());
prompt_update_skills()?;
Ok(())
}
fn fetch_release_versions(target: &str) -> miette::Result<Vec<String>> {
let releases = self_update::backends::github::ReleaseList::configure()
.repo_owner(REPO_OWNER)
.repo_name(REPO_NAME)
.with_target(target)
.build()
.map_err(|e| miette::miette!("配置 release 查询失败: {e}"))?
.fetch()
.map_err(|e| miette::miette!("获取 release 列表失败: {e}"))?;
Ok(releases.into_iter().map(|r| r.version).collect())
}
fn prompt_update_skills() -> miette::Result<()> {
if !std::io::stderr().is_terminal() {
println!("ℹ️ 非交互模式,已跳过 skills 同步。可运行 `gf skills update -g` 手动更新。");
return Ok(());
}
if crate::commands::skills::confirm("是否同时更新全局 skills?", true)? {
let args = crate::commands::skills::SkillsUpdateArgs {
global: true,
agent: None,
custom_path: None,
};
crate::commands::skills::update_skills(&args)?;
}
Ok(())
}
#[cfg(test)]
#[allow(
clippy::expect_used,
clippy::unwrap_used,
clippy::panic,
reason = "允许在测试中使用 expect/unwrap/panic"
)]
mod tests {
use super::*;
#[test]
fn test_parse_version_stable() {
assert_eq!(parse_version("1.0.0"), Some(Version::new(1, 0, 0)));
}
#[test]
fn test_parse_version_strips_leading_v() {
assert_eq!(parse_version("v1.2.3"), Some(Version::new(1, 2, 3)));
}
#[test]
fn test_parse_version_prerelease() {
let v = parse_version("1.1.0-rc.1").expect("parse rc");
assert!(v.pre.to_string().contains("rc"));
}
#[test]
fn test_parse_version_invalid() {
assert_eq!(parse_version("not-a-version"), None);
assert_eq!(parse_version(""), None);
}
#[test]
fn test_is_prerelease_rc_is_prerelease() {
assert!(is_prerelease(&Version::parse("1.1.0-rc.1").expect("rc")));
}
#[test]
fn test_is_prerelease_stable_is_not() {
assert!(!is_prerelease(&Version::new(1, 1, 0)));
}
#[test]
fn test_select_target_version_ignores_prerelease_by_default() {
let candidates = ["1.0.1", "1.1.0-rc.1", "1.1.0"];
let current = Version::new(1, 0, 0);
assert_eq!(
select_target_version(candidates.into_iter(), ¤t, false).as_deref(),
Some("1.1.0")
);
}
#[test]
fn test_select_target_version_includes_prerelease_with_flag() {
let current = Version::new(1, 0, 0);
let candidates = ["1.1.0-rc.1", "1.1.0"];
assert_eq!(
select_target_version(candidates.into_iter(), ¤t, true).as_deref(),
Some("1.1.0")
);
let candidates = ["1.1.0-rc.1", "1.0.5"];
assert_eq!(
select_target_version(candidates.into_iter(), ¤t, true).as_deref(),
Some("1.1.0-rc.1")
);
}
#[test]
fn test_select_target_version_none_when_up_to_date() {
let candidates = ["0.9.0", "1.0.0"];
let current = Version::new(1, 0, 0);
assert_eq!(
select_target_version(candidates.into_iter(), ¤t, false),
None
);
}
#[test]
fn test_select_target_version_skips_invalid() {
let candidates = ["not-a-version", "", "1.0.1"];
let current = Version::new(1, 0, 0);
assert_eq!(
select_target_version(candidates.into_iter(), ¤t, false).as_deref(),
Some("1.0.1")
);
}
use clap::{Parser, Subcommand};
#[derive(Debug, Parser)]
struct TestCli {
#[command(subcommand)]
cmd: TestCmd,
}
#[derive(Debug, Subcommand)]
enum TestCmd {
Update(UpdateArgs),
}
#[test]
fn test_update_args_parse_flags() {
let cli = TestCli::parse_from(["test", "update", "--check", "--pre", "--yes"]);
let TestCmd::Update(args) = cli.cmd;
assert!(args.check);
assert!(args.pre);
assert!(args.yes);
}
#[test]
fn test_update_up_to_date_when_no_newer() {
let args = UpdateArgs {
pre: false,
check: false,
yes: true,
};
let versions = vec![current_version()];
let result = handle_update_with(&args, |_| Ok(versions.clone()));
assert!(result.is_ok());
}
#[test]
fn test_update_check_reports_latest_without_updating() {
let args = UpdateArgs {
pre: false,
check: true,
yes: false,
};
let versions = vec!["9.9.9".to_string()];
let result = handle_update_with(&args, |_| Ok(versions.clone()));
assert!(result.is_ok());
}
#[test]
#[cfg(not(feature = "skip-verify"))]
fn test_verifying_key_is_32_bytes() {
assert_eq!(VERIFYING_KEY.len(), 32);
assert!(VERIFYING_KEY.iter().any(|&b| b != 0));
}
}