@steerable/agent-shell-tauri 0.6.47 → 0.6.49

package/Cargo.toml

@@ -17,10 +17,12 @@ command-group = "5.0.1"
 image = { version = "0.25", default-features = false, features = ["png"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+sha2 = "0.10"
+hex = "0.4"
 tauri = { version = "2.11.6", features = [] }
 tauri-plugin-dialog = "2.7.3"
 tauri-plugin-process = "2.3.1"
 tauri-plugin-single-instance = "2.4.5"
 tauri-plugin-updater = "2.12.0"
-tokio = { version = "1", features = ["time"] }
+tokio = { version = "1", features = ["io-util", "macros", "process", "sync", "time"] }
 url = "2"

package/README.md

@@ -12,3 +12,15 @@ resource paths, and updates.
 
 The crate is source-distributed with the npm package and is not published to
 crates.io.
+
+Packaged products place the complete portable Python sidecar at
+`python-runtime/<platform>` and the verified egress proxy at
+`engine/steerable-egress-proxy`. The Python runtime contains the native Rust
+CoreLoop engine. 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 starts the product without an interpreter and
+lets the settings UI install one in the background. The default
+python-build-standalone archive is checked against the packaged SHA-256; users
+may instead choose an unverified custom archive URL or an existing Python 3.9+
+executable. Download progress is emitted to the renderer, and the selected
+interpreter is passed as `STEERABLE_PYTHON` on the next application start.

package/package.json

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

package/src/commands.rs

@@ -108,6 +108,14 @@ pub async fn host_save_text_file(
     })
 }
 
+#[tauri::command]
+pub fn host_read_clipboard_text() -> String {
+    let Ok(mut clipboard) = Clipboard::new() else {
+        return String::new();
+    };
+    clipboard.get_text().unwrap_or_default()
+}
+
 #[tauri::command]
 pub async fn host_capture_screenshot(
     image: ScreenshotImage,

package/src/host.rs

@@ -1,10 +1,11 @@
+use crate::python_runner::{self, PythonRunnerLock, RunnerSetup};
 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 +13,58 @@ use std::sync::Mutex;
 use std::thread;
 use std::time::{Duration, Instant};
 use tauri::{AppHandle, Manager};
+use tauri_plugin_dialog::{DialogExt, 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 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 +75,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 +109,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 +137,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 +151,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 +190,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((
@@ -162,39 +239,110 @@ struct HostPaths {
     app_root: PathBuf,
     web_dist: PathBuf,
     engine_dir: Option<PathBuf>,
+    sidecar_python: Option<PathBuf>,
 }
 
 impl HostPaths {
-    fn apply_runtime_env(&self, command: &mut Command) {
-        let Some(engine_dir) = &self.engine_dir else {
-            return;
-        };
-        let rust_sidecar = engine_dir.join(platform_binary("steerable-sidecar"));
-        if rust_sidecar.exists() {
-            command
-                .env("STEERABLE_RUST_SIDECAR", "1")
-                .env("STEERABLE_RUST_SIDECAR_BIN", rust_sidecar);
+    fn apply_runtime_env(&self, command: &mut Command, python_runner: Option<PathBuf>) {
+        if let Some(sidecar_python) = &self.sidecar_python {
+            command.env("STEERABLE_SIDECAR_PYTHON", sidecar_python);
         }
-        let egress_proxy = engine_dir.join(platform_binary("steerable-egress-proxy"));
-        if egress_proxy.exists() {
-            command.env("STEERABLE_EGRESS_PROXY_BIN", egress_proxy);
+        if let Some(engine_dir) = &self.engine_dir {
+            let egress_proxy = engine_dir.join(platform_binary("steerable-egress-proxy"));
+            if egress_proxy.exists() {
+                command.env("STEERABLE_EGRESS_PROXY_BIN", egress_proxy);
+            }
+            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);
+            }
         }
-        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);
+        if let Some(python_runner) = python_runner {
+            command.env("STEERABLE_PYTHON", python_runner);
         }
-        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);
+    }
+
+    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() {
+                python_runner::configure(
+                    app,
+                    RunnerSetup {
+                        user_data: user_data.to_path_buf(),
+                        node: self.node.clone(),
+                        engine_dir: self.engine_dir.clone(),
+                        lock: None,
+                        target_name: platform_tag().into(),
+                        supported: false,
+                        active_runner: Some(explicit.clone()),
+                    },
+                );
+                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}"))?;
+
+        let active_runner = if python_runner_mode == "bundle" {
+            let runner = engine_dir.join("python-runner").join(&target.runner);
+            runner
+                .is_file()
+                .then_some(runner)
+                .ok_or_else(|| "bundled Python runner is missing".to_string())?
+        } else if python_runner_mode == "download" {
+            python_runner::configured_runner(user_data)
+                .or_else(|| python_runner::default_runner(user_data, &lock, target_name, target))
+                .unwrap_or_default()
+        } else {
+            return Err(format!(
+                "unsupported pythonRunner mode {python_runner_mode:?}"
+            ));
+        };
+        let active_runner = (!active_runner.as_os_str().is_empty()).then_some(active_runner);
+        python_runner::configure(
+            app,
+            RunnerSetup {
+                user_data: user_data.to_path_buf(),
+                node: self.node.clone(),
+                engine_dir: self.engine_dir.clone(),
+                lock: Some(lock),
+                target_name: target_name.into(),
+                supported: python_runner_mode == "download",
+                active_runner: active_runner.clone(),
+            },
+        );
+        Ok(active_runner)
     }
 
     fn resolve(app: &AppHandle, config: &DesktopConfig) -> Result<Self, String> {
@@ -217,6 +365,7 @@ impl HostPaths {
                     }),
                 app_root,
                 engine_dir: None,
+                sidecar_python: env::var_os("STEERABLE_SIDECAR_PYTHON").map(PathBuf::from),
             });
         }
 
