@steerable/agent-shell-tauri 0.6.51 → 0.6.53

package/Cargo.toml

@@ -26,3 +26,11 @@ tauri-plugin-single-instance = "2.4.5"
 tauri-plugin-updater = "2.12.0"
 tokio = { version = "1", features = ["io-util", "macros", "process", "sync", "time"] }
 url = "2"
+
+[target.'cfg(windows)'.dependencies]
+clipboard-win = "5.4.1"
+
+[target.'cfg(target_os = "macos")'.dependencies]
+objc2 = "0.6.4"
+objc2-app-kit = { version = "0.3.2", default-features = false, features = ["std", "NSPasteboard"] }
+objc2-foundation = { version = "0.3.2", default-features = false, features = ["std", "NSArray", "NSURL", "NSString"] }

package/package.json

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

package/src/clipboard.rs

@@ -0,0 +1,206 @@
+//! OS pasteboard reads for the chat composer.
+//!
+//! WKWebView does not deliver copied files or screenshots to the page.
+//! File lists are read on macOS and Windows. Image data is encoded as PNG
+//! on every desktop.
+
+use base64::{engine::general_purpose::STANDARD, Engine};
+use image::codecs::png::PngEncoder;
+use image::{ExtendedColorType, ImageEncoder};
+use serde::Serialize;
+
+const MAX_CLIPBOARD_IMAGE_BYTES: usize = 32 * 1024 * 1024;
+const MAX_CLIPBOARD_FILES: usize = 100;
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ClipboardFile {
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub path: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub data_base64: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mime: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ClipboardContents {
+    pub text: String,
+    pub files: Vec<ClipboardFile>,
+}
+
+/// Files win over text, and text wins over a bare image.
+///
+/// The file manager copies a path string next to the file list. Returning
+/// that string would also paste the path into the composer. A screenshot
+/// has no text.
+pub fn read_clipboard() -> ClipboardContents {
+    let files = clipboard_file_paths()
+        .into_iter()
+        .take(MAX_CLIPBOARD_FILES)
+        .map(|path| ClipboardFile {
+            name: file_name(&path),
+            path: Some(path),
+            data_base64: None,
+            mime: None,
+        })
+        .collect::<Vec<_>>();
+    if !files.is_empty() {
+        return ClipboardContents {
+            text: String::new(),
+            files,
+        };
+    }
+    let text = read_clipboard_text();
+    if !text.is_empty() {
+        return ClipboardContents {
+            text,
+            files: Vec::new(),
+        };
+    }
+    ClipboardContents {
+        text: String::new(),
+        files: clipboard_image().into_iter().collect(),
+    }
+}
+
+pub fn file_name(path: &str) -> String {
+    std::path::Path::new(path)
+        .file_name()
+        .map(|name| name.to_string_lossy().into_owned())
+        .filter(|name| !name.is_empty())
+        .unwrap_or_else(|| path.to_string())
+}
+
+pub fn read_clipboard_text() -> String {
+    let Ok(mut clipboard) = arboard::Clipboard::new() else {
+        return String::new();
+    };
+    clipboard.get_text().unwrap_or_default()
+}
+
+fn clipboard_image() -> Option<ClipboardFile> {
+    let mut clipboard = arboard::Clipboard::new().ok()?;
+    let image = clipboard.get_image().ok()?;
+    let png = png_from_rgba(image.width, image.height, image.bytes.as_ref())?;
+    Some(ClipboardFile {
+        name: "image.png".to_string(),
+        path: None,
+        data_base64: Some(STANDARD.encode(png)),
+        mime: Some("image/png".to_string()),
+    })
+}
+
+pub fn png_from_rgba(width: usize, height: usize, bytes: &[u8]) -> Option<Vec<u8>> {
+    let width = u32::try_from(width).ok()?;
+    let height = u32::try_from(height).ok()?;
+    let expected = (width as usize)
+        .checked_mul(height as usize)?
+        .checked_mul(4)?;
+    if bytes.len() != expected || expected > MAX_CLIPBOARD_IMAGE_BYTES {
+        return None;
+    }
+    let mut png = std::io::Cursor::new(Vec::new());
+    PngEncoder::new(&mut png)
+        .write_image(bytes, width, height, ExtendedColorType::Rgba8)
+        .ok()?;
+    let encoded = png.into_inner();
+    if encoded.len() > MAX_CLIPBOARD_IMAGE_BYTES {
+        return None;
+    }
+    Some(encoded)
+}
+
+fn clipboard_file_paths() -> Vec<String> {
+    #[cfg(target_os = "macos")]
+    {
+        macos_file_paths()
+    }
+    #[cfg(target_os = "windows")]
+    {
+        windows_file_paths()
+    }
+    #[cfg(not(any(target_os = "macos", target_os = "windows")))]
+    {
+        Vec::new()
+    }
+}
+
+/// Explorer stores a copied selection as `CF_HDROP`.
+#[cfg(target_os = "windows")]
+fn windows_file_paths() -> Vec<String> {
+    let files: Vec<String> =
+        clipboard_win::get_clipboard(clipboard_win::formats::FileList).unwrap_or_default();
+    files.into_iter().filter(|path| !path.is_empty()).collect()
+}
+
+#[cfg(target_os = "macos")]
+fn macos_file_paths() -> Vec<String> {
+    use objc2::ClassType;
+    use objc2_app_kit::NSPasteboard;
+    use objc2_foundation::{NSArray, NSURL};
+
+    let pasteboard = NSPasteboard::generalPasteboard();
+    let classes = NSArray::from_slice(&[NSURL::class()]);
+    // `class_array` is `NSURL`. `options` is nil, then non-file URLs are dropped.
+    let from_urls = unsafe { pasteboard.readObjectsForClasses_options(&classes, None) }
+        .map(|items| {
+            items
+                .to_vec()
+                .into_iter()
+                .filter_map(|item| item.downcast::<NSURL>().ok())
+                .filter(|url| url.isFileURL())
+                .filter_map(|url| url.path())
+                .map(|path| path.to_string())
+                .filter(|path| !path.is_empty())
+                .collect::<Vec<_>>()
+        })
+        .unwrap_or_default();
+    if !from_urls.is_empty() {
+        return from_urls;
+    }
+    legacy_filename_paths(&pasteboard)
+}
+
+/// Finder still writes this deprecated list on some copies.
+#[cfg(target_os = "macos")]
+#[allow(deprecated)]
+fn legacy_filename_paths(pasteboard: &objc2_app_kit::NSPasteboard) -> Vec<String> {
+    use objc2_app_kit::NSFilenamesPboardType;
+    use objc2_foundation::{NSArray, NSString};
+
+    let Some(list) = pasteboard.propertyListForType(unsafe { NSFilenamesPboardType }) else {
+        return Vec::new();
+    };
+    let Ok(array) = list.downcast::<NSArray>() else {
+        return Vec::new();
+    };
+    array
+        .to_vec()
+        .into_iter()
+        .filter_map(|item| item.downcast::<NSString>().ok())
+        .map(|path| path.to_string())
+        .filter(|path| !path.is_empty())
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn file_name_uses_the_last_path_segment() {
+        assert_eq!(file_name("/tmp/纪要.docx"), "纪要.docx");
+        assert_eq!(file_name("notes.txt"), "notes.txt");
+    }
+
+    #[test]
+    fn png_from_rgba_encodes_one_pixel_and_rejects_a_bad_buffer() {
+        let png = png_from_rgba(1, 1, &[255, 0, 0, 255]).expect("1x1 rgba encodes");
+        assert_eq!(&png[..4], &[0x89, b'P', b'N', b'G']);
+        assert!(png_from_rgba(2, 2, &[0, 0, 0, 0]).is_none());
+        assert!(png_from_rgba(usize::MAX, usize::MAX, &[]).is_none());
+    }
+}

package/src/commands.rs

@@ -1,3 +1,4 @@
+use crate::clipboard::{self, ClipboardContents};
 use arboard::{Clipboard, ImageData};
 use base64::{engine::general_purpose::STANDARD, Engine};
 use serde::{Deserialize, Serialize};
@@ -108,12 +109,14 @@ pub async fn host_save_text_file(
     })
 }
 
+#[tauri::command]
+pub fn host_read_clipboard() -> ClipboardContents {
+    clipboard::read_clipboard()
+}
+
 #[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()
+    clipboard::read_clipboard_text()
 }
 
 #[tauri::command]

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

@@ -1,18 +1,23 @@
+mod clipboard;
 mod commands;
 mod host;
 mod python_runner;
 mod update;
 
 use commands::{
-    host_capture_screenshot, host_read_clipboard_text, host_save_text_file, host_select_directory,
+    host_capture_screenshot, host_read_clipboard, 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::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 +105,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 +195,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())
@@ -120,6 +205,7 @@ pub fn run(context: tauri::Context<tauri::Wry>, config: DesktopConfig) {
             host_select_directory,
             host_save_text_file,
             host_capture_screenshot,
+            host_read_clipboard,
             host_read_clipboard_text,
             app_release_snapshot,
             app_release_check,
@@ -139,12 +225,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 +274,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 +311,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),
         _ => {}
     });
 }