@steerable/agent-shell-tauri 0.6.51 → 0.6.52

package/package.json

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

package/src/host.rs

@@ -9,7 +9,7 @@ use std::io::{BufRead, BufReader, Write};
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 use std::sync::mpsc;
-use std::sync::Mutex;
+use std::sync::{Arc, Mutex};
 use std::thread;
 use std::time::{Duration, Instant};
 use tauri::{AppHandle, Manager};
@@ -35,6 +35,34 @@ fn write_diag(dir: &Path, name: &str, body: &str) {
     let _ = std::fs::write(dir.join(name), body);
 }
 
+fn remember_line(recent: &Mutex<Vec<String>>, line: &str) {
+    let Ok(mut lines) = recent.lock() else {
+        return;
+    };
+    if lines.len() == 40 {
+        lines.remove(0);
+    }
+    lines.push(line.to_string());
+}
+
+fn format_host_exit(reason: &str, recent: &Mutex<Vec<String>>) -> String {
+    let detail = recent.lock().ok().and_then(|lines| {
+        lines
+            .iter()
+            .rev()
+            .find(|line| {
+                line.contains("failed to start")
+                    || line.contains("StoreAlreadyOwnedError")
+                    || line.contains("web build not found")
+            })
+            .cloned()
+    });
+    match detail {
+        Some(line) => format!("{reason}: {line}"),
+        None => reason.to_string(),
+    }
+}
+
 fn append_diag(dir: &Path, name: &str, line: &str) {
     if let Ok(mut file) = std::fs::OpenOptions::new()
         .create(true)
@@ -137,12 +165,16 @@ impl HostProcess {
             .ok_or_else(|| "Node host stderr was not piped".to_string())?;
 
         let (ready_tx, ready_rx) = mpsc::channel();
+        let (stderr_done_tx, stderr_done_rx) = mpsc::channel();
+        let recent = Arc::new(Mutex::new(Vec::<String>::new()));
         let stdout_dir = user_data.clone();
+        let stdout_recent = Arc::clone(&recent);
         thread::spawn(move || {
             for line in BufReader::new(stdout).lines() {
                 match line {
                     Ok(line) => {
                         println!("[node-host] {line}");
+                        remember_line(&stdout_recent, &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)
@@ -163,11 +195,14 @@ impl HostProcess {
             }
         });
         let stderr_dir = user_data.clone();
+        let stderr_recent = Arc::clone(&recent);
         thread::spawn(move || {
             for line in BufReader::new(stderr).lines().map_while(Result::ok) {
                 eprintln!("[node-host] {line}");
+                remember_line(&stderr_recent, &line);
                 append_diag(&stderr_dir, "host-node.log", &line);
             }
+            let _ = stderr_done_tx.send(());
         });
 
         let started = Instant::now();
@@ -175,19 +210,28 @@ impl HostProcess {
             match ready_rx.recv_timeout(Duration::from_millis(100)) {
                 Ok(result) => break result?,
                 Err(mpsc::RecvTimeoutError::Disconnected) => {
+                    let _ = stderr_done_rx.recv_timeout(Duration::from_millis(500));
                     let _ = child.kill();
-                    return Err("Node host exited before reporting readiness".to_string());
+                    return Err(format_host_exit(
+                        "Node host exited before reporting readiness",
+                        &recent,
+                    ));
                 }
                 Err(mpsc::RecvTimeoutError::Timeout) => {}
             }
             if let Some(status) = child.try_wait().map_err(|error| error.to_string())? {
-                return Err(format!(
-                    "Node host exited before reporting readiness: {status}"
+                let _ = stderr_done_rx.recv_timeout(Duration::from_millis(500));
+                return Err(format_host_exit(
+                    &format!("Node host exited before reporting readiness: {status}"),
+                    &recent,
                 ));
             }
             if started.elapsed() >= START_TIMEOUT {
                 let _ = child.kill();
-                return Err("Node host did not become ready within 30 seconds".to_string());
+                return Err(format_host_exit(
+                    "Node host did not become ready within 30 seconds",
+                    &recent,
+                ));
             }
         };
         write_diag(

package/src/lib.rs

@@ -11,8 +11,11 @@ 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::io::Write;
 use std::path::PathBuf;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::thread;
+use std::time::Duration;
 use tauri::{
     menu::{MenuBuilder, MenuItemBuilder, SubmenuBuilder},
     Emitter, Manager, RunEvent, WebviewUrl, WebviewWindowBuilder, WindowEvent,
@@ -100,6 +103,89 @@ fn install_menu(app: &tauri::App) -> tauri::Result<()> {
     Ok(())
 }
 
+static REVEAL_WHEN_READY: AtomicBool = AtomicBool::new(false);
+static INSTANCE_PING: AtomicBool = AtomicBool::new(false);
+
+/// Shows the running desktop window.
+///
+/// Closing the macOS window hides it. `set_focus` then does nothing until
+/// `show` has run on the main thread, so the activation is posted again
+/// after that show.
+fn reveal_main_window(app: &tauri::AppHandle) {
+    if app.get_webview_window("main").is_none() {
+        REVEAL_WHEN_READY.store(true, Ordering::SeqCst);
+        return;
+    }
+    focus_main_window(app);
+    let later = app.clone();
+    let _ = app.run_on_main_thread(move || focus_main_window(&later));
+}
+
+fn focus_main_window(app: &tauri::AppHandle) {
+    let Some(window) = app.get_webview_window("main") else {
+        return;
+    };
+    let _ = window.unminimize();
+    let _ = window.show();
+    let _ = window.set_focus();
+}
+
+fn is_database_in_use(error: &str) -> bool {
+    error.contains("StoreAlreadyOwnedError") || error.contains("store already owned")
+}
+
+fn database_in_use_message(product_name: &str) -> String {
+    format!(
+        "再打开一次{product_name}时，会回到已经打开的窗口。\n\n\
+         这次没有回到那个窗口，是因为本地数据库正被另一个进程占用。\
+         如果终端里还在跑 pnpm dev:bs，先在那个终端按 Ctrl+C 停掉，再重新打开{product_name}。\n\n\
+         重新启动后的开发服务会使用单独的数据目录，之后可以和桌面版同时开。"
+    )
+}
+
+/// Asks an already running desktop app to reveal its window.
+///
+/// A ping that this process receives itself means the database is held by
+/// something other than a second copy of the app.
+fn wake_other_desktop_app(app: &tauri::AppHandle) -> bool {
+    #[cfg(unix)]
+    {
+        INSTANCE_PING.store(false, Ordering::SeqCst);
+        if ping_single_instance(&app.config().identifier).is_err() {
+            return false;
+        }
+        for _ in 0..10 {
+            if INSTANCE_PING.load(Ordering::SeqCst) {
+                return false;
+            }
+            thread::sleep(Duration::from_millis(20));
+        }
+        true
+    }
+    #[cfg(not(unix))]
+    {
+        let _ = app;
+        false
+    }
+}
+
+#[cfg(unix)]
+fn ping_single_instance(identifier: &str) -> std::io::Result<()> {
+    let socket = PathBuf::from(format!(
+        "/tmp/{}_si.sock",
+        identifier.replace(['.', '-'], "_")
+    ));
+    let mut stream = std::os::unix::net::UnixStream::connect(socket)?;
+    stream.set_write_timeout(Some(Duration::from_millis(200)))?;
+    let cwd = std::env::current_dir().unwrap_or_default();
+    let args = std::env::args().collect::<Vec<_>>().join("\0");
+    stream.write_all(cwd.to_string_lossy().as_bytes())?;
+    stream.write_all(b"\0\0")?;
+    stream.write_all(args.as_bytes())?;
+    stream.flush()?;
+    Ok(())
+}
+
 /// Runs a Tauri desktop shell around the shared Node HostRuntime.
 pub fn run(context: tauri::Context<tauri::Wry>, config: DesktopConfig) {
     let product_name = config.product_name.clone();
@@ -107,11 +193,8 @@ pub fn run(context: tauri::Context<tauri::Wry>, config: DesktopConfig) {
         .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();
-                let _ = window.unminimize();
-                let _ = window.set_focus();
-            }
+            INSTANCE_PING.store(true, Ordering::SeqCst);
+            reveal_main_window(app);
         }))
         .plugin(tauri_plugin_dialog::init())
         .plugin(tauri_plugin_process::init())
@@ -139,12 +222,30 @@ pub fn run(context: tauri::Context<tauri::Wry>, config: DesktopConfig) {
                 let (host, url) = match HostProcess::spawn(&handle, &config) {
                     Ok(started) => started,
                     Err(error) => {
+                        if is_database_in_use(&error) && wake_other_desktop_app(&handle) {
+                            handle.exit(0);
+                            return;
+                        }
+                        let database_in_use = is_database_in_use(&error);
+                        let message = if database_in_use {
+                            database_in_use_message(&config.product_name)
+                        } else {
+                            error
+                        };
                         let exit_handle = handle.clone();
                         handle
                             .dialog()
-                            .message(error)
-                            .title(format!("{} 无法启动", config.product_name))
-                            .kind(MessageDialogKind::Error)
+                            .message(message)
+                            .title(if database_in_use {
+                                format!("{} 无法再开一个", config.product_name)
+                            } else {
+                                format!("{} 无法启动", config.product_name)
+                            })
+                            .kind(if database_in_use {
+                                MessageDialogKind::Warning
+                            } else {
+                                MessageDialogKind::Error
+                            })
                             .show(move |_| exit_handle.exit(1));
                         return;
                     }
@@ -170,6 +271,9 @@ pub fn run(context: tauri::Context<tauri::Wry>, config: DesktopConfig) {
                         .show(move |_| exit_handle.exit(1));
                     return;
                 }
+                if REVEAL_WHEN_READY.swap(false, Ordering::SeqCst) {
+                    focus_main_window(&handle);
+                }
                 python_runner::maybe_prompt(&handle);
                 update::start(&handle);
             });
@@ -204,12 +308,7 @@ pub fn run(context: tauri::Context<tauri::Wry>, config: DesktopConfig) {
             app.exit(0);
         }
         #[cfg(target_os = "macos")]
-        RunEvent::Reopen { .. } => {
-            if let Some(window) = app.get_webview_window("main") {
-                let _ = window.show();
-                let _ = window.set_focus();
-            }
-        }
+        RunEvent::Reopen { .. } => reveal_main_window(app),
         _ => {}
     });
 }