@steerable/agent-shell-tauri 0.6.46 → 0.6.48

package/README.md

@@ -12,3 +12,11 @@ resource paths, and updates.
 
 The crate is source-distributed with the npm package and is not published to
 crates.io.
+
+Packaged products place the verified Rust sidecar and egress proxy at
+`engine/steerable-sidecar` and `engine/steerable-egress-proxy`. An optional
+`engine/python-runner` is only a child interpreter for `run_code`; it never
+hosts the sidecar. Products may set `pythonRunner` to `bundle` or `download`
+in `product.json`. Download mode uses the packaged lock and installer,
+verifies SHA-256 before an atomic install under the product data directory,
+and passes the resulting absolute executable as `STEERABLE_PYTHON`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steerable/agent-shell-tauri",
-  "version": "0.6.46",
+  "version": "0.6.48",
   "description": "Reusable Tauri Rust host source for @steerable/agent-shell",
   "license": "Apache-2.0",
   "homepage": "https://steerableframework.com/",

package/src/host.rs

@@ -2,9 +2,9 @@ use crate::DesktopConfig;
 use command_group::{CommandGroup, GroupChild};
 #[cfg(unix)]
 use command_group::{Signal, UnixChildExt};
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use std::env;
-use std::io::{BufRead, BufReader};
+use std::io::{BufRead, BufReader, Write};
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 use std::sync::mpsc;
@@ -12,23 +12,74 @@ use std::sync::Mutex;
 use std::thread;
 use std::time::{Duration, Instant};
 use tauri::{AppHandle, Manager};
+use tauri_plugin_dialog::{DialogExt, MessageDialogButtons, MessageDialogKind};
 use url::Url;
 
 const READY_PREFIX: &str = "STEERABLE_HOST_READY ";
 const START_TIMEOUT: Duration = Duration::from_secs(30);
 
