feat: prepare versioned production Curio releases

2026-09-09 17:28:28 +08:00
parent 775d891288
commit 68b7164df8
10 changed files with 461 additions and 54 deletions
@@ -372,6 +372,14 @@ fn register(

 #[tokio::main]
 async fn main() -> Result<()> {
+    let args: Vec<String> = std::env::args().collect();
+    if args.get(1).map(String::as_str) == Some("--remote-source") {
+        return remote_source_check(
+            args.get(2).context("remote source URL required")?,
+            args.get(3).context("remote source ID required")?,
+        )
+        .await;
+    }
    let dist = PathBuf::from(std::env::args().nth(1).context("dist directory required")?)
        .canonicalize()?;
    let sandbox = tempfile::Builder::new()
@@ -468,3 +476,133 @@ async fn main() -> Result<()> {
    gateway.shutdown().await;
    Ok(())
 }
+
+async fn remote_source_check(url: &str, source_id: &str) -> Result<()> {
+    let sandbox = tempfile::Builder::new()
+        .prefix("trove-remote-qa-")
+        .tempdir_in("/tmp")?;
+    let paths = AppPaths::under(sandbox.path());
+    let packages = Arc::new(PackageManager::open(paths.clone(), "0.1.0", target())?);
+    let runtime = BackendSupervisor::new(sandbox.path().join("host.sock"));
+    let bus = ServiceBus::new(runtime.clone());
+    bus.register_builtin(Arc::new(RuntimeService {
+        paths: paths.clone(),
+        packages: packages.clone(),
+    }))?;
+    bus.register_builtin(Arc::new(Arc::new(Storage::new(paths.support.join("data")))))?;
+    let gateway =
+        UnixGateway::bind(runtime.socket_path().into(), runtime.clone(), bus.clone()).await?;
+    let mut rows = Vec::new();
+    check(&mut rows, "从真实远程源读取索引", async {
+        packages.add_source(SourceConfig {
+            id: source_id.into(),
+            name: source_id.into(),
+            kind: SourceKind::Http,
+            index: url.into(),
+            enabled: true,
+            priority: 0,
+            refresh_interval_seconds: 3600,
+        })?;
+        let refreshed = packages.refresh_source(source_id).await?;
+        ensure!(!refreshed.stale, "Remote source refresh used stale cache");
+        ensure!(
+            !packages.catalog().is_empty(),
+            "Remote source has no installable plugins"
+        );
+        Ok(json!({"url":url,"sourceId":source_id,"curioCount":packages.catalog().len()}))
+    })
+    .await;
+    if rows.iter().all(|row| row["status"] == "pass") {
+        for entry in packages.catalog() {
+            for version in entry.package.versions {
+                check(&mut rows, format!("远程安装 {}@{}", entry.package.id, version.version), async {
+                    let package = packages.install_from_source(source_id, &entry.package.id, &version.version, true).await?;
+                    ensure!(package.source_id.as_deref() == Some(source_id), "Installation wasn't bound to the remote source");
+                    if let Some(ui) = &package.manifest.ui {
+                        let asset = trove::runtime::assets::resolve_asset(&package.root, &package.manifest.id, &ui.entry, &format!("/{}/{}", package.manifest.id, ui.entry))?;
+                        ensure!(asset.is_file(), "Installed UI entry is missing");
+                    }
+                    Ok(json!({"id":package.manifest.id,"version":package.active_version,"sourceId":package.source_id}))
+                }).await;
+            }
+        }
+        for package in packages.list() {
+            register(&package, &paths, &runtime, &bus)?;
+        }
+        for package in packages
+            .list()
+            .into_iter()
+            .filter(|package| package.manifest.backend.is_some())
+        {
+            check(
+                &mut rows,
+                format!("运行远程安装后端 {}", package.manifest.id),
+                async {
+                    let context = trove::service::CallContext::new(
+                        Caller {
+                            curio_id: Some(package.manifest.id.clone()),
+                            instance_id: None,
+                            endpoint: "ui".into(),
+                        },
+                        "remote-check",
+                    );
+                    let result = bus
+                        .call(context, "@self", "info", json!({}), Default::default())
+                        .await?;
+                    ensure!(
+                        result["curioId"] == package.manifest.id
+                            && result["version"] == package.active_version,
+                        "Backend identity doesn't match installed remote version"
+                    );
+                    ensure!(
+                        result["pid"].as_u64().unwrap_or(0) > 0,
+                        "Backend didn't report a process"
+                    );
+                    Ok(result)
+                },
+            )
+            .await;
+        }
+        if packages.get("dev.trove.qa.consumer").is_ok()
+            && packages.get("dev.trove.qa.provider").is_ok()
+        {
+            check(&mut rows, "远程安装插件间的服务调用", async {
+                let context = trove::service::CallContext::new(
+                    Caller {
+                        curio_id: Some("dev.trove.qa.consumer".into()),
+                        instance_id: None,
+                        endpoint: "ui".into(),
+                    },
+                    "remote-consumer",
+                );
+                let result = bus
+                    .call(
+                        context,
+                        "dev.trove.qa.provider.probe",
+                        "echo",
+                        json!({"remote":true,"text":"远程安装 🧪"}),
+                        Default::default(),
+                    )
+                    .await?;
+                ensure!(
+                    result == json!({"remote":true,"text":"远程安装 🧪"}),
+                    "Cross-plugin response changed"
+                );
+                Ok(result)
+            })
+            .await;
+        }
+    }
+    bus.shutdown().await;
+    runtime.shutdown_all().await;
+    gateway.shutdown().await;
+    sandbox.close()?;
+    let failed = rows.iter().filter(|row| row["status"] == "fail").count();
+    emit(json!({
+        "schemaVersion":1,"sourceUrl":url,"sourceId":source_id,"target":target(),
+        "scope":"Remote HTTP index and packages via real PackageManager; installed native backends via real UDS. Desktop UI rendering is not included.",
+        "passed":rows.len()-failed,"failed":failed,"temporaryDataRemoved":true,"results":rows,
+    }));
+    ensure!(failed == 0, "Remote source verification failed");
+    Ok(())
+}