Skip to content

Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.

10.9 KB
Raw Blame
//! Windows consumes V3; released macOS readers retain the V2 projection unchanged.
use crate::{MAX_RELEASE_FEED_BYTES, ReleaseNotes, WebsiteReleasesV2};
use semver::Version;
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use std::collections::BTreeSet;
pub const WINDOWS_RELEASE_FEED: &str = "https://hiroute.ai/releases-v3.json";

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct WebsiteReleasesV3 {
    schema: String,
    releases: Vec<ReleaseV3>,
}
#[derive(Clone, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
struct ReleaseV3 {
    version: String,
    channel: String,
    published_at: String,
    notes: ReleaseNotes,
    artifacts: Vec<Value>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct WindowsDesktopRelease {
    pub version: String,
    pub notes: ReleaseNotes,
    pub architecture: String,
    pub distribution: String,
    pub filename: String,
    pub sha256: String,
    pub size: u64,
}
impl WindowsDesktopRelease {
    pub fn revision_prefix(&self) -> Result<&str, &'static str> {
        let prefix = format!("HiRoute-{}-", self.version);
        let revision = self
            .filename
            .strip_prefix(&prefix)
            .and_then(|s| s.strip_suffix("-windows-x86_64-setup.exe"))
            .ok_or("UPGRADE_ARTIFACT_INVALID")?;
        if Version::parse(&self.version).is_err()
            || self.version.len() > 64
            || self.architecture != "x86_64"
            || self.distribution != "unsigned"
            || !facts(&self.filename, &self.sha256, self.size)
            || !revision_id(revision)
        {
            return Err("UPGRADE_ARTIFACT_INVALID");
        }
        Ok(revision)
    }
    pub fn download_url(&self) -> String {
        format!(
            "https://hiroute.ai/releases/{}/{}",
            self.version, self.filename
        )
    }
}
#[derive(Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
enum WindowsArtifact {
    Desktop {
        platform: String,
        architecture: String,
        format: String,
        distribution: String,
        filename: String,
        sha256: String,
        size: u64,
    },
}
fn facts(name: &str, sha: &str, size: u64) -> bool {
    !name.is_empty()
        && name.len() <= 240
        && name
            .bytes()
            .all(|b| b.is_ascii_alphanumeric() || matches!(b, b'.' | b'_' | b'-'))
        && sha.len() == 64
        && sha
            .bytes()
            .all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b))
        && size > 0
        && size <= 2 * 1024 * 1024 * 1024
}
fn revision_id(value: &str) -> bool {
    value.len() == 12
        && value
            .bytes()
            .all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b))
}
impl WebsiteReleasesV3 {
    pub fn parse(bytes: &[u8]) -> Result<Self, &'static str> {
        let invalid = || "UPGRADE_CATALOG_INVALID";
        if bytes.is_empty() || bytes.len() > MAX_RELEASE_FEED_BYTES {
            return Err(invalid());
        }
        let catalog: Self = serde_json::from_slice(bytes).map_err(|_| invalid())?;
        if catalog.schema != "hiroute.website.releases/v3" || catalog.releases.len() > 64 {
            return Err(invalid());
        }
        let mut versions = BTreeSet::new();
        for release in &catalog.releases {
            let version = Version::parse(&release.version).map_err(|_| invalid())?;
            if release.version.len() > 64
                || !versions.insert(&release.version)
                || !matches!(release.channel.as_str(), "stable" | "preview")
                || (release.channel == "stable" && !version.pre.is_empty())
                || release.published_at.is_empty()
                || release.published_at.len() > 64
                || [&release.notes.zh, &release.notes.en]
                    .iter()
                    .any(|s| s.trim().is_empty() || s.len() > 64 * 1024)
                || release.artifacts.is_empty()
                || release.artifacts.len() > 16
            {
                return Err(invalid());
            }
            let mut names = BTreeSet::new();
            for value in &release.artifacts {
                let filename = value["filename"].as_str().ok_or_else(invalid)?;
                if !names.insert(filename) {
                    return Err(invalid());
                }
                if let Some(name) = value.get("manifest_filename")
                    && !names.insert(name.as_str().ok_or_else(invalid)?)
                {
                    return Err(invalid());
                }
                if value["platform"] != "Windows" {
                    continue;
                }
                match serde_json::from_value::<WindowsArtifact>(value.clone())
                    .map_err(|_| invalid())?
                {
                    WindowsArtifact::Desktop {
                        platform,
                        architecture,
                        format,
                        distribution,
                        filename,
                        sha256,
                        size,
                    } => {
                        if platform != "Windows" || format != "nsis" {
                            return Err(invalid());
                        }
                        WindowsDesktopRelease {
                            version: release.version.clone(),
                            notes: release.notes.clone(),
                            architecture,
                            distribution,
                            filename,
                            sha256,
                            size,
                        }
                        .revision_prefix()
                        .map_err(|_| invalid())?;
                    }
                }
            }
        }
        WebsiteReleasesV2::parse(&catalog.v2_projection()?)?;
        Ok(catalog)
    }
    pub fn v2_projection(&self) -> Result<Vec<u8>, &'static str> {
        let releases: Vec<_> = self
            .releases
            .iter()
            .filter_map(|release| {
                let mut release = release.clone();
                release.artifacts.retain(|a| a["platform"] != "Windows");
                (!release.artifacts.is_empty()).then_some(release)
            })
            .collect();
        serde_json::to_vec(&json!({"schema":"hiroute.website.releases/v2","releases":releases}))
            .map_err(|_| "UPGRADE_CATALOG_INVALID")
    }
    pub fn windows_update(
        &self,
        current: &str,
    ) -> Result<Option<WindowsDesktopRelease>, &'static str> {
        let current = Version::parse(current).map_err(|_| "UPGRADE_VERSION_INVALID")?;
        let mut selected: Option<(Version, WindowsDesktopRelease)> = None;
        for release in &self.releases {
            let version =
                Version::parse(&release.version).map_err(|_| "UPGRADE_CATALOG_INVALID")?;
            if release.channel != "stable"
                || version <= current
                || selected.as_ref().is_some_and(|(v, _)| v >= &version)
            {
                continue;
            }
            let candidates: Vec<_> = release
                .artifacts
                .iter()
                .filter(|a| a["kind"] == "desktop" && a["platform"] == "Windows")
                .collect();
            if candidates.len() > 1 {
                return Err("UPGRADE_ARTIFACT_AMBIGUOUS");
            }
            if let Some(value) = candidates.first() {
                let artifact: WindowsArtifact = serde_json::from_value((*value).clone())
                    .map_err(|_| "UPGRADE_CATALOG_INVALID")?;
                let WindowsArtifact::Desktop {
                    architecture,
                    distribution,
                    filename,
                    sha256,
                    size,
                    ..
                } = artifact;
                selected = Some((
                    version,
                    WindowsDesktopRelease {
                        version: release.version.clone(),
                        notes: release.notes.clone(),
                        architecture,
                        distribution,
                        filename,
                        sha256,
                        size,
                    },
                ));
            }
        }
        Ok(selected.map(|(_, value)| value))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    fn fixture() -> Value {
        json!({"schema":"hiroute.website.releases/v3","releases":[{"version":"0.4.0","channel":"stable","published_at":"2026-10-01T00:00:00Z","notes":{"zh":"测试","en":"Test"},"artifacts":[{"kind":"desktop","platform":"Windows","architecture":"x86_64","format":"nsis","distribution":"unsigned","filename":"HiRoute-0.4.0-aaaaaaaaaaaa-windows-x86_64-setup.exe","sha256":"a".repeat(64),"size":100}]}]})
    }
    #[test]
    fn windows_selection_and_legacy_projection_remain_separate() {
        let catalog = WebsiteReleasesV3::parse(&serde_json::to_vec(&fixture()).unwrap()).unwrap();
        assert!(WebsiteReleasesV2::parse(&catalog.v2_projection().unwrap()).is_ok());
        let update = catalog.windows_update("0.3.1").unwrap().unwrap();
        assert_eq!(update.revision_prefix().unwrap(), "aaaaaaaaaaaa");
        assert!(
            update
                .download_url()
                .starts_with("https://hiroute.ai/releases/0.4.0/")
        );
        assert!(catalog.windows_update("0.4.0").unwrap().is_none());
    }
    #[test]
    fn windows_standalone_archives_of_either_architecture_are_never_public() {
        for architecture in ["x86_64", "aarch64"] {
            let mut value = fixture();
            let target = format!("{architecture}-pc-windows-msvc");
            let name = format!("hiroute-0.4.0-aaaaaaaaaaaa-{target}.tar.gz");
            value["releases"][0]["artifacts"][0] = json!({"kind":"standalone","platform":"Windows",
                "architecture":architecture,"target":target,"format":"tar.gz","distribution":"unsigned",
                "filename":name,"sha256":"a".repeat(64),"size":100,
                "manifest_filename":format!("{name}.json"),"manifest_sha256":"b".repeat(64),"manifest_size":200});
            assert!(WebsiteReleasesV3::parse(&serde_json::to_vec(&value).unwrap()).is_err());
        }
    }
    #[test]
    fn invalid_windows_artifacts_cannot_be_selected_or_smuggled_into_a_catalog() {
        for (field, value) in [
            ("architecture", json!("aarch64")),
            ("distribution", json!("self-signed")),
            ("format", json!("exe")),
            ("filename", json!("../setup.exe")),
            ("sha256", json!("bad")),
            ("size", json!(0)),
            ("minimum_os", json!("any")),
        ] {
            let mut fixture = fixture();
            fixture["releases"][0]["artifacts"][0][field] = value;
            assert!(
                WebsiteReleasesV3::parse(&serde_json::to_vec(&fixture).unwrap()).is_err(),
                "{field}"
            );
        }
    }
}