From 53789b9bdd20a3ad88f18734d52f2de5c563e0af Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=94=D0=BC=D0=B8=D1=82=D1=80=D0=B8=D0=B9?= Date: Thu, 5 Nov 2026 16:09:29 +0500 Subject: [PATCH] Derive the Modules Preview update from a signed stable update coa-release derive-preview verifies the stable update package, unpacks it, replaces the core binaries with the plugin host build (same core commit), adds Core/plugin-sdk.zip and Core/plugins/recommended.json, and repacks it with the stable migrations, configuration and scripts unchanged. The result is signed with the preview key by coa-release sign. Tried on server-0.261104.94 and a CI plugin host: 37256 files, 3417 migrations, signature/archive/schema contract verified; the stable key rejects the package (env-driven test). New servers in the preview Manager are installed from the stable image; the preview core arrives as the first update. Co-Authored-By: Claude Opus 5.5 --- crates/coa-core/src/release.rs | 103 +++++++++++++++++++++++++++++++++ crates/coa-release/src/main.rs | 19 ++++++ src-tauri/src/lib.rs | 12 +++- 3 files changed, 133 insertions(+), 1 deletion(-) diff --git a/crates/coa-core/src/release.rs b/crates/coa-core/src/release.rs index 5fe7506..5655e2d 100644 --- a/crates/coa-core/src/release.rs +++ b/crates/coa-core/src/release.rs @@ -572,3 +572,106 @@ mod tests { ); } } + +/// Input of `derive_preview_update`: a signed stable update package and the plugin-host core built from +/// the same core commit. +pub struct PreviewParams<'a> { + /// Folder with the stable release's manifest.json, manifest.json.sig and archive parts. + pub stable: &'a Path, + /// The plugin-host build: worldserver.exe, authserver.exe, plugin-sdk.zip and the DLLs they need. + pub core: &'a Path, + /// `Core/plugins/recommended.json` for the modules the stable release had built in. + pub recommended: &'a Path, + pub version: String, + pub core_commit: String, + pub min_manager_version: String, + pub out: &'a Path, +} + +/// The Modules Preview update: the stable package of the same core commit with the core binaries replaced +/// by the plugin host, its SDK and the recommended modules added. Database migrations, configuration and +/// scripts stay exactly those of the stable release, so the preview core runs on the same database. +/// The result is unsigned; `sign_manifest` signs it with the preview key. +pub fn derive_preview_update(p: &PreviewParams, progress: &dyn Fn(&str)) -> Result { + crate::release_schema::verify_package(p.stable, crate::signing::EMBEDDED_PUBLIC_KEY)?; + let stable = Manifest::parse(&fs::read(p.stable.join("manifest.json"))?)?; + if stable.kind != Kind::Update { + return Err(Error::Invalid("The stable package is not an update package.".into())); + } + let preview_tuple = crate::manifest::parse_version(&p.version); + if preview_tuple.is_none() || preview_tuple <= crate::manifest::parse_version(&stable.version) { + return Err(Error::Invalid(format!( + "Preview version {} must be newer than the stable version {} it is made from.", + p.version, stable.version + ))); + } + let work = p.out.with_file_name(format!("{}-staging", p.out.file_name().unwrap().to_string_lossy())); + let _ = fs::remove_dir_all(&work); + fs::create_dir_all(&work)?; + progress("Unpacking the stable package"); + package::extract(p.stable, &stable, &work, &|_, _| {})?; + + // The plugin host replaces the monolithic core; everything it ships next to the exe goes to Core/. + let mut replaced = 0; + for entry in fs::read_dir(p.core)?.flatten() { + let name = entry.file_name().to_string_lossy().into_owned(); + let lower = name.to_ascii_lowercase(); + if !entry.path().is_file() || !(lower.ends_with(".exe") || lower.ends_with(".dll") || lower == "plugin-sdk.zip") { + continue; + } + fs::copy(entry.path(), fsx::safe_join(&work, &format!("Core/{name}"))?)?; + replaced += 1; + } + for required in ["Core/worldserver.exe", "Core/authserver.exe", "Core/plugin-sdk.zip"] { + if !fsx::safe_join(&work, required)?.is_file() { + return Err(Error::Invalid(format!("The plugin-host core has no {required}."))); + } + } + let host = crate::provenance::file_abi_fingerprint(&work.join("Core/worldserver.exe")) + .ok_or_else(|| Error::Invalid("Core/worldserver.exe is not a plugin host (no ABI fingerprint).".into()))?; + let rec: crate::rebuild::Recommended = serde_json::from_slice(&fs::read(p.recommended)?) + .map_err(|e| Error::Invalid(format!("recommended.json: {e}")))?; + if rec.schema != 1 { + return Err(Error::Invalid("recommended.json has an unknown schema.".into())); + } + let dst = fsx::safe_join(&work, "Core/plugins/recommended.json")?; + fs::create_dir_all(dst.parent().unwrap())?; + fs::copy(p.recommended, &dst)?; + progress(&format!("{replaced} core files replaced; plugin ABI {host}")); + + let opts = BuildOptions { + kind: Kind::Update, + version: p.version.clone(), + core_commit: Some(p.core_commit.clone()), + built_at: chrono::Utc::now().to_rfc3339(), + part_size: package::DEFAULT_PART_SIZE, + bots_commit: stable.bots.as_ref().and_then(|b| b.commit.clone()), + migrations: stable.migrations.clone(), + }; + let mut m = package::build(&work, p.out, &opts, &|s| progress(s))?; + m.min_manager_version = p.min_manager_version.clone(); + m.compatibility = stable.compatibility.clone().map(|mut c| { + c.core_commit = p.core_commit.clone(); + c.source_versions = vec![stable.version.clone()]; + c.source_databases.clear(); + c + }); + fsx::atomic_write(&p.out.join("manifest.json"), serde_json::to_string_pretty(&m)?.as_bytes())?; + let _ = fs::remove_dir_all(&work); + Ok(m) +} + +#[cfg(test)] +mod preview_isolation { + /// Real package: COA_TEST_PREVIEW_PACKAGE is a signed preview update. The preview key accepts it, the + /// stable key (all a stable Manager knows) does not. + #[test] + fn a_preview_package_is_rejected_by_the_stable_key() { + let Ok(dir) = std::env::var("COA_TEST_PREVIEW_PACKAGE") else { return }; + let dir = std::path::Path::new(&dir); + let manifest = std::fs::read(dir.join("manifest.json")).unwrap(); + let sig = std::fs::read_to_string(dir.join("manifest.json.sig")).unwrap(); + crate::signing::verify_exact(&manifest, &sig, crate::signing::PREVIEW_PUBLIC_KEY).unwrap(); + assert!(crate::signing::verify_exact(&manifest, &sig, crate::signing::EMBEDDED_PUBLIC_KEY).is_err()); + } +} diff --git a/crates/coa-release/src/main.rs b/crates/coa-release/src/main.rs index e791ce4..8d905ab 100644 --- a/crates/coa-release/src/main.rs +++ b/crates/coa-release/src/main.rs @@ -9,6 +9,8 @@ //! coa-release export-baseline --server DIR --out DIR (the three databases of a prepared server, for a Linux package) //! coa-release sign --dir DIR (key: env COA_SIGNING_KEY, or ~/.coa-manager/signing/manifest-signing.key) //! coa-release verify --dir DIR (against the public keys built into this tool) +//! coa-release derive-preview --stable DIR --core DIR --recommended FILE --version X --core-commit SHA +//! --min-manager-version X --out DIR (Modules Preview update from a stable update) //! coa-release public-key (public half of the signing key, to embed in the app) use std::collections::HashMap; @@ -298,6 +300,23 @@ fn run() -> Result<(), String> { .map_err(e)?; println!("signature, archive contents and database schema contract OK"); } + "derive-preview" => { + let out = PathBuf::from(need(&a, "out")?); + let m = coa_core::release::derive_preview_update( + &coa_core::release::PreviewParams { + stable: std::path::Path::new(need(&a, "stable")?), + core: std::path::Path::new(need(&a, "core")?), + recommended: std::path::Path::new(need(&a, "recommended")?), + version: need(&a, "version")?.clone(), + core_commit: need(&a, "core-commit")?.clone(), + min_manager_version: need(&a, "min-manager-version")?.clone(), + out: &out, + }, + &|s| eprintln!("{s}"), + ) + .map_err(e)?; + println!("preview update {} ({} files) in {}", m.version, m.files.len(), out.display()); + } "public-key" => { // The public half of the signing key (COA_SIGNING_KEY or the key file), for the app to embed. println!("{}", coa_core::signing::public_key_of(&signing_key()?).map_err(e)?); diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs index a779bb0..1ed09e1 100644 --- a/src-tauri/src/lib.rs +++ b/src-tauri/src/lib.rs @@ -309,7 +309,17 @@ fn installation_source(custom: Option) -> Result { .ok() .filter(|value| !value.trim().is_empty()) }); - select_installation_source(custom, || update_source(None)) + // A new server is installed from the qualified stable image; the preview channel publishes updates only, + // so the preview core arrives as the first update (the same path every existing server takes). + select_installation_source(custom, stable_update_source) +} + +fn stable_update_source() -> Result { + match coa_core::channels::resolve("stable") { + Ok(source) => Ok(source), + Err(Error::PackageNotPublished(_)) => Ok(Source::Url(DEFAULT_UPDATE_URL.into())), + Err(error) => Err(error), + } } fn select_installation_source(