ltcai 4.1.0 → 4.3.0

package/scripts/migrate_brain_storage.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""Brain storage migration utility.
+
+Examples:
+    python scripts/migrate_brain_storage.py plan --sqlite ~/.ltcai/knowledge_graph.sqlite --dsn postgresql://...
+    python scripts/migrate_brain_storage.py migrate --sqlite ~/.ltcai/knowledge_graph.sqlite --dsn postgresql://...
+    python scripts/migrate_brain_storage.py docker-plan --data-dir ~/.ltcai/postgres
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from lattice_brain.storage import DockerPostgresWizard, PostgresEngine, SQLiteToPostgresMigrator
+
+
+def _print_json(value: object) -> None:
+    print(json.dumps(value, ensure_ascii=False, indent=2))
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    for name in ("plan", "migrate"):
+        p = sub.add_parser(name)
+        p.add_argument("--sqlite", type=Path, required=True)
+        p.add_argument("--dsn", required=True)
+        p.add_argument("--schema", default="lattice_brain")
+
+    docker = sub.add_parser("docker-plan")
+    docker.add_argument("--data-dir", type=Path, required=True)
+    docker.add_argument("--port", type=int, default=5432)
+
+    args = parser.parse_args()
+    if args.command == "docker-plan":
+        wizard = DockerPostgresWizard(args.data_dir, port=args.port)
+        result = wizard.start(consent=False)
+        _print_json(result)
+        return 0
+
+    migrator = SQLiteToPostgresMigrator(
+        args.sqlite,
+        PostgresEngine(args.dsn, schema=args.schema),
+    )
+    _print_json(migrator.migrate(dry_run=args.command == "plan"))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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/scripts/wheel_smoke.py

@@ -33,6 +33,9 @@ REPO_ROOT = Path(__file__).resolve().parents[1]
 # Every importable module the wheel ships (pyproject py-modules + packages).
 WHEEL_MODULES = [
     "setup_wizard",
+    "lattice_brain",
+    "lattice_brain.storage",
+    "lattice_brain.archive",
     "latticeai",
     "latticeai.server_app",
     "latticeai.app_factory",

package/src-tauri/Cargo.lock

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

package/src-tauri/Cargo.toml

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

package/src-tauri/src/main.rs

@@ -4,11 +4,23 @@ use std::{
     sync::Mutex,
 };
 
+use serde::Serialize;
 use tauri::{Manager, State};
 
 struct BackendState {
     origin: String,
+    command: String,
     child: Mutex<Option<Child>>,
+    last_error: Mutex<Option<String>>,
+}
+
+#[derive(Serialize)]
+struct BackendStatus {
+    origin: String,
+    command: String,
+    running: bool,
+    pid: Option<u32>,
+    last_error: Option<String>,
 }
 
 #[tauri::command]
@@ -16,6 +28,32 @@ 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);
+    match spawn_backend(&state.origin, &state.command) {
+        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()
@@ -23,39 +61,105 @@ fn split_command(command: &str) -> Vec<String> {
         .collect()
 }
 
-fn spawn_backend(origin: &str) -> Option<Child> {
+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 set_error(state: &BackendState, err: Option<String>) {
+    if let Ok(mut last) = state.last_error.lock() {
+        *last = err;
+    }
+}
+
+fn spawn_backend(origin: &str, command: &str) -> 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;
+        return Err("Desktop backend command is empty.".to_string());
     }
     let mut cmd = Command::new(&parts[0]);
     cmd.args(&parts[1..])
         .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_CORS_ALLOW_NETWORK", "false")
         .env("LATTICEAI_TUNNEL", "false")
         .stdout(Stdio::null())
         .stderr(Stdio::null());
     if let Ok(cwd) = env::var("LATTICEAI_DESKTOP_BACKEND_CWD") {
         cmd.current_dir(cwd);
     }
-    cmd.spawn().ok()
+    cmd.spawn()
+        .map(Some)
+        .map_err(|err| format!("Failed to start desktop backend '{}': {}", parts[0], 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(),
+        running,
+        pid,
+        last_error,
+    }
 }
 
 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 command = backend_command();
+    let (child, last_error) = match spawn_backend(&origin, &command) {
+        Ok(child) => (child, None),
+        Err(err) => (None, Some(err)),
+    };
     tauri::Builder::default()
         .manage(BackendState {
             origin,
+            command,
             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");
@@ -65,11 +169,7 @@ fn main() {
         .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.1.0",
+  "version": "4.3.0",
   "identifier": "ai.lattice.desktop",
   "build": {
     "beforeDevCommand": "npm run frontend:dev",
@@ -27,7 +27,10 @@
   },
   "bundle": {
     "active": true,
-    "targets": ["dmg", "app"],
+    "targets": [
+      "dmg",
+      "app"
+    ],
     "icon": [
       "../static/icons/icon-192.png",
       "../static/icons/icon-512.png"

package/static/app/asset-manifest.json

@@ -1,13 +1,13 @@
 {
-  "version": "4.1.0",
+  "version": "4.3.0",
   "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-CJRAzNnf.js",
-    "assets/index-CSwBBgf4.css": "/static/app/assets/index-CSwBBgf4.css"
+    "index.html": "/static/app/assets/index-RiJTJliG.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-CJRAzNnf.js",
+      "file": "assets/index-RiJTJliG.js",
       "name": "index",
       "src": "index.html",
       "isEntry": true,
@@ -25,7 +25,7 @@
         "../node_modules/@tauri-apps/api/core.js"
       ],
       "css": [
-        "assets/index-CSwBBgf4.css"
+        "assets/index-yZswHE3d.css"
       ]
     }
   }