ltcai 4.3.0 → 4.3.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ltcai",
-  "version": "4.3.0",
-  "description": "Lattice AI — local-first Digital Brain Platform (knowledge graph, durable memory, hybrid search, agents, signed brain exchange)",
+  "version": "4.3.1",
+  "description": "Lattice AI — local-first Digital Brain Platform (knowledge graph, durable memory, hybrid search, agents, portable encrypted brain archives)",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {
     "type": "git",
@@ -68,6 +68,7 @@
   "files": [
     "bin/ltcai.js",
     "LICENSE",
+    "requirements.txt",
     "ltcai_cli.py",
     "auto_setup.py",
     "server.py",

package/requirements.txt

@@ -0,0 +1,17 @@
+fastapi>=0.110,<1
+uvicorn>=0.29,<1
+pydantic>=2.7,<3
+httpx>=0.27,<1
+pillow>=10,<13
+openai>=1.30,<3
+python-docx>=1.1,<2
+openpyxl>=3.1,<4
+python-pptx>=0.6.23,<2
+python-multipart>=0.0.9,<0.1
+keyring>=24,<26
+authlib>=1.3,<2
+cryptography>=42,<49
+pdfplumber>=0.11,<0.12
+pypdfium2>=4.30,<6
+watchdog>=4,<7
+psycopg[binary]>=3.2,<4

package/src-tauri/Cargo.lock

@@ -1654,7 +1654,7 @@ dependencies = [
 
 [[package]]
 name = "lattice-ai-desktop"
-version = "4.3.0"
+version = "4.3.1"
 dependencies = [
  "plist",
  "serde",

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lattice-ai-desktop"
-version = "4.3.0"
+version = "4.3.1"
 description = "Lattice AI Digital Brain desktop shell"
 authors = ["TaeSoo Park"]
 edition = "2021"

package/src-tauri/src/main.rs

@@ -1,5 +1,7 @@
 use std::{
     env,
+    fs::OpenOptions,
+    path::PathBuf,
     process::{Child, Command, Stdio},
     sync::Mutex,
 };
@@ -10,6 +12,7 @@ use tauri::{Manager, State};
 struct BackendState {
     origin: String,
     command: String,
+    cwd: Option<String>,
     child: Mutex<Option<Child>>,
     last_error: Mutex<Option<String>>,
 }
@@ -18,11 +21,19 @@ struct BackendState {
 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>,
+}
+
 #[tauri::command]
 fn backend_origin(state: State<'_, BackendState>) -> String {
     state.origin.clone()
@@ -36,7 +47,8 @@ fn backend_status(state: State<'_, BackendState>) -> BackendStatus {
 #[tauri::command]
 fn restart_backend(state: State<'_, BackendState>) -> BackendStatus {
     kill_backend(&state);
-    match spawn_backend(&state.origin, &state.command) {
+    let launch = backend_launch(&state.origin);
+    match spawn_backend(&state.origin, &launch) {
         Ok(child) => {
             if let Ok(mut slot) = state.child.lock() {
                 *slot = child;
@@ -55,15 +67,174 @@ fn shutdown_backend(state: State<'_, BackendState>) -> BackendStatus {
 }
 
 fn split_command(command: &str) -> Vec<String> {
-    command
-        .split_whitespace()
-        .map(|part| part.to_string())
-        .collect()
+    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
+}
+
+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("ltcai_cli.py").is_file() {
+        Some(up)
+    } else if resources.join("ltcai_cli.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_command() -> String {
-    env::var("LATTICEAI_DESKTOP_BACKEND_CMD")
-        .unwrap_or_else(|_| "python3 ltcai_cli.py --host 127.0.0.1 --port 8765".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, "ltcai_cli") {
+            return BackendLaunch {
+                command: format!("{python} -m ltcai_cli --host 127.0.0.1 --port {port}"),
+                program: python,
+                args: vec![
+                    "-m".into(),
+                    "ltcai_cli".into(),
+                    "--host".into(),
+                    "127.0.0.1".into(),
+                    "--port".into(),
+                    port,
+                ],
+                cwd: None,
+            };
+        }
+    }
+
+    if let Some(resources) = bundled_python_root() {
+        let launcher = resources.join("ltcai_cli.py");
+        if launcher.is_file() {
+            if let Some(python) = python_candidates().into_iter().next() {
+                return BackendLaunch {
+                    command: format!("{python} {} --host 127.0.0.1 --port {port}", launcher.display()),
+                    program: python,
+                    args: vec![
+                        launcher.to_string_lossy().to_string(),
+                        "--host".into(),
+                        "127.0.0.1".into(),
+                        "--port".into(),
+                        port,
+                    ],
+                    cwd: None,
+                };
+            }
+        }
+    }
+
+    BackendLaunch {
+        command: "unavailable: LTCAI executable or importable ltcai_cli module not found".to_string(),
+        program: String::new(),
+        args: Vec::new(),
+        cwd: None,
+    }
 }
 
 fn set_error(state: &BackendState, err: Option<String>) {
@@ -72,30 +243,64 @@ fn set_error(state: &BackendState, err: Option<String>) {
     }
 }
 
-fn spawn_backend(origin: &str, command: &str) -> Result<Option<Child>, String> {
+fn spawn_backend(origin: &str, launch: &BackendLaunch) -> Result<Option<Child>, String> {
     if env::var("LATTICEAI_DESKTOP_NO_BACKEND").is_ok() {
         return Ok(None);
     }
-    let parts = split_command(&command);
-    if parts.is_empty() {
-        return Err("Desktop backend command is empty.".to_string());
+    if launch.program.is_empty() {
+        return Err("Desktop backend unavailable: LTCAI executable or importable ltcai_cli module not found.".to_string());
     }
-    let mut cmd = Command::new(&parts[0]);
-    cmd.args(&parts[1..])
+
+    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")
-        .stdout(Stdio::null())
-        .stderr(Stdio::null());
-    if let Ok(cwd) = env::var("LATTICEAI_DESKTOP_BACKEND_CWD") {
+        .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());
+        }
+        if let Ok(file) = OpenOptions::new().create(true).append(true).open(log_dir.join("desktop-sidecar.err.log")) {
+            cmd.stderr(Stdio::from(file));
+        } 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 '{}': {}", parts[0], err))
+        .map_err(|err| format!("Failed to start desktop backend '{}': {}", launch.command, err))
 }
 
 fn kill_backend(state: &BackendState) {
@@ -125,25 +330,40 @@ fn status_from_state(state: &BackendState) -> BackendStatus {
             }
         }
     }
-    let last_error = state
-        .last_error
-        .lock()
-        .ok()
-        .and_then(|guard| guard.clone());
+    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 command = backend_command();
-    let (child, last_error) = match spawn_backend(&origin, &command) {
+    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)),
     };
@@ -151,6 +371,7 @@ fn main() {
         .manage(BackendState {
             origin,
             command,
+            cwd,
             child: Mutex::new(child),
             last_error: Mutex::new(last_error),
         })
@@ -163,6 +384,17 @@ fn main() {
         .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 mut 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);
+                    }
+                });
             }
             Ok(())
         })

package/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Lattice AI",
-  "version": "4.3.0",
+  "version": "4.3.1",
   "identifier": "ai.lattice.desktop",
   "build": {
     "beforeDevCommand": "npm run frontend:dev",
@@ -31,6 +31,25 @@
       "dmg",
       "app"
     ],
+    "resources": [
+      "../auto_setup.py",
+      "../kg_schema.py",
+      "../knowledge_graph.py",
+      "../knowledge_graph_api.py",
+      "../llm_router.py",
+      "../local_knowledge_api.py",
+      "../ltcai_cli.py",
+      "../mcp_registry.py",
+      "../p_reinforce.py",
+      "../server.py",
+      "../setup_wizard.py",
+      "../telegram_bot.py",
+      "../requirements.txt",
+      "../latticeai",
+      "../lattice_brain",
+      "../tools",
+      "../static"
+    ],
     "icon": [
       "../static/icons/icon-192.png",
       "../static/icons/icon-512.png"

package/static/app/asset-manifest.json

@@ -1,12 +1,12 @@
 {
-  "version": "4.3.0",
+  "version": "4.3.1",
   "generated_at": "vite",
   "entrypoints": {
     "app": "/static/app/index.html"
   },
   "assets": {
     "../node_modules/@tauri-apps/api/core.js": "/static/app/assets/core-CwxXejkd.js",
-    "index.html": "/static/app/assets/index-RiJTJliG.js",
+    "index.html": "/static/app/assets/index-BhPuj8rT.js",
     "assets/index-yZswHE3d.css": "/static/app/assets/index-yZswHE3d.css"
   },
   "vite": {
@@ -17,7 +17,7 @@
       "isDynamicEntry": true
     },
     "index.html": {
-      "file": "assets/index-RiJTJliG.js",
+      "file": "assets/index-BhPuj8rT.js",
       "name": "index",
       "src": "index.html",
       "isEntry": true,