nmem-cli 0.10.4__tar.gz → 0.10.6__tar.gz

{nmem_cli-0.10.4 → nmem_cli-0.10.6}/Cargo.lock

@@ -5206,7 +5206,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-cli"
-version = "0.10.4"
+version = "0.10.6"
 dependencies = [
  "anstyle",
  "anyhow",
@@ -5222,7 +5222,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-content"
-version = "0.10.4"
+version = "0.10.6"
 dependencies = [
  "anyhow",
  "md5",
@@ -5234,7 +5234,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-core"
-version = "0.10.4"
+version = "0.10.6"
 dependencies = [
  "serde",
  "serde_json",
@@ -5244,7 +5244,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-docs"
-version = "0.10.4"
+version = "0.10.6"
 dependencies = [
  "criterion",
  "scraper",
@@ -5254,7 +5254,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-embed"
-version = "0.10.4"
+version = "0.10.6"
 dependencies = [
  "anyhow",
  "arrow-array",
@@ -5274,7 +5274,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-feed"
-version = "0.10.4"
+version = "0.10.6"
 dependencies = [
  "anyhow",
  "serde_json",
@@ -5283,7 +5283,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-graph"
-version = "0.10.4"
+version = "0.10.6"
 dependencies = [
  "anyhow",
  "caseless",
@@ -5302,7 +5302,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-harness"
-version = "0.10.4"
+version = "0.10.6"
 dependencies = [
  "anyhow",
  "futures",
@@ -5322,7 +5322,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-model"
-version = "0.10.4"
+version = "0.10.6"
 dependencies = [
  "anyhow",
  "encoding_rs",
@@ -5351,7 +5351,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-search"
-version = "0.10.4"
+version = "0.10.6"
 dependencies = [
  "anyhow",
  "arrow-array",
@@ -5373,7 +5373,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-server"
-version = "0.10.4"
+version = "0.10.6"
 dependencies = [
  "aes-gcm",
  "anyhow",
@@ -5429,7 +5429,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-tui"
-version = "0.10.4"
+version = "0.10.6"
 dependencies = [
  "anyhow",
  "arboard",
@@ -5443,7 +5443,7 @@ dependencies = [
 
 [[package]]
 name = "nmem-websearch"
-version = "0.10.4"
+version = "0.10.6"
 dependencies = [
  "anyhow",
  "dom_smoothie",

{nmem_cli-0.10.4 → nmem_cli-0.10.6}/Cargo.toml

@@ -4,7 +4,7 @@ members = ["crates/nmem-cli"]
 
 [workspace.package]
 edition = "2021"
-version = "0.10.4"
+version = "0.10.6"
 license = "UNLICENSED"
 publish = false
 

{nmem_cli-0.10.4 → nmem_cli-0.10.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nmem-cli
-Version: 0.10.4
+Version: 0.10.6
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{nmem_cli-0.10.4 → nmem_cli-0.10.6}/crates/nmem-cli/src/cli.rs

@@ -178,6 +178,19 @@ pub enum Command {
         #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
         passthrough: Vec<String>,
     },
+    /// Run the backend server (headless / self-hosted). Execs the sibling
+    /// `nmem-server` binary. Compatibility shim for systemd units written by the
+    /// old Python `nmem service install` (`ExecStart=… nmem serve --host … --port …`),
+    /// which broke when the Rust CLI — a REST client with no built-in server —
+    /// took over `/usr/local/bin/nmem`.
+    Serve {
+        /// Bind host (maps to NMEM_SERVER_ADDR host).
+        #[arg(long, default_value = "127.0.0.1")]
+        host: String,
+        /// Bind port (maps to NMEM_SERVER_ADDR port).
+        #[arg(long, default_value_t = 14242)]
+        port: u16,
+    },
 }
 
 // ── skills ───────────────────────────────────────────────────────────────────
@@ -1403,7 +1416,8 @@ pub struct ThreadImportArgs {
 
 #[derive(Args, Debug)]
 pub struct ThreadSaveArgs {
-    /// Source app: claude-code, codex, cursor, gemini-cli, opencode, pi, hermes.
+    /// Source app: claude-code, codex, cursor, gemini-cli, grok, hermes,
+    /// kimi-code, kimi-work, mimo-code, omp, opencode, pi.
     #[arg(long = "from", value_name = "HOST")]
     pub source_app: String,
     /// Project directory path (default: current dir).
@@ -1439,7 +1453,8 @@ pub struct ThreadSaveArgs {
 
 #[derive(Args, Debug)]
 pub struct ThreadSyncArgs {
-    /// Source app: claude-code, codex, cursor, gemini-cli, opencode, pi, hermes.
+    /// Source app: claude-code, codex, cursor, gemini-cli, grok, hermes,
+    /// kimi-code, kimi-work, mimo-code, omp, opencode, pi.
     #[arg(long = "from", value_name = "HOST")]
     pub source_app: String,
     /// Project directory path.
@@ -1457,7 +1472,8 @@ pub struct ThreadSyncArgs {
     /// Specific session ID.
     #[arg(long = "session-id")]
     pub session_id: Option<String>,
-    /// Cursor/Pi session directory/JSONL file or Hermes state.db to scan (repeatable).
+    /// Host transcript directory/file to scan (repeatable). Supports sources
+    /// such as Cursor workspaces, Pi/OMP JSONL roots, and Hermes state.db.
     #[arg(long = "session-dir")]
     pub session_dirs: Vec<String>,
     /// Truncate large tool results where supported.

{nmem_cli-0.10.4 → nmem_cli-0.10.6}/crates/nmem-cli/src/main.rs

@@ -45,6 +45,11 @@ async fn run(cli: Cli) -> anyhow::Result<()> {
         return launch_tui(api_flag, passthrough);
     }
 
+    // `serve` execs the backend (`nmem-server`) and needs no live client.
+    if let Command::Serve { host, port } = &cli.command {
+        return launch_server(host, *port);
+    }
+
     // Local-only config verbs (show/set/get-url/mcp show) need no live client.
     // Provider verbs hit /remote-llm/* and fall through to the client path.
     if let Command::Config { action } = &cli.command {
@@ -400,6 +405,7 @@ async fn run(cli: Cli) -> anyhow::Result<()> {
 
         // Handled before the client is built.
         Command::Tui { .. } => unreachable!("tui handled before client init"),
+        Command::Serve { .. } => unreachable!("serve handled before client init"),
     }
 }
 
@@ -440,11 +446,185 @@ fn launch_tui(api_flag: Option<&str>, passthrough: &[String]) -> anyhow::Result<
     std::process::exit(status.code().unwrap_or(1));
 }
 
+/// Run the backend by exec'ing the sibling `nmem-server` binary (resolved next
+/// to `nmem`, like the TUI). `nmem-server` takes its bind address from
+/// `NMEM_SERVER_ADDR`, so map `--host`/`--port` onto that (only if the caller
+/// hasn't already set it). On Unix we `exec` (replace the process) so systemd
+/// tracks the server's own PID instead of a wrapper; on Windows we spawn and
+/// forward the exit code. Compatibility shim for legacy `nmem serve …` units.
+fn launch_server(host: &str, port: u16) -> anyhow::Result<()> {
+    let exe = std::env::current_exe()
+        .map_err(|e| anyhow::anyhow!("cannot resolve current executable: {e}"))?;
+    let dir = exe
+        .parent()
+        .ok_or_else(|| anyhow::anyhow!("cannot resolve executable directory"))?;
+    let bin_name = if cfg!(target_os = "windows") {
+        "nmem-server.exe"
+    } else {
+        "nmem-server"
+    };
+    let server_path = dir.join(bin_name);
+    if !server_path.exists() {
+        anyhow::bail!(
+            "the backend binary `{}` was not found next to `nmem` (looked in {}). \
+             `nmem serve` runs the bundled backend; install the full package, not just the CLI.",
+            bin_name,
+            dir.display()
+        );
+    }
+
+    let mut cmd = std::process::Command::new(&server_path);
+    // Respect an explicit NMEM_SERVER_ADDR; otherwise derive it from --host/--port.
+    if std::env::var_os("NMEM_SERVER_ADDR").is_none() {
+        cmd.env("NMEM_SERVER_ADDR", format!("{host}:{port}"));
+    }
+    // Derive a default NMEM_APP_DATA when unset, so a LEGACY systemd unit (the
+    // Python `nmem service install` generated `nmem.service` sets only HOME/XDG_*
+    // and calls `nmem serve`) still finds the user's existing graph. Without this
+    // the server's `apply_app_data_root` no-ops and it boots WITHOUT a writable
+    // graph/search/content surface. Explicit env always wins (docker/operators/the
+    // Tauri launcher set it). The canonical graph dir is `<platform-data>/NowledgeGraph`
+    // (identical in the Tauri launcher `setup_user_directory` and the Python
+    // `get_nowledge_graph_data_dir`); it IS the dir holding `nowledge_graph_v2.db`,
+    // matching the NMEM_APP_DATA contract in the server's `apply_app_data_root`.
+    if std::env::var_os("NMEM_APP_DATA").is_none() {
+        match default_app_data_dir() {
+            Some(dir) => {
+                cmd.env("NMEM_APP_DATA", &dir);
+            }
+            None => {
+                // Home unresolvable: never guess a path that could boot against an
+                // empty dir — tell the operator to set it explicitly instead.
+                eprintln!(
+                    "nmem serve: NMEM_APP_DATA is unset and the home directory could not be \
+                     resolved; set NMEM_APP_DATA to your NowledgeGraph data dir so the server \
+                     serves your existing data."
+                );
+            }
+        }
+    }
+    // Config root: the legacy Python CLI stored app-settings.json / remote_llm.json
+    // / license under the platform CONFIG dir (XDG_CONFIG_HOME / %APPDATA% /
+    // Application Support). Without NMEM_APP_CONFIG_DIR the server's
+    // apply_app_data_root pins it to the GRAPH sibling instead, so an upgraded
+    // legacy headless install gets its graph back but loses provider, license, and
+    // access settings. Set the platform config dir when unset (explicit wins).
+    if std::env::var_os("NMEM_APP_CONFIG_DIR").is_none() {
+        if let Some(cfg) = default_config_dir() {
+            cmd.env("NMEM_APP_CONFIG_DIR", &cfg);
+        }
+    }
+    // Headless marker: `nmem serve` on a non-loopback bind (LAN / 0.0.0.0) is a
+    // DELIBERATE headless server (matching the Python image's `serve --host
+    // 0.0.0.0`). Mark it headless so the server's off-loopback fail-closed guard
+    // WARNS instead of REFUSING — otherwise an upgraded systemd/LAN start exits
+    // with the unauthenticated-bind error. Explicit NOWLEDGE_HEADLESS wins; a
+    // loopback bind stays unmarked (the desktop/local default).
+    if std::env::var_os("NOWLEDGE_HEADLESS").is_none() && !host_is_loopback(host) {
+        cmd.env("NOWLEDGE_HEADLESS", "1");
+    }
+
+    #[cfg(unix)]
+    {
+        use std::os::unix::process::CommandExt;
+        // exec replaces this process; only returns on failure.
+        let err = cmd.exec();
+        Err(anyhow::anyhow!(
+            "failed to exec {}: {err}",
+            server_path.display()
+        ))
+    }
+    #[cfg(not(unix))]
+    {
+        let status = cmd
+            .status()
+            .map_err(|e| anyhow::anyhow!("failed to launch {}: {e}", server_path.display()))?;
+        std::process::exit(status.code().unwrap_or(1));
+    }
+}
+
+/// The canonical NowledgeGraph graph DATA dir for the current platform, or
+/// `None` when the home directory cannot be resolved. Identical to the Tauri
+/// launcher `setup_user_directory` + the Python `get_nowledge_graph_data_dir`,
+/// so a default-derived `NMEM_APP_DATA` points at the SAME dir the desktop/Python
+/// already wrote (never an empty new one):
+///   - macOS:   `~/Library/Application Support/NowledgeGraph`
+///   - Windows: `%LOCALAPPDATA%/NowledgeGraph` (fallback `~/AppData/Local/...`)
+///   - Linux:   `$XDG_DATA_HOME/NowledgeGraph` (fallback `~/.local/share/...`)
+fn default_app_data_dir() -> Option<std::path::PathBuf> {
+    let home = std::env::var_os("HOME")
+        .or_else(|| std::env::var_os("USERPROFILE"))
+        .map(std::path::PathBuf::from)
+        .filter(|p| !p.as_os_str().is_empty())?;
+    Some(default_app_data_dir_from(&home))
+}
+
+/// Pure, testable core of [`default_app_data_dir`] (home injected).
+fn default_app_data_dir_from(home: &std::path::Path) -> std::path::PathBuf {
+    let base = if cfg!(target_os = "macos") {
+        home.join("Library").join("Application Support")
+    } else if cfg!(target_os = "windows") {
+        std::env::var_os("LOCALAPPDATA")
+            .map(std::path::PathBuf::from)
+            .filter(|p| !p.as_os_str().is_empty())
+            .unwrap_or_else(|| home.join("AppData").join("Local"))
+    } else {
+        std::env::var_os("XDG_DATA_HOME")
+            .map(std::path::PathBuf::from)
+            .filter(|p| !p.as_os_str().is_empty())
+            .unwrap_or_else(|| home.join(".local").join("share"))
+    };
+    base.join("NowledgeGraph")
+}
+
+/// The platform CONFIG dir `co.nowledge.mem.desktop` (app-settings / remote_llm /
+/// license / device files), mirroring the server's `app_desktop_dir` + Python's
+/// `get_app_config_dir`. `None` when home cannot be resolved.
+///   - macOS:   `~/Library/Application Support/co.nowledge.mem.desktop`
+///   - Windows: `%APPDATA%/co.nowledge.mem.desktop` (Roaming; fallback `~/AppData/Roaming`)
+///   - Linux:   `$XDG_CONFIG_HOME/co.nowledge.mem.desktop` (fallback `~/.config`)
+fn default_config_dir() -> Option<std::path::PathBuf> {
+    let home = std::env::var_os("HOME")
+        .or_else(|| std::env::var_os("USERPROFILE"))
+        .map(std::path::PathBuf::from)
+        .filter(|p| !p.as_os_str().is_empty())?;
+    let base = if cfg!(target_os = "macos") {
+        home.join("Library").join("Application Support")
+    } else if cfg!(target_os = "windows") {
+        std::env::var_os("APPDATA")
+            .map(std::path::PathBuf::from)
+            .filter(|p| !p.as_os_str().is_empty())
+            .unwrap_or_else(|| home.join("AppData").join("Roaming"))
+    } else {
+        std::env::var_os("XDG_CONFIG_HOME")
+            .map(std::path::PathBuf::from)
+            .filter(|p| !p.as_os_str().is_empty())
+            .unwrap_or_else(|| home.join(".config"))
+    };
+    Some(base.join("co.nowledge.mem.desktop"))
+}
+
+/// True when `host` is a loopback bind (the server only refuses an
+/// off-loopback, unauthenticated bind — loopback never needs the headless mark).
+fn host_is_loopback(host: &str) -> bool {
+    matches!(host, "127.0.0.1" | "localhost" | "::1" | "[::1]")
+        || host.starts_with("127.")
+        || host.eq_ignore_ascii_case("localhost")
+}
+
 #[cfg(test)]
 mod arg_tests {
     use super::*;
     use clap::Parser;
 
+    #[test]
+    fn default_app_data_dir_ends_in_nowledge_graph() {
+        let home = std::path::Path::new("/home/tester");
+        let dir = default_app_data_dir_from(home);
+        assert!(dir.ends_with("NowledgeGraph"), "must be the NowledgeGraph graph dir: {dir:?}");
+        assert!(dir.starts_with(home), "must hang off the given home: {dir:?}");
+    }
+
     #[test]
     fn parses_global_api_and_json() {
         let cli =

{nmem_cli-0.10.4 → nmem_cli-0.10.6}/pyproject.toml

@@ -13,7 +13,7 @@ build-backend = "maturin"
 
 [project]
 name = "nmem-cli"
-version = "0.10.4"
+version = "0.10.6"
 description = "CLI and TUI for Nowledge Mem - AI memory management"
 authors = [
     { name = "Nowledge Labs" },