ltcai 11.2.0 → 11.5.0

package/src-tauri/src/main.rs

@@ -1,410 +1,137 @@
-use std::{
-    env,
-    fs::OpenOptions,
-    path::PathBuf,
-    process::{Child, Command, Stdio},
-    sync::Mutex,
-};
-
-use serde::Serialize;
+//! Lattice AI desktop shell.
+//!
+//! Everything this file used to do itself — resolving the worker command,
+//! spawning it, probing a TCP socket to guess whether it was up, killing and
+//! respawning on restart — moved into the `lattice-host` crate in 11.4.0 and is
+//! now shared with the `lattice-host` binary, so the desktop and the CLI front
+//! door cannot drift apart. What is left here is the part that is genuinely
+//! Tauri's: five commands, one window, and the promise that closing the window
+//! stops the worker.
+//!
+//! Since 11.5.0 the shell also *serves* that front door: the gateway runs
+//! in-process on the public port and the worker sits behind it (see
+//! [`topology`] for the arrangement and its escape hatches).
+//!
+//! The five command names and their response shapes are unchanged — the
+//! frontend (`frontend/src/api/base.ts`, `frontend/src/api/client.ts`) invokes
+//! them by name and reads `backend_status` as a plain record. The fields added
+//! in 11.5.0 are additive; nothing was renamed or removed.
+
+mod backend;
+mod folder;
+mod topology;
+
+use std::sync::Arc;
+
+use backend::{BackendStatus, DesktopBackend};
 use tauri::{Manager, State};
 
-struct BackendState {
-    origin: String,
-    command: String,
-    cwd: Option<String>,
-    child: Mutex<Option<Child>>,
-    last_error: Mutex<Option<String>>,
-}
-
-#[derive(Serialize)]
-struct BackendStatus {
-    origin: String,
-    command: String,
-    cwd: Option<String>,
-    running: bool,
-    pid: Option<u32>,
-    last_error: Option<String>,
-}
-
-struct BackendLaunch {
-    command: String,
-    program: String,
-    args: Vec<String>,
-    cwd: Option<PathBuf>,
-}
-
+/// `backend_origin` → the origin every frontend request is sent to.
 #[tauri::command]