@@ -227,17 +376,30 @@ impl HostPaths {
         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"));
+        let python_name = if cfg!(windows) {
+            "python.exe"
+        } else {
+            "python3"
+        };
+        let python_root = resource_dir.join("python-runtime").join(platform_tag());
+        let sidecar_python = [
+            python_root.join("python").join(python_name),
+            python_root.join("python/bin").join(python_name),
+            python_root.join(python_name),
+            python_root.join("bin").join(python_name),
+        ]
+        .into_iter()
+        .find(|candidate| candidate.is_file())
+        .ok_or_else(|| {
+            format!(
+                "packaged Python sidecar runtime is missing under {}",
+                python_root.display()
+            )
+        })?;
         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)
@@ -245,6 +407,7 @@ impl HostPaths {
             web_dist: host_root.join("web-dist"),
             app_root,
             engine_dir: Some(resource_dir.join("engine")),
+            sidecar_python: Some(sidecar_python),
         })
     }
 }
@@ -273,7 +436,7 @@ fn platform_tag() -> &'static str {
 
 fn node_resource_name() -> &'static str {
     if cfg!(windows) {
-        "node/node.exe"
+        "engine/node.exe"
     } else {
         "node/node"
     }
@@ -310,7 +473,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

@@ -1,15 +1,24 @@
 mod commands;
 mod host;
+mod python_runner;
 mod update;
 
-use commands::{host_capture_screenshot, host_save_text_file, host_select_directory};
+use commands::{
+    host_capture_screenshot, host_read_clipboard_text, host_save_text_file, host_select_directory,
+};
 use host::HostProcess;
+use python_runner::{
+    python_runner_cancel, python_runner_download, python_runner_pick_local, python_runner_restart,
+    python_runner_snapshot, python_runner_use_default, python_runner_use_local,
+};
 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,18 +51,28 @@ 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()?;
+    // Predefined Paste delivers an empty clipboard into WKWebView. Own the
+    // shortcut and read the pasteboard from the host process instead.
+    let paste = MenuItemBuilder::with_id("edit-paste", "粘贴")
+        .accelerator("CmdOrCtrl+V")
+        .build(app)?;
     let edit = SubmenuBuilder::new(app, "编辑")
         .undo()
         .redo()
         .separator()
         .cut()
         .copy()
-        .paste()
+        .item(&paste)
         .select_all()
         .build()?;
     let view = SubmenuBuilder::new(app, "视图")
@@ -72,6 +91,10 @@ fn install_menu(app: &tauri::App) -> tauri::Result<()> {
         "open-terminal" => {
             let _ = app.emit("menu:open-terminal", ());
         }
+        "edit-paste" => {
+            let _ = app.emit("menu:paste", ());
+        }
+        "app-quit" => app.exit(0),
         _ => {}
     });
     Ok(())
@@ -82,6 +105,7 @@ pub fn run(context: tauri::Context<tauri::Wry>, config: DesktopConfig) {
     let product_name = config.product_name.clone();
     let builder = tauri::Builder::default()
         .manage(update::UpdateState::default())
+        .manage(python_runner::PythonRunnerState::default())
         .plugin(tauri_plugin_single_instance::init(|app, _args, _cwd| {
             if let Some(window) = app.get_webview_window("main") {
                 let _ = window.show();
@@ -95,31 +119,60 @@ 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,
+            host_read_clipboard_text,
+            app_release_snapshot,
+            app_release_check,
+            app_release_install,
+            python_runner_snapshot,
+            python_runner_download,
+            python_runner_cancel,
+            python_runner_pick_local,
+            python_runner_use_local,
+            python_runner_use_default,
+            python_runner_restart
         ])
         .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());
+                python_runner::maybe_prompt(&handle);
+                update::start(&handle);
+            });
             Ok(())
         });