-#[derive(Deserialize)]
+#[derive(Deserialize, Serialize)]
 struct ReadyRecord {
     host: String,
     port: u16,
 }
 
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct PythonRunnerLock {
+    version: String,
+    python_version: String,
+    python_build_standalone_release: String,
+    targets: std::collections::HashMap<String, PythonRunnerTarget>,
+}
+
+#[derive(Deserialize)]
+struct PythonRunnerTarget {
+    triple: String,
+    sha256: String,
+    runner: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct ProductRuntime {
+    python_runner: Option<String>,
+}
+
+fn write_diag(dir: &Path, name: &str, body: &str) {
+    let _ = std::fs::write(dir.join(name), body);
+}
+
+fn append_diag(dir: &Path, name: &str, line: &str) {
+    if let Ok(mut file) = std::fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(dir.join(name))
+    {
+        let _ = writeln!(file, "{line}");
+    }
+}
+
 pub struct HostProcess {
     child: Mutex<Option<GroupChild>>,
 }
 
 impl HostProcess {
     pub fn spawn(app: &AppHandle, config: &DesktopConfig) -> Result<(Self, Url), String> {
+        match Self::spawn_inner(app, config) {
+            Ok(started) => Ok(started),
+            Err(error) => {
+                if let Some(dir) = env::var_os("DEEPPATH_USER_DATA_DIR") {
+                    let dir = PathBuf::from(dir);
+                    let _ = std::fs::create_dir_all(&dir);
+                    write_diag(&dir, "host-error.txt", &error);
+                }
+                Err(error)
+            }
+        }
+    }
+
+    fn spawn_inner(app: &AppHandle, config: &DesktopConfig) -> Result<(Self, Url), String> {
         let paths = HostPaths::resolve(app, config)?;
         let user_data = match env::var_os("DEEPPATH_USER_DATA_DIR") {
             Some(path) => PathBuf::from(path),
@@ -39,6 +90,30 @@ impl HostProcess {
                 .join(&config.data_dir_name),
         };
         std::fs::create_dir_all(&user_data).map_err(|error| error.to_string())?;
+        let sidecar_tmp = user_data.join("sidecar/tmp");
+        std::fs::create_dir_all(&sidecar_tmp).map_err(|error| error.to_string())?;
+        let python_runner = paths.resolve_python_runner(app, config, &user_data);
+        if let Err(error) = &python_runner {
+            eprintln!("[python-runner] {error}; run_code will be unavailable");
+            app.dialog()
+                .message(format!(
+                    "Python 运行器安装失败，run_code 本次不可用。\n\n{error}"
+                ))
+                .title("Python 运行器")
+                .kind(MessageDialogKind::Error)
+                .show(|_| {});
+        }
+        write_diag(
+            &user_data,
+            "host-spawn.txt",
+            &format!(
+                "node={}\nserver={}\napp_root={}\nweb_dist={}\n",
+                paths.node.display(),
+                paths.server_entry.display(),
+                paths.app_root.display(),
+                paths.web_dist.display()
+            ),
+        );
 
         let mut command = Command::new(&paths.node);
         command
@@ -49,12 +124,15 @@ impl HostProcess {
             .env("DEEPPATH_BS_HOST", "127.0.0.1")
             .env("DEEPPATH_BS_PORT", "0")
             .env("DEEPPATH_WEB_DIST", &paths.web_dist)
-            .env("DEEPPATH_USER_DATA_DIR", user_data)
+            .env("DEEPPATH_USER_DATA_DIR", &user_data)
+            .env("TMPDIR", &sidecar_tmp)
+            .env("TMP", &sidecar_tmp)
+            .env("TEMP", &sidecar_tmp)
             .env("STEERABLE_HOST_PARENT_PID", std::process::id().to_string())
             .stdin(Stdio::null())
             .stdout(Stdio::piped())
             .stderr(Stdio::piped());
-        paths.apply_runtime_env(&mut command);
+        paths.apply_runtime_env(&mut command, python_runner.ok().flatten());
 
         let mut child = spawn_group(&mut command).map_err(|error| {
             format!(
@@ -74,11 +152,13 @@ impl HostProcess {
             .ok_or_else(|| "Node host stderr was not piped".to_string())?;
 
         let (ready_tx, ready_rx) = mpsc::channel();
+        let stdout_dir = user_data.clone();
         thread::spawn(move || {
             for line in BufReader::new(stdout).lines() {
                 match line {
                     Ok(line) => {
                         println!("[node-host] {line}");
+                        append_diag(&stdout_dir, "host-node.log", &line);
                         if let Some(record) = line.strip_prefix(READY_PREFIX) {
                             let parsed = serde_json::from_str::<ReadyRecord>(record)
                                 .map_err(|error| error.to_string());
@@ -86,15 +166,22 @@ impl HostProcess {
                         }
                     }
                     Err(error) => {
+                        append_diag(
+                            &stdout_dir,
+                            "host-node.log",
+                            &format!("stdout error: {error}"),
+                        );
                         let _ = ready_tx.send(Err(error.to_string()));
                         break;
                     }
                 }
             }
         });
+        let stderr_dir = user_data.clone();
         thread::spawn(move || {
             for line in BufReader::new(stderr).lines().map_while(Result::ok) {
                 eprintln!("[node-host] {line}");
+                append_diag(&stderr_dir, "host-node.log", &line);
             }
         });
 
@@ -118,6 +205,11 @@ impl HostProcess {
                 return Err("Node host did not become ready within 30 seconds".to_string());
             }
         };
+        write_diag(
+            &user_data,
+            "host-ready.json",
+            &serde_json::to_string(&ready).map_err(|error| error.to_string())?,
+        );
         let url = Url::parse(&format!("http://{}:{}/", ready.host, ready.port))
             .map_err(|error| error.to_string())?;
         Ok((
@@ -165,7 +257,7 @@ struct HostPaths {
 }
 
 impl HostPaths {
-    fn apply_runtime_env(&self, command: &mut Command) {
+    fn apply_runtime_env(&self, command: &mut Command, python_runner: Option<PathBuf>) {
         let Some(engine_dir) = &self.engine_dir else {
             return;
         };
@@ -179,22 +271,111 @@ impl HostPaths {
         if egress_proxy.exists() {
             command.env("STEERABLE_EGRESS_PROXY_BIN", egress_proxy);
         }
-        let python =
-            engine_dir
-                .join("python-runtime")
-                .join(platform_tag())
-                .join(if cfg!(windows) {
-                    "python/python.exe"
-                } else {
-                    "python/bin/python3"
-                });
-        if python.exists() {
-            command.env("STEERABLE_SIDECAR_PYTHON", python);
-        }
         let win_spawn_helper = engine_dir.join("win-spawn-helper/win-spawn-helper.exe");
         if win_spawn_helper.exists() {
             command.env("DEEPPATH_WIN_SPAWN_HELPER", win_spawn_helper);
         }
+        if let Some(python_runner) = python_runner {
+            command.env("STEERABLE_PYTHON", python_runner);
+        }
+    }
+
+    fn resolve_python_runner(
+        &self,
+        app: &AppHandle,
+        config: &DesktopConfig,
+        user_data: &Path,
+    ) -> Result<Option<PathBuf>, String> {
+        if let Some(explicit) = env::var_os("STEERABLE_PYTHON") {
+            let explicit = PathBuf::from(explicit);
+            if explicit.is_absolute() && explicit.is_file() {
+                return Ok(Some(explicit));
+            }
+            return Err("STEERABLE_PYTHON must name an existing absolute file".into());
+        }
+        let Some(engine_dir) = &self.engine_dir else {
+            return Ok(None);
+        };
+        let product: ProductRuntime = serde_json::from_str(
+            &std::fs::read_to_string(
+                self.app_root
+                    .join("products")
+                    .join(&config.product_id)
+                    .join("product.json"),
+            )
+            .map_err(|error| error.to_string())?,
+        )
+        .map_err(|error| error.to_string())?;
+        let Some(python_runner_mode) = product.python_runner.as_deref() else {
+            return Ok(None);
+        };
+        let lock: PythonRunnerLock = serde_json::from_str(
+            &std::fs::read_to_string(engine_dir.join("python-runner-lock.json"))
+                .map_err(|error| error.to_string())?,
+        )
+        .map_err(|error| error.to_string())?;
+        let target_name = platform_tag();
+        let target = lock
+            .targets
+            .get(target_name)
+            .ok_or_else(|| format!("Python runner does not support {target_name}"))?;
+
+        if python_runner_mode == "bundle" {
+            let runner = engine_dir.join("python-runner").join(&target.runner);
+            return runner
+                .is_file()
+                .then_some(Some(runner))
+                .ok_or_else(|| "bundled Python runner is missing".to_string());
+        }
+        if python_runner_mode != "download" {
+            return Err(format!(
+                "unsupported pythonRunner mode {python_runner_mode:?}"
+            ));
+        }
+        let destination = user_data
+            .join("python-runner")
+            .join(&lock.version)
+            .join(target_name);
+        let runner = destination.join(&target.runner);
+        if runner.exists() {
+            return Ok(Some(runner));
+        }
+        let confirmed = app
+            .dialog()
+            .message(
+                "Aroli 需要下载独立的 Python 运行器才能使用 run_code。\n\n\
+                 不安装不会影响聊天和其他工具。下载内容会经过 SHA-256 校验。",
+            )
+            .title("安装 Python 代码运行器")
+            .buttons(MessageDialogButtons::OkCancelCustom(
+                "下载并安装".to_string(),
+                "暂不安装".to_string(),
+            ))
+            .blocking_show();
+        if !confirmed {
+            return Ok(None);
+        }
+
+        let filename = format!(
+            "cpython-{}+{}-{}-install_only_stripped.tar.gz",
+            lock.python_version, lock.python_build_standalone_release, target.triple
+        );
+        let url = format!(
+            "https://github.com/astral-sh/python-build-standalone/releases/download/{}/{}",
+            lock.python_build_standalone_release, filename
+        );
+        let installer = engine_dir.join("install-python-runner.mjs");
+        let status = Command::new(&self.node)
+            .arg(installer)
+            .args(["--url", &url, "--sha256", &target.sha256, "--destination"])
+            .arg(&destination)
+            .args(["--runner", &target.runner])
+            .status()
+            .map_err(|error| format!("failed to start Python runner installer: {error}"))?;
+        if !status.success() || !runner.exists() {
+            return Err(format!("Python runner installer exited with {status}"));
+        }
+        Ok(Some(runner))
     }
 
     fn resolve(app: &AppHandle, config: &DesktopConfig) -> Result<Self, String> {
@@ -224,20 +405,12 @@ impl HostPaths {
             .path()
             .resource_dir()
             .map_err(|error| error.to_string())?;
-        let resource_dir = node_compatible_path(&resource_dir);
         let host_root = resource_dir.join("node-host");
         let app_root = host_root.join("app-dist");
-        let engine_node = resource_dir.join("engine").join(platform_binary("node"));
         Ok(Self {
             node: env::var_os("DEEPPATH_TAURI_NODE")
                 .map(PathBuf::from)
-                .unwrap_or_else(|| {
-                    if engine_node.exists() {
-                        engine_node
-                    } else {
-                        resource_dir.join(node_resource_name())
-                    }
-                }),
+                .unwrap_or_else(|| resource_dir.join(node_resource_name())),
             server_entry: app_root
                 .join("products")
                 .join(&config.product_id)
@@ -273,33 +446,12 @@ fn platform_tag() -> &'static str {
 
 fn node_resource_name() -> &'static str {
     if cfg!(windows) {
-        "node/node.exe"
+        "engine/node.exe"
     } else {
         "node/node"
     }
 }
 
-fn node_compatible_path(path: &Path) -> PathBuf {
-    #[cfg(windows)]
-    {
-        use std::ffi::OsString;
-        use std::os::windows::ffi::{OsStrExt, OsStringExt};
-
-        let wide = path.as_os_str().encode_wide().collect::<Vec<_>>();
-        let verbatim_unc = r"\\?\UNC\".encode_utf16().collect::<Vec<_>>();
-        if let Some(rest) = wide.strip_prefix(verbatim_unc.as_slice()) {
-            let mut normalized = r"\\".encode_utf16().collect::<Vec<_>>();
-            normalized.extend_from_slice(rest);
-            return PathBuf::from(OsString::from_wide(&normalized));
-        }
-        let verbatim = r"\\?\".encode_utf16().collect::<Vec<_>>();
-        if let Some(rest) = wide.strip_prefix(verbatim.as_slice()) {
-            return PathBuf::from(OsString::from_wide(rest));
-        }
-    }
-    path.to_path_buf()
-}
-
 fn spawn_group(command: &mut Command) -> std::io::Result<GroupChild> {
     #[cfg(windows)]
     {
@@ -310,7 +462,3 @@ fn spawn_group(command: &mut Command) -> std::io::Result<GroupChild> {
         command.group_spawn()
     }
 }
-
-#[cfg(test)]
-#[path = "host_tests.rs"]
-mod tests;

package/src/lib.rs

@@ -5,11 +5,13 @@ mod update;
 use commands::{host_capture_screenshot, host_save_text_file, host_select_directory};
 use host::HostProcess;
 use std::path::PathBuf;
+use std::thread;
 use tauri::{
     menu::{MenuBuilder, MenuItemBuilder, SubmenuBuilder},
     Emitter, Manager, RunEvent, WebviewUrl, WebviewWindowBuilder, WindowEvent,
 };
 use tauri_plugin_dialog::{DialogExt, MessageDialogKind};
+use update::{app_release_check, app_release_install, app_release_snapshot};
 
 /// Product values required by the reusable desktop host.
 pub struct DesktopConfig {
@@ -42,10 +44,15 @@ fn install_menu(app: &tauri::App) -> tauri::Result<()> {
     let open_terminal = MenuItemBuilder::with_id("open-terminal", "打开终端")
         .accelerator("CmdOrCtrl+T")
         .build(app)?;
+    let quit = MenuItemBuilder::with_id("app-quit", "退出")
+        .accelerator("CmdOrCtrl+Q")
+        .build(app)?;
     let file = SubmenuBuilder::new(app, "文件")
         .item(&new_chat)
         .separator()
         .close_window()
+        .separator()
+        .item(&quit)
         .build()?;
     let edit = SubmenuBuilder::new(app, "编辑")
         .undo()
@@ -72,6 +79,7 @@ fn install_menu(app: &tauri::App) -> tauri::Result<()> {
         "open-terminal" => {
             let _ = app.emit("menu:open-terminal", ());
         }
+        "app-quit" => app.exit(0),
         _ => {}
     });
     Ok(())
@@ -95,31 +103,51 @@ pub fn run(context: tauri::Context<tauri::Wry>, config: DesktopConfig) {
         .invoke_handler(tauri::generate_handler![
             host_select_directory,
             host_save_text_file,
-            host_capture_screenshot
+            host_capture_screenshot,
+            app_release_snapshot,
+            app_release_check,
+            app_release_install
         ])
         .setup(move |app| {
             install_menu(app)?;
-            let (host, url) = match HostProcess::spawn(app.handle(), &config) {
-                Ok(started) => started,
-                Err(error) => {
-                    let handle = app.handle().clone();
-                    app.dialog()
-                        .message(error)
+            let handle = app.handle().clone();
+            thread::spawn(move || {
+                let (host, url) = match HostProcess::spawn(&handle, &config) {
+                    Ok(started) => started,
+                    Err(error) => {
+                        let exit_handle = handle.clone();
+                        handle
+                            .dialog()
+                            .message(error)
+                            .title(format!("{} 无法启动", config.product_name))
+                            .kind(MessageDialogKind::Error)
+                            .show(move |_| exit_handle.exit(1));
+                        return;
+                    }
+                };
+                handle.manage(host);
+                let allowed_origin = url.origin().ascii_serialization();
+                if let Err(error) =
+                    WebviewWindowBuilder::new(&handle, "main", WebviewUrl::External(url))
+                        .title(&config.product_name)
+                        .inner_size(1200.0, 800.0)
+                        .min_inner_size(900.0, 650.0)
+                        .on_navigation(move |url| {
+                            url.origin().ascii_serialization() == allowed_origin
+                        })
+                        .build()
+                {
+                    let exit_handle = handle.clone();
+                    handle
+                        .dialog()
+                        .message(error.to_string())
                         .title(format!("{} 无法启动", config.product_name))
                         .kind(MessageDialogKind::Error)
-                        .show(move |_| handle.exit(1));
-                    return Ok(());
+                        .show(move |_| exit_handle.exit(1));
+                    return;
                 }
-            };
-            app.manage(host);
-            let allowed_origin = url.origin().ascii_serialization();
-            WebviewWindowBuilder::new(app, "main", WebviewUrl::External(url))
-                .title(&config.product_name)
-                .inner_size(1200.0, 800.0)
-                .min_inner_size(900.0, 650.0)
-                .on_navigation(move |url| url.origin().ascii_serialization() == allowed_origin)
-                .build()?;
-            update::start(app.handle());
+                update::start(&handle);
+            });
             Ok(())
         });
 

package/src/update.rs

@@ -1,18 +1,64 @@
+use serde::Serialize;
 use std::sync::Mutex;
 use std::time::Duration;
 use tauri::{AppHandle, Emitter, Manager};
 use tauri_plugin_updater::{Update, UpdaterExt};
 
 const CHECK_INTERVAL: Duration = Duration::from_secs(4 * 60 * 60);
+const EVENT: &str = "app-update-state";
+
+/// 渲染层看到的版本与更新状态。`version` 是当前安装版本。
+#[derive(Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AppReleaseSnapshot {
+    version: String,
+    enabled: bool,
+    phase: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    available_version: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    percent: Option<u8>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    message: Option<String>,
+}
+
+struct Tracked {
+    phase: String,
+    available_version: Option<String>,
+    percent: Option<u8>,
+    message: Option<String>,
+}
+
+impl Tracked {
+    fn idle() -> Self {
+        Self {
+            phase: "idle".into(),
+            available_version: None,
+            percent: None,
+            message: None,
+        }
+    }
+}
 
 struct PendingUpdate {
     update: Update,
     bytes: Vec<u8>,
 }
 
-#[derive(Default)]
 pub struct UpdateState {
     pending: Mutex<Option<PendingUpdate>>,
+    tracked: Mutex<Tracked>,
+    gate: tokio::sync::Mutex<()>,
+}
+
+impl Default for UpdateState {
+    fn default() -> Self {
+        Self {
+            pending: Mutex::new(None),
+            tracked: Mutex::new(Tracked::idle()),
+            gate: tokio::sync::Mutex::new(()),
+        }
+    }
 }
 
 impl UpdateState {
@@ -29,8 +75,107 @@ impl UpdateState {
     }
 }
 
+/// 开发构建只检查、不下载、不替换正在跑的程序。
+/// `DEEPPATH_APP_UPDATE=1` 强制打开安装；`=0` 连检查也关掉。
+fn updates_enabled() -> bool {
+    std::env::var("DEEPPATH_APP_UPDATE").as_deref() != Ok("0")
+}
+
+fn install_allowed() -> bool {
+    match std::env::var("DEEPPATH_APP_UPDATE").as_deref() {
+        Ok("0") => false,
+        Ok("1") => true,
+        _ => !cfg!(debug_assertions),
+    }
+}
+
+fn clip_message(message: String) -> String {
+    const MAX: usize = 180;
+    let mut chars = message.chars();
+    let clipped: String = chars.by_ref().take(MAX).collect();
+    if chars.next().is_some() {
+        format!("{clipped}…")
+    } else {
+        clipped
+    }
+}
+
+fn next_download_percent(downloaded: u64, total: u64, previous: u8) -> Option<u8> {
+    if total == 0 {
+        return None;
+    }
+    let percent = ((downloaded.saturating_mul(100)) / total).min(100) as u8;
+    if percent != previous && (percent == 100 || percent >= previous.saturating_add(5)) {
+        Some(percent)
+    } else {
+        None
+    }
+}
+
+fn snapshot(app: &AppHandle) -> AppReleaseSnapshot {
+    let enabled = updates_enabled();
+    let state = app.state::<UpdateState>();
+    let tracked = state.tracked.lock().ok();
+    let (phase, available_version, percent, message) = if let Some(tracked) = tracked.as_ref() {
+        (
+            if enabled {
+                tracked.phase.clone()
+            } else {
+                "disabled".into()
+            },
+            if enabled {
+                tracked.available_version.clone()
+            } else {
+                None
+            },
+            if enabled { tracked.percent } else { None },
+            if enabled {
+                tracked.message.clone()
+            } else {
+                None
+            },
+        )
+    } else if enabled {
+        ("idle".into(), None, None, None)
+    } else {
+        ("disabled".into(), None, None, None)
+    };
+    AppReleaseSnapshot {
+        version: app.package_info().version.to_string(),
+        enabled,
+        phase,
+        available_version,
+        percent,
+        message,
+    }
+}
+
+fn publish(
+    app: &AppHandle,
+    phase: &str,
+    available_version: Option<String>,
+    percent: Option<u8>,
+    message: Option<String>,
+) {
+    if let Ok(mut tracked) = app.state::<UpdateState>().tracked.lock() {
+        tracked.phase = phase.to_string();
+        tracked.available_version = available_version;
+        tracked.percent = percent;
+        tracked.message = message;
+    }
+    let _ = app.emit(EVENT, snapshot(app));
+}
+
+fn has_pending(app: &AppHandle) -> bool {
+    app.state::<UpdateState>()
+        .pending
+        .lock()
+        .map(|pending| pending.is_some())
+        .unwrap_or(true)
+}
+
 pub fn start(app: &AppHandle) {
-    if cfg!(debug_assertions) || std::env::var("DEEPPATH_APP_UPDATE").as_deref() == Ok("0") {
+    if !install_allowed() {
         return;
     }
     let app = app.clone();
@@ -42,58 +187,95 @@ pub fn start(app: &AppHandle) {
     });
 }
 
-async fn check_once(app: &AppHandle) {
-    if app
-        .state::<UpdateState>()
-        .pending
-        .lock()
-        .map(|pending| pending.is_some())
-        .unwrap_or(true)
-    {
+pub async fn check_once(app: &AppHandle) {
+    let state = app.state::<UpdateState>();
+    let _gate = state.gate.lock().await;
+    if !updates_enabled() {
+        publish(app, "disabled", None, None, None);
+        return;
+    }
+    if has_pending(app) {
         return;
     }
-    let _ = app.emit(
-        "app-update-state",
-        serde_json::json!({ "phase": "checking" }),
-    );
+    publish(app, "checking", None, None, None);
     let updater = match app.updater() {
         Ok(updater) => updater,
         Err(error) => {
             eprintln!("[updater] initialization failed: {error}");
+            publish(
+                app,
+                "error",
+                None,
+                None,
+                Some(clip_message(error.to_string())),
+            );
             return;
         }
     };
     let update = match updater.check().await {
         Ok(Some(update)) => update,
         Ok(None) => {
-            let _ = app.emit("app-update-state", serde_json::json!({ "phase": "idle" }));
+            publish(app, "idle", None, None, Some("已是最新".into()));
             return;
         }
         Err(error) => {
             eprintln!("[updater] check failed: {error}");
-            let _ = app.emit(
-                "app-update-state",
-                serde_json::json!({ "phase": "error", "message": error.to_string() }),
+            publish(
+                app,
+                "error",
+                None,
+                None,
+                Some(clip_message(error.to_string())),
             );
             return;
         }
     };
     let version = update.version.clone();
-    let _ = app.emit(
-        "app-update-state",
-        serde_json::json!({ "phase": "downloading", "version": version }),
-    );
-    let bytes = match update.download(|_chunk, _total| {}, || {}).await {
+    if !install_allowed() {
+        publish(
+            app,
+            "idle",
+            Some(version.clone()),
+            None,
+            Some("开发构建不安装更新".into()),
+        );
+        return;
+    }
+    publish(app, "downloading", Some(version.clone()), Some(0), None);
+    let mut downloaded: u64 = 0;
+    let mut last_percent: u8 = 0;
+    let bytes = match update
+        .download(
+            |chunk, total| {
+                downloaded = downloaded.saturating_add(chunk as u64);
+                let Some(total) = total else {
+                    return;
+                };
+                let Some(percent) = next_download_percent(downloaded, total, last_percent) else {
+                    return;
+                };
+                last_percent = percent;
+                publish(
+                    app,
+                    "downloading",
+                    Some(version.clone()),
+                    Some(percent),
+                    None,
+                );
+            },
+            || {},
+        )
+        .await
+    {
         Ok(bytes) => bytes,
         Err(error) => {
             eprintln!("[updater] download failed: {error}");
-            let _ = app.emit(
-                "app-update-state",
-                serde_json::json!({
-                    "phase": "error",
-                    "version": version,
-                    "message": error.to_string()
-                }),
+            publish(
+                app,
+                "error",
+                Some(version),
+                None,
+                Some(clip_message(error.to_string())),
             );
             return;
         }
@@ -101,8 +283,87 @@ async fn check_once(app: &AppHandle) {
     if let Ok(mut pending) = app.state::<UpdateState>().pending.lock() {
         *pending = Some(PendingUpdate { update, bytes });
     }
-    let _ = app.emit(
-        "app-update-state",
-        serde_json::json!({ "phase": "ready", "version": version }),
-    );
+    publish(app, "ready", Some(version), None, None);
+}
+
+#[tauri::command]
+pub fn app_release_snapshot(app: AppHandle) -> AppReleaseSnapshot {
+    snapshot(&app)
+}
+
+#[tauri::command]
+pub async fn app_release_check(app: AppHandle) -> AppReleaseSnapshot {
+    check_once(&app).await;
+    snapshot(&app)
+}
+
+#[tauri::command]
+pub async fn app_release_install(app: AppHandle) -> AppReleaseSnapshot {
+    if !install_allowed() {
+        publish(&app, "error", None, None, Some("开发构建不安装更新".into()));
+        return snapshot(&app);
+    }
+    let pending = app
+        .state::<UpdateState>()
+        .pending
+        .lock()
+        .ok()
+        .and_then(|mut pending| pending.take());
+    let Some(pending) = pending else {
+        return snapshot(&app);
+    };
+    let version = pending.update.version.clone();
+    publish(&app, "installing", Some(version.clone()), None, None);
+    let joined =
+        tauri::async_runtime::spawn_blocking(move || pending.update.install(pending.bytes)).await;
+    match joined {
+        Ok(Ok(())) => {
+            app.request_restart();
+        }
+        Ok(Err(error)) => {
+            eprintln!("[updater] install failed: {error}");
+            publish(
+                &app,
+                "error",
+                Some(version),
+                None,
+                Some(clip_message(error.to_string())),
+            );
+        }
+        Err(error) => {
+            publish(
+                &app,
+                "error",
+                Some(version),
+                None,
+                Some(clip_message(error.to_string())),
+            );
+        }
+    }
+    snapshot(&app)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{clip_message, next_download_percent};
+
+    #[test]
+    fn reports_download_percent_in_steps() {
+        assert_eq!(next_download_percent(0, 0, 0), None);
+        assert_eq!(next_download_percent(4, 100, 0), None);
+        assert_eq!(next_download_percent(5, 100, 0), Some(5));
+        assert_eq!(next_download_percent(9, 100, 5), None);
+        assert_eq!(next_download_percent(96, 100, 90), Some(96));
+        assert_eq!(next_download_percent(100, 100, 96), Some(100));
+        assert_eq!(next_download_percent(100, 100, 100), None);
+    }
+
+    #[test]
+    fn clips_long_updater_errors() {
+        assert_eq!(clip_message("短".into()), "短");
+        let long = "错".repeat(200);
+        let clipped = clip_message(long);
+        assert!(clipped.ends_with('…'));
+        assert_eq!(clipped.chars().count(), 181);
+    }
 }

package/src/host_tests.rs

@@ -1,27 +0,0 @@
-use super::node_compatible_path;
-use std::path::Path;
-
-#[cfg(not(windows))]
-#[test]
-fn packaged_path_is_unchanged_off_windows() {
-    let path = Path::new("/opt/Aroli/node-host");
-    assert_eq!(node_compatible_path(path), path);
-}
-
-#[cfg(windows)]
-#[test]
-fn strips_windows_verbatim_disk_prefix() {
-    assert_eq!(
-        node_compatible_path(Path::new(r"\\?\C:\Aroli\node-host")),
-        Path::new(r"C:\Aroli\node-host")
-    );
-}
-
-#[cfg(windows)]
-#[test]
-fn converts_windows_verbatim_unc_prefix() {
-    assert_eq!(
-        node_compatible_path(Path::new(r"\\?\UNC\server\share\node-host")),
-        Path::new(r"\\server\share\node-host")
-    );
-}