ltcai 4.2.0 → 4.3.1

package/scripts/clean_release_artifacts.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+
+const repo = join(import.meta.dirname, "..");
+const version = process.argv[2] || process.env.npm_package_version;
+
+if (!version || !/^\d+\.\d+\.\d+([.-][0-9A-Za-z.]+)?$/.test(version)) {
+  console.error("usage: node scripts/clean_release_artifacts.mjs <version>");
+  process.exit(2);
+}
+
+const targets = [
+  join(repo, "dist", `ltcai-${version}-py3-none-any.whl`),
+  join(repo, "dist", `ltcai-${version}.tar.gz`),
+  join(repo, "dist", `ltcai-${version}.vsix`),
+  join(repo, `ltcai-${version}.tgz`),
+  join(repo, "src-tauri", "target", "release", "bundle", "dmg", `Lattice AI_${version}_aarch64.dmg`),
+  join(repo, "src-tauri", "target", "release", "bundle", "macos", "Lattice AI.app"),
+];
+
+for (const target of targets) {
+  if (existsSync(target)) {
+    rmSync(target, { recursive: true, force: true });
+    console.log(`removed ${target}`);
+  }
+}

package/scripts/lint_frontend.mjs

@@ -76,7 +76,12 @@ const requiredPaths = [
   "/api/brain/storage/postgres/docker",
   "/api/brain/storage/migrate-postgres",
   "/api/knowledge-graph/archive",
+  "/api/knowledge-graph/archive/inspect",
+  "/api/knowledge-graph/archive/verify",
+  "/api/knowledge-graph/archive/import",
   "/api/knowledge-graph/archive/restore",
+  "/api/knowledge-graph/backup-health",
+  "/admin/product-hardening",
 ];
 if (openapiPaths.length < 300) fail(`OpenAPI path count too low: ${openapiPaths.length}`);
 for (const path of requiredPaths) {

package/scripts/validate_release_artifacts.py

@@ -10,6 +10,7 @@ effort) that the VSIX actually contains the compiled extension entrypoint.
 Usage:
     python scripts/validate_release_artifacts.py 1.1.0
     python scripts/validate_release_artifacts.py 1.1.0 --require-vsix
+    python scripts/validate_release_artifacts.py 1.1.0 --require-dmg
     python scripts/validate_release_artifacts.py 1.1.0 --dist dist --json
 
 Exit code is non-zero on any failure so CI can fail fast.
@@ -63,6 +64,7 @@ def validate(
     *,
     require_vsix: bool,
     require_tgz: bool,
+    require_dmg: bool = False,
 ) -> Dict[str, object]:
     errors: List[str] = []
     warnings: List[str] = []
@@ -105,6 +107,12 @@ def validate(
         else:
             warnings.append(f"npm tarball not found: {tgz.name} (run `npm pack`)")
 
+    dmg = dist_dir.parent / "src-tauri" / "target" / "release" / "bundle" / "dmg" / f"Lattice AI_{version}_aarch64.dmg"
+    if dmg.is_file():
+        found["dmg"] = str(dmg)
+    elif require_dmg:
+        errors.append(f"missing dmg: {dmg}")
+
     # Guard against stale-version mixing: warn loudly about other-version builds
     # so a `dist/*` glob upload is obviously unsafe.
     other_versions = set()
@@ -137,6 +145,7 @@ def main(argv: Optional[List[str]] = None) -> int:
     parser.add_argument("--dist", default="dist", help="dist directory (default: dist)")
     parser.add_argument("--require-vsix", action="store_true", help="fail if the VSIX is absent")
     parser.add_argument("--require-tgz", action="store_true", help="check for npm pack tarball at repo root")
+    parser.add_argument("--require-dmg", action="store_true", help="fail if the Tauri DMG is absent")
     parser.add_argument("--json", action="store_true", help="emit machine-readable JSON")
     args = parser.parse_args(argv)
 
@@ -145,6 +154,7 @@ def main(argv: Optional[List[str]] = None) -> int:
         Path(args.dist),
         require_vsix=args.require_vsix,
         require_tgz=args.require_tgz,
+        require_dmg=args.require_dmg,
     )
 
     if args.json:

package/src-tauri/Cargo.lock

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

package/src-tauri/Cargo.toml

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

package/src-tauri/src/main.rs

@@ -1,14 +1,37 @@
 use std::{
     env,
+    fs::OpenOptions,
+    path::PathBuf,
     process::{Child, Command, Stdio},
     sync::Mutex,
 };
 
+use serde::Serialize;
 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>,
 }
 
 #[tauri::command]
@@ -16,60 +39,369 @@ fn backend_origin(state: State<'_, BackendState>) -> String {
     state.origin.clone()
 }
 
+#[tauri::command]
+fn backend_status(state: State<'_, BackendState>) -> BackendStatus {
+    status_from_state(&state)
+}
+
+#[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)
+}
+
+#[tauri::command]
+fn shutdown_backend(state: State<'_, BackendState>) -> BackendStatus {
+    kill_backend(&state);
+    status_from_state(&state)
+}
+
 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 spawn_backend(origin: &str) -> Option<Child> {
+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_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>) {
+    if let Ok(mut last) = state.last_error.lock() {
+        *last = err;
+    }
+}
+
+fn spawn_backend(origin: &str, launch: &BackendLaunch) -> Result<Option<Child>, String> {
     if env::var("LATTICEAI_DESKTOP_NO_BACKEND").is_ok() {
-        return None;
+        return Ok(None);
     }
-    let command = env::var("LATTICEAI_DESKTOP_BACKEND_CMD")
-        .unwrap_or_else(|_| "python3 ltcai_cli.py --host 127.0.0.1 --port 8765".to_string());
-    let parts = split_command(&command);
-    if parts.is_empty() {
-        return None;
+    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);
     }
-    cmd.spawn().ok()
+    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 '{}': {}", 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))),
+            }
+        }
+    }
+    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 child = spawn_backend(&origin);
+    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),
         })
-        .invoke_handler(tauri::generate_handler![backend_origin])
+        .invoke_handler(tauri::generate_handler![
+            backend_origin,
+            backend_status,
+            restart_backend,
+            shutdown_backend
+        ])
         .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(())
         })
         .on_window_event(|window, event| {
             if matches!(event, tauri::WindowEvent::CloseRequested { .. }) {
                 if let Some(state) = window.try_state::<BackendState>() {
-                    if let Ok(mut child) = state.child.lock() {
-                        if let Some(process) = child.as_mut() {
-                            let _ = process.kill();
-                        }
-                    }
+                    kill_backend(&state);
                 }
             }
         })

package/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Lattice AI",
-  "version": "4.2.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,13 +1,13 @@
 {
-  "version": "4.2.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-C_HAkbAg.js",
-    "assets/index-CDjiH_se.css": "/static/app/assets/index-CDjiH_se.css"
+    "index.html": "/static/app/assets/index-BhPuj8rT.js",
+    "assets/index-yZswHE3d.css": "/static/app/assets/index-yZswHE3d.css"
   },
   "vite": {
     "../node_modules/@tauri-apps/api/core.js": {
@@ -17,7 +17,7 @@
       "isDynamicEntry": true
     },
     "index.html": {
-      "file": "assets/index-C_HAkbAg.js",
+      "file": "assets/index-BhPuj8rT.js",
       "name": "index",
       "src": "index.html",
       "isEntry": true,
@@ -25,7 +25,7 @@
         "../node_modules/@tauri-apps/api/core.js"
       ],
       "css": [
-        "assets/index-CDjiH_se.css"
+        "assets/index-yZswHE3d.css"
       ]
     }
   }