@pheem49/mint 1.15.0 → 1.17.0

package/src-tauri/src/native/terminal.rs

@@ -0,0 +1,201 @@
+use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64};
+use portable_pty::{Child, CommandBuilder, MasterPty, PtySize, native_pty_system};
+use serde::Serialize;
+use std::collections::HashMap;
+use std::io::Write;
+use std::sync::Mutex;
+use tauri::{AppHandle, Emitter};
+
+#[derive(Default)]
+pub(crate) struct TerminalSessions {
+    sessions: std::sync::Arc<Mutex<HashMap<String, std::sync::Arc<TerminalSession>>>>,
+}
+
+pub(crate) struct TerminalSession {
+    writer: Mutex<Box<dyn Write + Send>>,
+    pty: Mutex<Box<dyn MasterPty + Send>>,
+    child: Mutex<Box<dyn Child + Send + Sync>>,
+}
+
+impl Drop for TerminalSessions {
+    fn drop(&mut self) {
+        if let Ok(sessions) = self.sessions.lock() {
+            for session in sessions.values() {
+                if let Ok(mut child) = session.child.lock() {
+                    let _ = child.kill();
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct TerminalOutput {
+    session_id: String,
+    data: String,
+}
+
+fn terminal_shell() -> String {
+    #[cfg(windows)]
+    {
+        std::env::var("COMSPEC").unwrap_or_else(|_| "powershell.exe".into())
+    }
+    #[cfg(not(windows))]
+    {
+        std::env::var("SHELL").unwrap_or_else(|_| "/bin/sh".into())
+    }
+}
+
+#[tauri::command]
+pub(crate) fn start_interactive_terminal(
+    app: AppHandle,
+    state: tauri::State<'_, TerminalSessions>,
+    cwd: Option<String>,
+) -> Result<String, String> {
+    let pair = native_pty_system()
+        .openpty(PtySize {
+            rows: 28,
+            cols: 100,
+            pixel_width: 0,
+            pixel_height: 0,
+        })
+        .map_err(|error| format!("Could not create terminal: {error}"))?;
+    let mut command = CommandBuilder::new(terminal_shell());
+    command.env("TERM", "xterm-256color");
+    if let Some(path) = cwd.filter(|path| std::path::Path::new(path).is_dir()) {
+        command.cwd(path);
+    }
+    let child = pair
+        .slave
+        .spawn_command(command)
+        .map_err(|error| format!("Could not start shell: {error}"))?;
+    drop(pair.slave);
+
+    let reader = pair
+        .master
+        .try_clone_reader()
+        .map_err(|error| format!("Could not read terminal output: {error}"))?;
+    let writer = pair
+        .master
+        .take_writer()
+        .map_err(|error| format!("Could not write to terminal: {error}"))?;
+    let session_id = uuid::Uuid::new_v4().to_string();
+    let session = std::sync::Arc::new(TerminalSession {
+        writer: Mutex::new(writer),
+        pty: Mutex::new(pair.master),
+        child: Mutex::new(child),
+    });
+    state
+        .sessions
+        .lock()
+        .map_err(|_| "Terminal state is unavailable".to_string())?
+        .insert(session_id.clone(), session.clone());
+
+    let output_app = app.clone();
+    let output_id = session_id.clone();
+    let sessions = state.sessions.clone();
+    std::thread::spawn(move || {
+        let mut reader = reader;
+        let mut buffer = [0_u8; 8192];
+        loop {
+            match reader.read(&mut buffer) {
+                Ok(0) | Err(_) => break,
+                Ok(length) => {
+                    let _ = output_app.emit(
+                        "terminal-output",
+                        TerminalOutput {
+                            session_id: output_id.clone(),
+                            data: BASE64.encode(&buffer[..length]),
+                        },
+                    );
+                }
+            }
+        }
+        let exit_code = session
+            .child
+            .lock()
+            .ok()
+            .and_then(|mut child| child.wait().ok())
+            .map(|status| status.exit_code());
+        if let Ok(mut sessions) = sessions.lock() {
+            sessions.remove(&output_id);
+        }
+        let _ = output_app.emit(
+            "terminal-exit",
+            serde_json::json!({
+                "sessionId": output_id,
+                "exitCode": exit_code,
+            }),
+        );
+    });
+
+    Ok(session_id)
+}
+
+#[tauri::command]
+pub(crate) fn write_interactive_terminal(
+    state: tauri::State<'_, TerminalSessions>,
+    session_id: String,
+    data: String,
+) -> Result<(), String> {
+    let sessions = state
+        .sessions
+        .lock()
+        .map_err(|_| "Terminal state is unavailable".to_string())?;
+    let session = sessions
+        .get(&session_id)
+        .ok_or("Terminal session was not found")?;
+    session
+        .writer
+        .lock()
+        .map_err(|_| "Terminal input is unavailable".to_string())?
+        .write_all(data.as_bytes())
+        .map_err(|error| error.to_string())
+}
+
+#[tauri::command]
+pub(crate) fn resize_interactive_terminal(
+    state: tauri::State<'_, TerminalSessions>,
+    session_id: String,
+    cols: u16,
+    rows: u16,
+) -> Result<(), String> {
+    let sessions = state
+        .sessions
+        .lock()
+        .map_err(|_| "Terminal state is unavailable".to_string())?;
+    let session = sessions
+        .get(&session_id)
+        .ok_or("Terminal session was not found")?;
+    session
+        .pty
+        .lock()
+        .map_err(|_| "Terminal is unavailable".to_string())?
+        .resize(PtySize {
+            rows: rows.max(1),
+            cols: cols.max(1),
+            pixel_width: 0,
+            pixel_height: 0,
+        })
+        .map_err(|error| error.to_string())
+}
+
+#[tauri::command]
+pub(crate) fn stop_interactive_terminal(
+    state: tauri::State<'_, TerminalSessions>,
+    session_id: String,
+) -> Result<(), String> {
+    let session = state
+        .sessions
+        .lock()
+        .map_err(|_| "Terminal state is unavailable".to_string())?
+        .remove(&session_id)
+        .ok_or("Terminal session was not found")?;
+    session
+        .child
+        .lock()
+        .map_err(|_| "Terminal process is unavailable".to_string())?
+        .kill()
+        .map_err(|error| error.to_string())
+}

package/src-tauri/src/native/updater.rs

@@ -0,0 +1,148 @@
+use mint_core::MintConfig;
+use serde::Serialize;
+use tauri::{AppHandle, Runtime};
+use tauri_plugin_updater::UpdaterExt;
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UpdateChannelStatus {
+    pub current_version: &'static str,
+    pub configured: bool,
+    pub endpoint: String,
+    pub public_key_configured: bool,
+    pub automatic_install: bool,
+    pub message: &'static str,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AvailableUpdate {
+    pub current_version: String,
+    pub version: String,
+    pub notes: Option<String>,
+    pub available: bool,
+}
+
+pub fn status(config: &MintConfig) -> UpdateChannelStatus {
+    let endpoint = string_value(config, "updaterEndpoint");
+    let public_key_configured = !string_value(config, "updaterPublicKey").trim().is_empty();
+    UpdateChannelStatus {
+        current_version: env!("CARGO_PKG_VERSION"),
+        configured: !endpoint.trim().is_empty() && public_key_configured,
+        endpoint,
+        public_key_configured,
+        automatic_install: false,
+        message: "Signed Tauri update channel status only; automatic installation is disabled.",
+    }
+}
+
+pub async fn check<R: Runtime>(
+    app: &AppHandle<R>,
+    config: &MintConfig,
+) -> Result<AvailableUpdate, String> {
+    let updater = updater(app, config)?;
+    let current_version = env!("CARGO_PKG_VERSION").to_owned();
+    match updater.check().await.map_err(|error| error.to_string())? {
+        Some(update) => Ok(AvailableUpdate {
+            current_version,
+            version: update.version.clone(),
+            notes: update.body.clone(),
+            available: true,
+        }),
+        None => Ok(AvailableUpdate {
+            version: current_version.clone(),
+            current_version,
+            notes: None,
+            available: false,
+        }),
+    }
+}
+
+pub async fn install<R: Runtime>(
+    app: &AppHandle<R>,
+    config: &MintConfig,
+    approved: bool,
+) -> Result<String, String> {
+    require_install_approval(approved)?;
+    let Some(update) = updater(app, config)?
+        .check()
+        .await
+        .map_err(|error| error.to_string())?
+    else {
+        return Ok("Mint is already up to date.".into());
+    };
+    let version = update.version.clone();
+    update
+        .download_and_install(|_, _| {}, || {})
+        .await
+        .map_err(|error| error.to_string())?;
+    Ok(format!(
+        "Installed Mint {version}. Restart Mint to use the new version."
+    ))
+}
+
+fn require_install_approval(approved: bool) -> Result<(), String> {
+    approved
+        .then_some(())
+        .ok_or_else(|| "update installation requires explicit user approval".into())
+}
+
+fn updater<R: Runtime>(
+    app: &AppHandle<R>,
+    config: &MintConfig,
+) -> Result<tauri_plugin_updater::Updater, String> {
+    let endpoint = string_value(config, "updaterEndpoint");
+    let public_key = string_value(config, "updaterPublicKey");
+    if endpoint.trim().is_empty() || public_key.trim().is_empty() {
+        return Err(
+            "configure updaterEndpoint and updaterPublicKey before checking updates".into(),
+        );
+    }
+    app.updater_builder()
+        .pubkey(public_key)
+        .endpoints(vec![
+            endpoint
+                .parse()
+                .map_err(|error| format!("invalid updater endpoint: {error}"))?,
+        ])
+        .map_err(|error| error.to_string())?
+        .build()
+        .map_err(|error| error.to_string())
+}
+
+fn string_value(config: &MintConfig, key: &str) -> String {
+    config
+        .extra
+        .get(key)
+        .and_then(serde_json::Value::as_str)
+        .unwrap_or_default()
+        .to_owned()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn requires_endpoint_and_public_key_without_enabling_installation() {
+        let mut config = MintConfig::default();
+        config.extra.insert(
+            "updaterEndpoint".into(),
+            "https://updates.example.com/latest.json".into(),
+        );
+        config
+            .extra
+            .insert("updaterPublicKey".into(), "RWQexample".into());
+        let status = status(&config);
+        assert!(status.configured);
+        assert!(!status.automatic_install);
+    }
+
+    #[test]
+    fn rejects_install_without_explicit_approval() {
+        assert_eq!(
+            require_install_approval(false).unwrap_err(),
+            "update installation requires explicit user approval"
+        );
+    }
+}

package/src-tauri/src/native/windows.rs

@@ -0,0 +1,143 @@
+use crate::native::capture::reset_live_translate_interaction;
+use serde::Serialize;
+use tauri::{
+    AppHandle, Emitter, Manager, PhysicalPosition, PhysicalSize, WebviewUrl, WebviewWindowBuilder,
+};
+pub fn open_desktop_window(app: &AppHandle, kind: &str) -> Result<(), String> {
+    let (label, route, width, height, always_on_top, skip_taskbar) = match kind {
+        "spotlight" => ("spotlight", "spotlight", 600.0, 80.0, true, true),
+        "widget" => ("widget", "widget", 150.0, 150.0, true, true),
+        "screen-picker" => ("screen-picker", "screen-picker", 1280.0, 800.0, true, true),
+        "live-translate-controls" => (
+            "live-translate-controls",
+            "live-translate-controls",
+            880.0,
+            76.0,
+            true,
+            true,
+        ),
+        other => return Err(format!("unsupported desktop window '{other}'")),
+    };
+
+    if let Some(window) = app.get_webview_window(label) {
+        window.show().map_err(|error| error.to_string())?;
+        window.set_focus().map_err(|error| error.to_string())?;
+        return Ok(());
+    }
+
+    let url = WebviewUrl::App(format!("index.html#/{route}").into());
+    let mut builder = WebviewWindowBuilder::new(app, label, url)
+        .title(format!("Mint {kind}"))
+        .inner_size(width, height)
+        .decorations(false)
+        .transparent(true)
+        .always_on_top(always_on_top)
+        .skip_taskbar(skip_taskbar);
+    if kind == "screen-picker" {
+        builder = builder.fullscreen(true);
+    }
+    builder.build().map_err(|error| error.to_string())?;
+    Ok(())
+}
+
+pub fn hide_window(app: &AppHandle, label: &str) -> Result<(), String> {
+    app.get_webview_window(label)
+        .ok_or_else(|| format!("window '{label}' is not open"))?
+        .hide()
+        .map_err(|error| error.to_string())
+}
+
+pub fn close_window(app: &AppHandle, label: &str) -> Result<(), String> {
+    app.get_webview_window(label)
+        .ok_or_else(|| format!("window '{label}' is not open"))?
+        .close()
+        .map_err(|error| error.to_string())
+}
+
+pub fn resize_window(app: &AppHandle, label: &str, width: u32, height: u32) -> Result<(), String> {
+    app.get_webview_window(label)
+        .ok_or_else(|| format!("window '{label}' is not open"))?
+        .set_size(PhysicalSize::new(width, height))
+        .map_err(|error| error.to_string())
+}
+
+pub fn position_widget(app: &AppHandle) {
+    let Some(widget) = app.get_webview_window("widget") else {
+        return;
+    };
+    let Ok(Some(monitor)) = widget.primary_monitor() else {
+        return;
+    };
+    let size = monitor.size();
+    let x = size.width.saturating_sub(190) as i32;
+    let _ = widget.set_position(PhysicalPosition::new(x, 40));
+}
+
+pub fn emit_to_main(app: &AppHandle, event: &str, payload: impl Serialize + Clone) {
+    if let Some(main) = app.get_webview_window("main") {
+        let _ = main.emit(event, payload);
+        let _ = main.show();
+        let _ = main.set_focus();
+    }
+}
+
+#[tauri::command]
+pub(crate) fn open_window(app: AppHandle, kind: String) -> Result<(), String> {
+    if kind == "main" {
+        let window = app
+            .get_webview_window("main")
+            .ok_or_else(|| "main window is unavailable".to_string())?;
+        window.show().map_err(|error| error.to_string())?;
+        window.set_focus().map_err(|error| error.to_string())?;
+        return Ok(());
+    }
+    open_desktop_window(&app, &kind)?;
+    if kind == "widget" {
+        position_widget(&app);
+    }
+    Ok(())
+}
+
+#[tauri::command]
+pub(crate) fn hide_desktop_window(app: AppHandle, label: String) -> Result<(), String> {
+    hide_window(&app, &label)
+}
+
+#[tauri::command]
+pub(crate) fn close_desktop_window(app: AppHandle, label: String) -> Result<(), String> {
+    close_window(&app, &label)?;
+    if label == "screen-picker" {
+        if let Some(controls) = app.get_webview_window("live-translate-controls") {
+            let _ = controls.close();
+        }
+        reset_live_translate_interaction();
+        if let Some(main) = app.get_webview_window("main") {
+            main.show().map_err(|error| error.to_string())?;
+            main.set_focus().map_err(|error| error.to_string())?;
+        }
+    }
+    Ok(())
+}
+
+#[tauri::command]
+pub(crate) fn resize_desktop_window(
+    app: AppHandle,
+    label: String,
+    width: u32,
+    height: u32,
+) -> Result<(), String> {
+    resize_window(&app, &label, width, height)
+}
+
+#[tauri::command]
+pub(crate) fn submit_spotlight(app: AppHandle, query: String) {
+    emit_to_main(&app, "spotlight-to-chat", query);
+    let _ = hide_window(&app, "spotlight");
+}
+
+#[tauri::command]
+pub(crate) fn set_ai_state(app: AppHandle, state: String) {
+    if let Some(widget) = app.get_webview_window("widget") {
+        let _ = widget.emit("widget-state", state);
+    }
+}

package/tsconfig.json

@@ -22,9 +22,25 @@
     "noFallthroughCasesInSwitch": true,
 
     "paths": {
+      "@/components/ui/*": ["./src/renderer/shared/components/ui/*"],
+      "@/lib/utils": ["./src/renderer/shared/lib/utils"],
       "@/*": ["./src/renderer/src/*", "./src/renderer/src-web/*"],
       "@shared/*": ["./src/renderer/shared/*"]
     }
   },
-  "include": ["src/renderer/src", "src/renderer/src-web", "src/renderer/src/env.d.ts"]
+  "include": [
+    "src/renderer/src",
+    "src/renderer/src-web",
+    "src/renderer/shared",
+    "src/renderer/src/env.d.ts",
+    "src/renderer/src-web/env.d.ts",
+    "src/renderer/shared/env.d.ts"
+  ],
+  "exclude": [
+    "**/*.test.ts",
+    "**/*.test.tsx",
+    "**/*.spec.ts",
+    "**/*.spec.tsx",
+    "src/renderer/tests"
+  ]
 }

package/vite.config.ts

@@ -1,7 +1,9 @@
 // @ts-nocheck
 import { defineConfig } from 'vite'
 import react from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
 import { resolve } from 'path'
+import { pdfjsAssets } from './src/bin/pdfjs-assets.mjs'
 
 export default defineConfig({
   root: resolve(__dirname, 'src/renderer'),
@@ -24,9 +26,11 @@ export default defineConfig({
       ]
     }
   },
-  plugins: [react()],
+  plugins: [react(), tailwindcss(), pdfjsAssets()],
   resolve: {
     alias: {
+      '@/components/ui': resolve(__dirname, 'src/renderer/shared/components/ui'),
+      '@/lib/utils': resolve(__dirname, 'src/renderer/shared/lib/utils'),
       '@': resolve(__dirname, 'src/renderer/src'),
       '@shared': resolve(__dirname, 'src/renderer/shared')
     }

package/vite.config.web.ts

@@ -1,7 +1,9 @@
 // @ts-nocheck
 import { defineConfig } from 'vite'
 import react from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
 import { resolve } from 'path'
+import { pdfjsAssets } from './src/bin/pdfjs-assets.mjs'
 
 export default defineConfig({
   root: resolve(__dirname, 'src/renderer'),
@@ -52,6 +54,8 @@ export default defineConfig({
   },
   plugins: [
     react(),
+    tailwindcss(),
+    pdfjsAssets(),
     {
       name: 'rewrite-html',
       configureServer(server) {
@@ -83,6 +87,8 @@ export default defineConfig({
   ],
   resolve: {
     alias: {
+      '@/components/ui': resolve(__dirname, 'src/renderer/shared/components/ui'),
+      '@/lib/utils': resolve(__dirname, 'src/renderer/shared/lib/utils'),
       '@': resolve(__dirname, 'src/renderer/src-web'),
       '@shared': resolve(__dirname, 'src/renderer/shared')
     }

package/.cargo/config.toml

@@ -1,13 +0,0 @@
-# Keep local builds from exhausting RAM on low-memory machines.
-#
-# `cargo test`/`build` otherwise fan out to one job per CPU (12 here), and
-# each rustc + linker for a big crate can use 1-3 GB. On a 6 GB box that
-# thrashes swap until the desktop session dies. Capping jobs plus using the
-# lower-memory `lld` linker keeps peak usage sane. Override per-invocation
-# with `cargo build -j <n>` or `CARGO_BUILD_JOBS` when you have the headroom.
-
-[build]
-jobs = 4
-
-[target.x86_64-unknown-linux-gnu]
-rustflags = ["-C", "link-arg=-fuse-ld=lld", "-C", "link-arg=-L/usr/lib/gcc/x86_64-linux-gnu/13", "-C", "link-arg=-L/usr/lib/gcc/x86_64-linux-gnu/14"]