-fn backend_origin(state: State<'_, BackendState>) -> String {
-    state.origin.clone()
+fn backend_origin(state: State<'_, Arc<DesktopBackend>>) -> String {
+    state.origin().to_string()
 }
 
+/// `backend_status` → a live snapshot, health probe included.
+///
+/// Async, and therefore `Result`, because Tauri requires it of a command that
+/// borrows state across an await. It never returns `Err`: the frontend keeps
+/// receiving a resolved record exactly as before.
 #[tauri::command]
-fn backend_status(state: State<'_, BackendState>) -> BackendStatus {
-    status_from_state(&state)
+async fn backend_status(state: State<'_, Arc<DesktopBackend>>) -> Result<BackendStatus, String> {
+    Ok(state.status().await)
 }
 
+/// `restart_backend` → stop, start, and report what happened.
 #[tauri::command]
-fn restart_backend(state: State<'_, BackendState>) -> BackendStatus {
-    kill_backend(&state);
-    let launch = backend_launch(&state.origin);
-    match spawn_backend(&state.origin, &launch) {
-        Ok(child) => {
-            if let Ok(mut slot) = state.child.lock() {
-                *slot = child;
-            }
-            set_error(&state, None);
-        }
-        Err(err) => set_error(&state, Some(err)),
-    }
-    status_from_state(&state)
+async fn restart_backend(state: State<'_, Arc<DesktopBackend>>) -> Result<BackendStatus, String> {
+    Ok(state.restart().await)
 }
 
+/// `shutdown_backend` → stop the worker and suppress restarts.
 #[tauri::command]
-fn shutdown_backend(state: State<'_, BackendState>) -> BackendStatus {
-    kill_backend(&state);
-    status_from_state(&state)
+async fn shutdown_backend(state: State<'_, Arc<DesktopBackend>>) -> Result<BackendStatus, String> {
+    Ok(state.stop().await)
 }
 
+/// `select_folder` → the native directory picker.
 #[tauri::command]
 fn select_folder() -> Option<String> {
-    native_select_folder()
-}
-
-#[cfg(target_os = "macos")]
-fn native_select_folder() -> Option<String> {
-    let output = Command::new("osascript")
-        .args([
-            "-e",
-            r#"POSIX path of (choose folder with prompt "Choose a folder for Lattice AI")"#,
-        ])
-        .output()
-        .ok()?;
-    if !output.status.success() {
-        return None;
-    }
-    let path = String::from_utf8_lossy(&output.stdout).trim().to_string();
-    if path.is_empty() {
-        None
-    } else {
-        Some(path)
-    }
-}
-
-#[cfg(not(target_os = "macos"))]
-fn native_select_folder() -> Option<String> {
-    None
-}
-
-fn split_command(command: &str) -> Vec<String> {
-    command.split_whitespace().map(|part| part.to_string()).collect()
-}
-
-fn command_in_path(name: &str) -> Option<String> {
-    let mut dirs: Vec<PathBuf> = env::var_os("PATH")
-        .map(|value| env::split_paths(&value).collect())
-        .unwrap_or_default();
-    dirs.extend([
-        PathBuf::from("/opt/homebrew/bin"),
-        PathBuf::from("/usr/local/bin"),
-        PathBuf::from("/usr/bin"),
-        PathBuf::from("/bin"),
-    ]);
-    for dir in dirs {
-        let candidate = dir.join(name);
-        if candidate.is_file() {
-            return Some(candidate.to_string_lossy().to_string());
-        }
-    }
-    None
+    folder::select_folder()
 }
 
-fn python_candidates() -> Vec<String> {
-    let mut out = Vec::new();
-    if let Ok(value) = env::var("LTCAI_PYTHON") {
-        out.push(value);
-    }
-    for name in ["python3", "python"] {
-        if let Some(path) = command_in_path(name) {
-            out.push(path);
-        }
-    }
-    out.extend([
-        "/opt/homebrew/bin/python3".to_string(),
-        "/usr/local/bin/python3".to_string(),
-        "/usr/bin/python3".to_string(),
-    ]);
-    out.sort();
-    out.dedup();
-    out
-}
-
-fn module_importable(python: &str, module: &str) -> bool {
-    Command::new(python)
-        .args(["-c", &format!("import {module}")])
-        .stdout(Stdio::null())
-        .stderr(Stdio::null())
-        .status()
-        .map(|status| status.success())
-        .unwrap_or(false)
-}
-
-fn resource_dir() -> Option<PathBuf> {
-    let exe = env::current_exe().ok()?;
-    let macos_dir = exe.parent()?;
-    let contents_dir = macos_dir.parent()?;
-    let resources = contents_dir.join("Resources");
-    if resources.exists() {
-        Some(resources)
-    } else {
-        None
-    }
-}
-
-fn bundled_python_root() -> Option<PathBuf> {
-    let resources = resource_dir()?;
-    let up = resources.join("_up_");
-    if up.join("latticeai").join("cli").join("entrypoint.py").is_file() {
-        Some(up)
-    } else if resources.join("latticeai").join("cli").join("entrypoint.py").is_file() {
-        Some(resources)
-    } else {
-        None
-    }
-}
-
-fn desktop_runtime_dir() -> Option<PathBuf> {
-    let home = env::var("HOME").ok()?;
-    let dir = PathBuf::from(home).join(".ltcai").join("desktop-runtime");
-    let _ = std::fs::create_dir_all(&dir);
-    Some(dir)
-}
-
-fn python_path_env(launch: &BackendLaunch) -> Option<String> {
-    let mut paths: Vec<PathBuf> = Vec::new();
-    if let Some(resources) = bundled_python_root() {
-        paths.push(resources);
-    }
-    if let Some(cwd) = &launch.cwd {
-        if !paths.iter().any(|path| path == cwd) {
-            paths.push(cwd.clone());
-        }
-    }
-    if let Some(existing) = env::var_os("PYTHONPATH") {
-        paths.extend(env::split_paths(&existing));
-    }
-    env::join_paths(paths).ok().map(|value| value.to_string_lossy().to_string())
-}
-
-fn backend_launch(origin: &str) -> BackendLaunch {
-    let port = origin.rsplit(':').next().unwrap_or("8765").to_string();
-    if let Ok(command) = env::var("LATTICEAI_DESKTOP_BACKEND_CMD") {
-        let parts = split_command(&command);
-        if let Some(program) = parts.first() {
-            return BackendLaunch {
-                command,
-                program: program.clone(),
-                args: parts[1..].to_vec(),
-                cwd: env::var("LATTICEAI_DESKTOP_BACKEND_CWD").ok().map(PathBuf::from),
-            };
-        }
-    }
-
-    for name in ["LTCAI", "ltcai"] {
-        if let Some(program) = command_in_path(name) {
-            return BackendLaunch {
-                command: format!("{program} --host 127.0.0.1 --port {port}"),
-                program,
-                args: vec!["--host".into(), "127.0.0.1".into(), "--port".into(), port],
-                cwd: None,
-            };
-        }
-    }
-
-    for python in python_candidates() {
-        if module_importable(&python, "latticeai.cli.entrypoint") {
-            return BackendLaunch {
-                command: format!("{python} -m latticeai.cli.entrypoint --host 127.0.0.1 --port {port}"),
-                program: python,
-                args: vec![
-                    "-m".into(),
-                    "latticeai.cli.entrypoint".into(),
-                    "--host".into(),
-                    "127.0.0.1".into(),
-                    "--port".into(),
-                    port,
-                ],
-                cwd: None,
-            };
+/// Bring the worker up, then point the webview at `{origin}/app`.
+///
+/// The navigation waits on the worker's own `GET /health` rather than on a TCP
+/// connect: a bound socket only proves something is listening, and landing on
+/// `/app` before the routes exist is what used to show a blank window.
+fn boot(app: &tauri::App) {
+    let Some(window) = app.get_webview_window("main") else {
+        return;
+    };
+    let _ = window.set_title("Lattice AI");
+    let _ = window.show();
+    let _ = window.set_focus();
+
+    let shell = Arc::clone(&app.state::<Arc<DesktopBackend>>());
+    tauri::async_runtime::spawn(async move {
+        let status = shell.start().await;
+        if !status.healthy && !shell.supervised() {
+            // A supervised worker already had its health gate inside `start`;
+            // an adopted one (LATTICEAI_DESKTOP_BACKEND_ORIGIN) still needs it.
+            // Waiting in both places would double the worst case.
+            shell.wait_until_serving().await;
         }
-    }
-
-    if let Some(resources) = bundled_python_root() {
-        if resources.join("latticeai").join("cli").join("entrypoint.py").is_file() {
-            if let Some(python) = python_candidates().into_iter().next() {
-                return BackendLaunch {
-                    command: format!("{python} -m latticeai.cli.entrypoint --host 127.0.0.1 --port {port}"),
-                    program: python,
-                    args: vec![
-                        "-m".into(),
-                        "latticeai.cli.entrypoint".into(),
-                        "--host".into(),
-                        "127.0.0.1".into(),
-                        "--port".into(),
-                        port,
-                    ],
-                    cwd: Some(resources),
-                };
-            }
+        // Navigate either way, as the shell always has: a window showing the
+        // browser's own "cannot connect" is more use than a window showing
+        // nothing while a worker that will never arrive is waited for.
+        if let Ok(url) = tauri::Url::parse(&shell.app_url()) {
+            let _ = window.navigate(url);
         }
-    }
-
-    BackendLaunch {
-        command: "unavailable: LTCAI executable or importable latticeai.cli.entrypoint module not found".to_string(),
-        program: String::new(),
-        args: Vec::new(),
-        cwd: None,
-    }
-}
-
-fn set_error(state: &BackendState, err: Option<String>) {
-    if let Ok(mut last) = state.last_error.lock() {
-        *last = err;
+    });
+}
+
+/// Stop the worker and the front door from a synchronous Tauri callback
+/// (window close, app exit).
+///
+/// `block_on` is safe here because these callbacks run on the event loop
+/// thread, outside any async runtime — and the wait is what makes the shutdown
+/// graceful: SIGTERM, then SIGKILL only if the worker ignores it, so the
+/// worker gets to close its SQLite handles instead of being shot mid-write.
+fn stop_worker<R: tauri::Runtime, M: Manager<R>>(manager: &M) {
+    if let Some(shell) = manager.try_state::<Arc<DesktopBackend>>() {
+        let shell = Arc::clone(&shell);
+        let stopping = Arc::clone(&shell);
+        tauri::async_runtime::block_on(async move {
+            stopping.stop().await;
+        });
+        // The gateway outlives `shutdown_backend` on purpose (so the window can
+        // still read `/host/status`), but not the process.
+        shell.stop_gateway();
     }
 }
 
-fn spawn_backend(origin: &str, launch: &BackendLaunch) -> Result<Option<Child>, String> {
-    if env::var("LATTICEAI_DESKTOP_NO_BACKEND").is_ok() {
-        return Ok(None);
-    }
-    if launch.program.is_empty() {
-        return Err("Desktop backend unavailable: LTCAI executable or importable latticeai.cli.entrypoint module not found.".to_string());
-    }
-
-    let mut cmd = Command::new(&launch.program);
-    cmd.args(&launch.args)
-        .env("LATTICEAI_HOST", "127.0.0.1")
-        .env("LATTICEAI_PORT", origin.rsplit(':').next().unwrap_or("8765"))
-        .env("LATTICEAI_ENABLE_TELEGRAM", "false")
-        .env("LATTICEAI_AUTOLOAD_MODELS", "false")
-        .env("LATTICEAI_ALLOW_MODEL_DOWNLOADS", "false")
-        .env("LATTICEAI_CORS_ALLOW_NETWORK", "false")
-        .env("LATTICEAI_ENABLE_EXTERNAL_CONNECTORS", "false")
-        .env("LATTICEAI_TUNNEL", "false")
-        .env(
-            "PATH",
-            format!(
-                "{}:{}",
-                "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin",
-                env::var("PATH").unwrap_or_default()
-            ),
-        );
-    if let Some(runtime_dir) = desktop_runtime_dir() {
-        cmd.env("LATTICEAI_AGENT_ROOT", runtime_dir.join("agent_workspace"));
-        if launch.cwd.is_none() {
-            cmd.current_dir(&runtime_dir);
-        }
-    }
-    if let Some(python_path) = python_path_env(launch) {
-        cmd.env("PYTHONPATH", python_path);
-    }
-    if let Some(cwd) = &launch.cwd {
-        cmd.current_dir(cwd);
-    }
-    if let Ok(home) = env::var("HOME") {
-        let log_dir = PathBuf::from(home).join(".ltcai");
-        let _ = std::fs::create_dir_all(&log_dir);
-        if let Ok(file) = OpenOptions::new().create(true).append(true).open(log_dir.join("desktop-sidecar.log")) {
-            cmd.stdout(Stdio::from(file));
-        } else {
-            cmd.stdout(Stdio::null());
+fn main() {
+    let shell = match DesktopBackend::resolve() {
+        Ok(shell) => Arc::new(shell),
+        Err(err) => {
+            eprintln!("lattice-ai-desktop: cannot prepare the backend: {err}");
+            std::process::exit(1);
         }
-        if let Ok(file) = OpenOptions::new().create(true).append(true).open(log_dir.join("desktop-sidecar.err.log")) {
-            cmd.stderr(Stdio::from(file));
+    };
+    eprintln!(
+        "lattice-ai-desktop: backend {} [{}] ({})",
+        shell.origin(),
+        shell.topology().as_str(),
+        if shell.supervised() {
+            "supervised here"
         } else {
-            cmd.stderr(Stdio::null());
-        }
-    } else {
-        cmd.stdout(Stdio::null()).stderr(Stdio::null());
-    }
-
-    cmd.spawn()
-        .map(Some)
-        .map_err(|err| format!("Failed to start desktop backend '{}': {}", launch.command, err))
-}
-
-fn kill_backend(state: &BackendState) {
-    if let Ok(mut child) = state.child.lock() {
-        if let Some(mut process) = child.take() {
-            let _ = process.kill();
-            let _ = process.wait();
-        }
-    }
-}
-
-fn status_from_state(state: &BackendState) -> BackendStatus {
-    let mut running = false;
-    let mut pid = None;
-    if let Ok(mut child_slot) = state.child.lock() {
-        if let Some(child) = child_slot.as_mut() {
-            match child.try_wait() {
-                Ok(Some(status)) => {
-                    set_error(state, Some(format!("Desktop backend exited with status {}", status)));
-                    *child_slot = None;
-                }
-                Ok(None) => {
-                    running = true;
-                    pid = Some(child.id());
-                }
-                Err(err) => set_error(state, Some(format!("Unable to inspect desktop backend: {}", err))),
-            }
+            "external — nothing will be spawned"
         }
-    }
-    let last_error = state.last_error.lock().ok().and_then(|guard| guard.clone());
-    BackendStatus {
-        origin: state.origin.clone(),
-        command: state.command.clone(),
-        cwd: state.cwd.clone(),
-        running,
-        pid,
-        last_error,
-    }
-}
+    );
 
-fn wait_for_backend(origin: &str) {
-    let host_port = origin
-        .trim_start_matches("http://")
-        .trim_start_matches("https://")
-        .split('/')
-        .next()
-        .unwrap_or("127.0.0.1:8765")
-        .to_string();
-    for _ in 0..45 {
-        if std::net::TcpStream::connect(&host_port).is_ok() {
-            return;
-        }
-        std::thread::sleep(std::time::Duration::from_millis(500));
-    }
-}
-
-fn main() {
-    let origin = env::var("LATTICEAI_DESKTOP_BACKEND_ORIGIN")
-        .unwrap_or_else(|_| "http://127.0.0.1:8765".to_string());
-    let launch = backend_launch(&origin);
-    let command = launch.command.clone();
-    let cwd = launch.cwd.as_ref().map(|path| path.to_string_lossy().to_string());
-    let (child, last_error) = match spawn_backend(&origin, &launch) {
-        Ok(child) => (child, None),
-        Err(err) => (None, Some(err)),
-    };
     tauri::Builder::default()
-        .manage(BackendState {
-            origin,
-            command,
-            cwd,
-            child: Mutex::new(child),
-            last_error: Mutex::new(last_error),
-        })
+        .manage(shell)
         .invoke_handler(tauri::generate_handler![
             backend_origin,
             backend_status,
@@ -413,27 +140,12 @@ fn main() {
             select_folder
         ])
         .setup(|app| {
-            if let Some(window) = app.get_webview_window("main") {
-                let _ = window.set_title("Lattice AI");
-                let _ = window.show();
-                let _ = window.set_focus();
-                let origin = app.state::<BackendState>().origin.clone();
-                let target = format!("{}/app", origin.trim_end_matches('/'));
-                let window_for_nav = window.clone();
-                std::thread::spawn(move || {
-                    wait_for_backend(&origin);
-                    if let Ok(url) = tauri::Url::parse(&target) {
-                        let _ = window_for_nav.navigate(url);
-                    }
-                });
-            }
+            boot(app);
             Ok(())
         })
         .on_window_event(|window, event| {
             if matches!(event, tauri::WindowEvent::CloseRequested { .. }) {
-                if let Some(state) = window.try_state::<BackendState>() {
-                    kill_backend(&state);
-                }
+                stop_worker(window);
             }
         })
         .build(tauri::generate_context!())
@@ -443,9 +155,7 @@ fn main() {
                 event,
                 tauri::RunEvent::ExitRequested { .. } | tauri::RunEvent::Exit
             ) {
-                if let Some(state) = app_handle.try_state::<BackendState>() {
-                    kill_backend(&state);
-                }
+                stop_worker(app_handle);
             }
         });
 }