OpenJarvis 0.1.2.dev754__tar.gz → 0.1.2.dev756__tar.gz

{openjarvis-0.1.2.dev754 → openjarvis-0.1.2.dev756}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenJarvis
-Version: 0.1.2.dev754
+Version: 0.1.2.dev756
 Summary: OpenJarvis — modular AI assistant backend with composable intelligence primitives
 Project-URL: Homepage, https://github.com/open-jarvis/OpenJarvis
 Project-URL: Documentation, https://open-jarvis.github.io/OpenJarvis/

{openjarvis-0.1.2.dev754 → openjarvis-0.1.2.dev756}/frontend/src-tauri/src/lib.rs

@@ -291,10 +291,29 @@ impl ChildHandle {
     }
 }
 
-#[derive(Default)]
+/// Rolling buffer holding the most recent ~16 KB of jarvis stderr.
+///
+/// Populated by a background drainer task spawned at boot so the pipe
+/// never fills and back-pressures `jarvis serve`; consumed by the boot
+/// path when surfacing failure messages.
+type StderrTail = Arc<Mutex<Vec<u8>>>;
+
+const STDERR_TAIL_LIMIT: usize = 16 * 1024;
+
 struct BackendManager {
     ollama: Option<ChildHandle>,
     jarvis: Option<ChildHandle>,
+    jarvis_stderr_tail: StderrTail,
+}
+
+impl Default for BackendManager {
+    fn default() -> Self {
+        Self {
+            ollama: None,
+            jarvis: None,
+            jarvis_stderr_tail: Arc::new(Mutex::new(Vec::new())),
+        }
+    }
 }
 
 impl BackendManager {
@@ -362,6 +381,134 @@ async fn wait_for_url(url: &str, timeout: Duration) -> bool {
     false
 }
 
+/// Outcome of waiting for `jarvis serve` to become healthy.
+///
+/// Unlike [`wait_for_url`] this differentiates "server is up but degraded"
+/// (HTTP 503 — usually inference engine failed to load) from "server never
+/// came up" and from "child process died before serving anything", because
+/// each needs a different user-facing message.
+#[derive(Debug)]
+enum JarvisStartResult {
+    /// `/health` returned 2xx.
+    Ready,
+    /// Server replied 503. The body is the actionable message (typically
+    /// "engine not ready" or a model-load error).
+    ServiceUnavailable(String),
+    /// The `jarvis serve` child exited before `/health` returned 2xx.
+    EarlyExit { code: Option<i32>, stderr: String },
+    /// Deadline elapsed without ever seeing 2xx or an early exit.
+    Timeout,
+}
+
+/// Spawn a detached task that continuously drains `jarvis serve`'s
+/// stderr into a rolling tail buffer.
+///
+/// We MUST keep reading stderr for as long as the child runs — `jarvis
+/// serve` is chatty (engine load progress, request logs), and the OS
+/// pipe buffer is small (4 KB on Windows, 64 KB on Linux). Once full,
+/// the child's next stderr write blocks indefinitely and the server
+/// hangs mid-operation. The drainer reads in chunks and keeps only the
+/// last `STDERR_TAIL_LIMIT` bytes — enough to surface a tail trace if
+/// the child later dies, without unbounded memory growth.
+///
+/// Returns immediately after spawning the task; the task ends naturally
+/// when the child closes stderr (i.e. exits).
+fn spawn_jarvis_stderr_drainer(mut stderr: tokio::process::ChildStderr, tail: StderrTail) {
+    use tokio::io::AsyncReadExt;
+    tokio::spawn(async move {
+        let mut buf = vec![0u8; 4096];
+        loop {
+            match stderr.read(&mut buf).await {
+                Ok(0) => break,  // EOF — child closed stderr
+                Err(_) => break, // pipe broke — also done
+                Ok(n) => {
+                    let mut t = tail.lock().await;
+                    t.extend_from_slice(&buf[..n]);
+                    if t.len() > STDERR_TAIL_LIMIT {
+                        let drop_n = t.len() - STDERR_TAIL_LIMIT;
+                        t.drain(..drop_n);
+                    }
+                }
+            }
+        }
+    });
+}
+
+/// Read whatever the stderr drainer has buffered so far.
+///
+/// Safe to call at any time; returns an empty string before the
+/// drainer has seen any bytes. Trimmed.
+async fn read_jarvis_stderr_tail(backend: &SharedBackend) -> String {
+    let tail = backend.lock().await.jarvis_stderr_tail.clone();
+    let bytes = tail.lock().await.clone();
+    String::from_utf8_lossy(&bytes).trim().to_string()
+}
+
+/// Poll `jarvis serve` health, watching the child process state so we
+/// never wait 10 minutes for a process that crashed in the first second.
+async fn wait_for_jarvis_health(
+    url: &str,
+    timeout: Duration,
+    backend: &SharedBackend,
+) -> JarvisStartResult {
+    let client = match reqwest::Client::builder()
+        .timeout(Duration::from_secs(2))
+        .build()
+    {
+        Ok(c) => c,
+        Err(_) => return JarvisStartResult::Timeout,
+    };
+    let deadline = tokio::time::Instant::now() + timeout;
+    loop {
+        // 1. Has the child already exited? `try_wait` is non-blocking; on
+        // Windows where uv / python / the Rust extension can fail to load
+        // very fast, this catches the crash within ~500ms instead of after
+        // the full HTTP timeout window.
+        let exit_status = {
+            let mut mgr = backend.lock().await;
+            match mgr.jarvis.as_mut() {
+                Some(h) => h.child.try_wait().ok().flatten(),
+                None => None,
+            }
+        };
+        if let Some(status) = exit_status {
+            let stderr = read_jarvis_stderr_tail(backend).await;
+            return JarvisStartResult::EarlyExit {
+                code: status.code(),
+                stderr,
+            };
+        }
+
+        // 2. Try the health endpoint.
+        match client.get(url).send().await {
+            Ok(resp) => {
+                let status = resp.status();
+                if status.is_success() {
+                    return JarvisStartResult::Ready;
+                }
+                if status == reqwest::StatusCode::SERVICE_UNAVAILABLE {
+                    // Server is up but the inference engine is not. This
+                    // is a terminal-for-us state — polling won't change
+                    // anything; the user has to fix their engine config.
+                    let body = resp.text().await.unwrap_or_default();
+                    return JarvisStartResult::ServiceUnavailable(body);
+                }
+                // Other non-2xx (e.g. 404 during a brief routing-table
+                // warmup window) — fall through and keep polling.
+            }
+            Err(_) => {
+                // Connection refused / DNS / timeout — server still
+                // booting. Keep polling.
+            }
+        }
+
+        if tokio::time::Instant::now() >= deadline {
+            return JarvisStartResult::Timeout;
+        }
+        tokio::time::sleep(Duration::from_millis(500)).await;
+    }
+}
+
 async fn ollama_has_model(model: &str) -> bool {
     let url = format!("http://127.0.0.1:{}/api/tags", OLLAMA_PORT);
     let client = reqwest::Client::builder()
@@ -790,8 +937,19 @@ async fn boot_backend(backend: SharedBackend, status: SharedStatus) {
     let jarvis_child = cmd.spawn();
 
     match jarvis_child {
-        Ok(child) => {
-            backend.lock().await.jarvis = Some(ChildHandle { child });
+        Ok(mut child) => {
+            // Start draining stderr immediately. If we wait until the
+            // health check returns we risk filling the 4 KB Windows pipe
+            // buffer during startup logging and hanging the child before
+            // it can bind its HTTP port — exactly the symptom in #309.
+            let stderr_handle = child.stderr.take();
+            let mut mgr = backend.lock().await;
+            let tail = mgr.jarvis_stderr_tail.clone();
+            mgr.jarvis = Some(ChildHandle { child });
+            drop(mgr);
+            if let Some(stderr) = stderr_handle {
+                spawn_jarvis_stderr_drainer(stderr, tail);
+            }
         }
         Err(e) => {
             let mut s = status.lock().await;
@@ -806,38 +964,71 @@ async fn boot_backend(backend: SharedBackend, status: SharedStatus) {
     }
 
     let server_url = format!("http://127.0.0.1:{}/health", JARVIS_PORT);
-    let server_ok = wait_for_url(&server_url, Duration::from_secs(600)).await;
-
-    if !server_ok {
-        // Try to read stderr from the failed process for a useful error
-        let mut stderr_msg = String::new();
-        {
-            let mut mgr = backend.lock().await;
-            if let Some(ref mut h) = mgr.jarvis {
-                if let Some(ref mut stderr) = h.child.stderr.take() {
-                    use tokio::io::AsyncReadExt;
-                    let mut buf = vec![0u8; 4096];
-                    if let Ok(n) = stderr.read(&mut buf).await {
-                        stderr_msg = String::from_utf8_lossy(&buf[..n]).to_string();
-                    }
-                }
-            }
-        }
-        let detail = if stderr_msg.is_empty() {
-            format!(
-                "Jarvis server did not start. Check that:\n\
-                 1. uv is installed ({})\n\
-                 2. The OpenJarvis repo is at {}\n\
-                 3. Run 'uv sync' in that directory",
-                uv_bin,
+    match wait_for_jarvis_health(&server_url, Duration::from_secs(600), &backend).await {
+        JarvisStartResult::Ready => {}
+        JarvisStartResult::ServiceUnavailable(body) => {
+            let mut s = status.lock().await;
+            s.error = Some(format!(
+                "Jarvis server is running but the inference engine is not available \
+                 (HTTP 503). This usually means the configured model couldn't be loaded.\n\n\
+                 Check the server logs, or run 'uv run jarvis serve --port {} --model {}' \
+                 from {} to see the engine error.\n\n\
+                 Server response:\n{}",
+                JARVIS_PORT,
+                startup_model,
                 root.display(),
-            )
-        } else {
-            format!("Server failed to start: {}", stderr_msg.trim())
-        };
-        let mut s = status.lock().await;
-        s.error = Some(detail);
-        return;
+                body.trim(),
+            ));
+            return;
+        }
+        JarvisStartResult::EarlyExit { code, stderr } => {
+            // `None` here means the OS didn't expose an exit code — on
+            // Unix that's a signal kill (SIGKILL/SIGSEGV/...), on Windows
+            // it means the process was terminated externally (Task
+            // Manager, parent-of-parent, AV). "unknown" covers both.
+            let code_str = code
+                .map(|c| c.to_string())
+                .unwrap_or_else(|| "unknown".into());
+            let mut s = status.lock().await;
+            s.error = Some(if stderr.is_empty() {
+                format!(
+                    "Jarvis server exited (code {}) before becoming ready.\n\n\
+                     No stderr output. Check that:\n\
+                     1. uv is installed ({})\n\
+                     2. The OpenJarvis repo is at {}\n\
+                     3. 'uv sync' completes in that directory",
+                    code_str,
+                    uv_bin,
+                    root.display(),
+                )
+            } else {
+                format!(
+                    "Jarvis server exited (code {}) before becoming ready.\n\nStderr:\n{}",
+                    code_str, stderr,
+                )
+            });
+            return;
+        }
+        JarvisStartResult::Timeout => {
+            let stderr = read_jarvis_stderr_tail(&backend).await;
+            let mut s = status.lock().await;
+            s.error = Some(if stderr.is_empty() {
+                format!(
+                    "Jarvis server did not become ready within 10 minutes. Check that:\n\
+                     1. uv is installed ({})\n\
+                     2. The OpenJarvis repo is at {}\n\
+                     3. Run 'uv sync' in that directory",
+                    uv_bin,
+                    root.display(),
+                )
+            } else {
+                format!(
+                    "Jarvis server did not become ready within 10 minutes.\n\nStderr:\n{}",
+                    stderr,
+                )
+            });
+            return;
+        }
     }
 
     {

{openjarvis-0.1.2.dev754 → openjarvis-0.1.2.dev756}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "OpenJarvis"
-version = "0.1.2.dev754"
+version = "0.1.2.dev756"
 description = "OpenJarvis — modular AI assistant backend with composable intelligence primitives"
 readme = "README.md"
 # Upper bound: numpy 2.2.x (pinned transitively via datasets/pandas) ships no

{openjarvis-0.1.2.dev754 → openjarvis-0.1.2.dev756}/scripts/install/install.sh

@@ -90,6 +90,18 @@ EOF
 need git
 need curl
 
+# ---- python command ----
+# Prefer `python3` (Linux / macOS / WSL convention); fall back to `python`
+# on minimal distros that only ship the unversioned name. This is used by
+# the analytics beacon and state-file helpers below — uv installs its own
+# interpreter into the venv later, so this is only for the bootstrap shims.
+PY_CMD="python3"
+if ! command -v python3 >/dev/null 2>&1; then
+    if command -v python >/dev/null 2>&1; then
+        PY_CMD="python"
+    fi
+fi
+
 # ---- env ----
 OPENJARVIS_HOME="${OPENJARVIS_HOME:-$HOME/.openjarvis}"
 OPENJARVIS_REPO_URL="${OPENJARVIS_REPO_URL:-https://github.com/open-jarvis/OpenJarvis.git}"
@@ -148,7 +160,7 @@ get_anon_id() {
         return
     fi
     local new_id
-    new_id="$(python3 -c 'import uuid; print(uuid.uuid4())' 2>/dev/null || echo "")"
+    new_id="$("$PY_CMD" -c 'import uuid; print(uuid.uuid4())' 2>/dev/null || echo "")"
     if [[ -z "$new_id" ]]; then
         return
     fi
@@ -189,7 +201,7 @@ beacon() {
     os="$(detect_os)"
     arch="$(detect_arch)"
 
-    python3 - "$ANALYTICS_HOST" "$ANALYTICS_KEY" "$event" "$anon_id" \
+    "$PY_CMD" - "$ANALYTICS_HOST" "$ANALYTICS_KEY" "$event" "$anon_id" \
         "$os" "$arch" "$stage" "$elapsed_ms" "$exit_code" \
         >/dev/null 2>&1 <<'PYEOF' || true
 import json
@@ -251,7 +263,7 @@ mark_done() {
     if [[ ! -f "$STATE_FILE" ]]; then
         echo '{}' > "$STATE_FILE"
     fi
-    python3 - "$STATE_FILE" "$1" "$WSL" <<'PYEOF'
+    "$PY_CMD" - "$STATE_FILE" "$1" "$WSL" <<'PYEOF'
 import json, sys
 path, key, wsl = sys.argv[1], sys.argv[2], sys.argv[3]
 with open(path) as f:

{openjarvis-0.1.2.dev754 → openjarvis-0.1.2.dev756}/scripts/oauth_all.py

@@ -11,7 +11,6 @@ from __future__ import annotations
 import argparse
 import json
 import os
-import webbrowser
 from http.server import BaseHTTPRequestHandler, HTTPServer
 from pathlib import Path
 from typing import Any, Dict, List
@@ -19,6 +18,8 @@ from urllib.parse import parse_qs, urlencode, urlparse
 
 import httpx
 
+from openjarvis.core import open_browser
+
 CONFIG_DIR = Path.home() / ".openjarvis" / "connectors"
 CONFIG_DIR.mkdir(parents=True, exist_ok=True)
 
@@ -144,7 +145,7 @@ def do_google() -> None:
         })
     )
     print("  Opening browser...")
-    webbrowser.open(url)
+    open_browser(url)
     code = _wait_for_code()
 
     resp = httpx.post(
@@ -192,7 +193,7 @@ def do_strava() -> None:
         })
     )
     print("  Opening browser...")
-    webbrowser.open(url)
+    open_browser(url)
     code = _wait_for_code()
 
     resp = httpx.post(
@@ -303,7 +304,7 @@ def do_spotify() -> None:
         })
     )
     print("  Opening browser...")
-    webbrowser.open(url)
+    open_browser(url)
     code = _wait_for_code(port=spotify_port)
 
     import base64

{openjarvis-0.1.2.dev754 → openjarvis-0.1.2.dev756}/scripts/quickstart.sh

@@ -47,19 +47,24 @@ echo "  └───────────────────────
 echo -e "${NC}"
 
 # ── 1. Check Python ──────────────────────────────────────────────────
+# Prefer python3, fall back to python (Windows / minimal distros that ship
+# only the unversioned name).
 info "Checking Python..."
 if command -v python3 &>/dev/null; then
-  PY_VERSION=$(python3 -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')")
-  PY_MAJOR=$(echo "$PY_VERSION" | cut -d. -f1)
-  PY_MINOR=$(echo "$PY_VERSION" | cut -d. -f2)
-  if [ "$PY_MAJOR" -ge 3 ] && [ "$PY_MINOR" -ge 10 ]; then
-    ok "Python $PY_VERSION"
-  else
-    fail "Python 3.10+ required (found $PY_VERSION)"
-  fi
+  PY_CMD="python3"
+elif command -v python &>/dev/null; then
+  PY_CMD="python"
 else
   fail "Python 3 not found. Install from https://python.org"
 fi
+PY_VERSION=$("$PY_CMD" -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')")
+PY_MAJOR=$(echo "$PY_VERSION" | cut -d. -f1)
+PY_MINOR=$(echo "$PY_VERSION" | cut -d. -f2)
+if [ "$PY_MAJOR" -ge 3 ] && [ "$PY_MINOR" -ge 10 ]; then
+  ok "Python $PY_VERSION ($PY_CMD)"
+else
+  fail "Python 3.10+ required (found $PY_VERSION)"
+fi
 
 # ── 2. Check / install uv ───────────────────────────────────────────
 info "Checking uv..."
@@ -182,6 +187,7 @@ info "Opening $URL ..."
 case "$(uname -s)" in
   Darwin) open "$URL" ;;
   Linux)  xdg-open "$URL" 2>/dev/null || true ;;
+  MINGW*|MSYS*|CYGWIN*) cmd /c start "" "$URL" 2>/dev/null || true ;;
   *)      true ;;
 esac
 

{openjarvis-0.1.2.dev754 → openjarvis-0.1.2.dev756}/src/openjarvis/connectors/oauth.py

@@ -16,6 +16,7 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 from urllib.parse import urlencode
 
+from openjarvis.core import open_browser
 from openjarvis.core.config import DEFAULT_CONFIG_DIR
 
 # ---------------------------------------------------------------------------
@@ -419,7 +420,6 @@ def run_oauth_flow(
     RuntimeError
         If the user denies authorization or the callback times out.
     """
-    import webbrowser
     from http.server import BaseHTTPRequestHandler, HTTPServer
     from urllib.parse import parse_qs, urlparse
 
@@ -492,7 +492,7 @@ def run_oauth_flow(
     server.timeout = 120  # 2 minute timeout
 
     # Open the consent page in the user's default browser
-    webbrowser.open(auth_url)
+    open_browser(auth_url)
 
     # Wait for the callback (blocking, with per-request timeout)
     while not auth_code and not error:
@@ -661,7 +661,6 @@ def run_connector_oauth(
 
     Returns the raw token response dict.
     """
-    import webbrowser
 
     provider = get_provider_for_connector(connector_id)
     if provider is None:
@@ -694,7 +693,7 @@ def run_connector_oauth(
     auth_url = f"{provider.auth_endpoint}?{urlencode(params)}"
 
     # Open browser and wait for callback
-    webbrowser.open(auth_url)
+    open_browser(auth_url)
     code = _wait_for_callback_code(
         host=provider.callback_host,
         port=provider.callback_port,

{openjarvis-0.1.2.dev754 → openjarvis-0.1.2.dev756}/src/openjarvis/core/__init__.py

@@ -19,6 +19,7 @@ from openjarvis.core.types import (
     ToolCall,
     ToolResult,
 )
+from openjarvis.core.utils import get_python_executable, open_browser
 
 __all__ = [
     "AgentRegistry",
@@ -34,4 +35,6 @@ __all__ = [
     "ToolCall",
     "ToolRegistry",
     "ToolResult",
+    "get_python_executable",
+    "open_browser",
 ]

openjarvis-0.1.2.dev756/src/openjarvis/core/utils.py

@@ -0,0 +1,52 @@
+"""Small cross-platform utilities used by the CLI, OAuth flow, and evals.
+
+Kept dependency-free so importing this module is cheap (the public re-export
+from ``openjarvis.core`` must not pull in heavy modules at package init).
+"""
+
+from __future__ import annotations
+
+import platform
+import shutil
+import subprocess
+import webbrowser
+
+
+def get_python_executable() -> str:
+    """Return the best ``python`` interpreter name on PATH.
+
+    Prefers ``python3`` (Linux/macOS convention); falls back to ``python``
+    (Windows / some minimal Linux distros that ship only ``python``). Returns
+    the literal string ``"python3"`` when neither is found, so callers still
+    get a usable command that will fail with a clear "command not found"
+    rather than an empty string.
+
+    The result is a *command name or absolute path* that callers can hand to
+    :mod:`subprocess` directly when ``shell=False``, and must be shell-quoted
+    (:func:`shlex.quote`) before being interpolated into a ``shell=True``
+    command string — paths on Windows often contain spaces.
+    """
+    return shutil.which("python3") or shutil.which("python") or "python3"
+
+
+def open_browser(url: str) -> None:
+    """Open *url* in the user's default browser, with a Windows fast-path.
+
+    :func:`webbrowser.open` is the cross-platform default, but on Windows it
+    sometimes blocks or fails inside a console host. ``cmd /c start "" "URL"``
+    is the canonical Windows incantation that hands the URL to the OS shell
+    and returns immediately. We try that first on Windows and fall back to
+    :func:`webbrowser.open` if the subprocess spawn fails.
+    """
+    if platform.system() == "Windows":
+        try:
+            # The empty title argument after ``start`` is required: ``start``
+            # treats a single quoted argument as a window title, not a URL.
+            subprocess.run(["cmd", "/c", "start", "", url], check=False)
+            return
+        except Exception:  # noqa: BLE001 - any spawn failure -> fall back
+            pass
+    webbrowser.open(url)
+
+
+__all__ = ["get_python_executable", "open_browser"]

{openjarvis-0.1.2.dev754 → openjarvis-0.1.2.dev756}/src/openjarvis/evals/scorers/livecodebench.py

@@ -16,6 +16,7 @@ import subprocess
 import tempfile
 from typing import Any, Dict, List, Optional, Tuple
 
+from openjarvis.core import get_python_executable
 from openjarvis.evals.core.scorer import Scorer
 from openjarvis.evals.core.types import EvalRecord
 
@@ -90,7 +91,7 @@ def _run_single_test(
 
     try:
         result = subprocess.run(
-            ["python3", script_path],
+            [get_python_executable(), script_path],
             input=test_input,
             capture_output=True,
             text=True,

{openjarvis-0.1.2.dev754 → openjarvis-0.1.2.dev756}/tests/security/test_subprocess_sandbox.py

@@ -3,8 +3,10 @@
 from __future__ import annotations
 
 import os
+import shlex
 import tempfile
 
+from openjarvis.core import get_python_executable
 from openjarvis.security.subprocess_sandbox import (
     build_safe_env,
     kill_process_tree,
@@ -97,7 +99,7 @@ class TestRunSandboxed:
     def test_output_truncation(self) -> None:
         # Generate output larger than max_output_bytes
         result = run_sandboxed(
-            "python3 -c \"print('A' * 200)\"",
+            f"{shlex.quote(get_python_executable())} -c \"print('A' * 200)\"",
             timeout=10.0,
             max_output_bytes=50,
         )

{openjarvis-0.1.2.dev754 → openjarvis-0.1.2.dev756}/tests/tools/test_shell_exec.py

@@ -9,11 +9,13 @@ from __future__ import annotations
 
 import importlib
 import os
+import shlex
 import sys
 from unittest.mock import MagicMock, patch
 
 import pytest
 
+from openjarvis.core import get_python_executable
 from openjarvis.tools.shell_exec import ShellExecTool
 
 
@@ -216,7 +218,10 @@ class TestShellExecTool:
         """Stdout exceeding 100 KB is truncated."""
         tool = ShellExecTool()
         result = tool.execute(
-            command="python3 -c \"print('A' * 200000)\"",
+            command=(
+                f"{shlex.quote(get_python_executable())} "
+                "-c \"print('A' * 200000)\""
+            ),
         )
         assert "truncated" in result.content
         assert len(result.content) < 200_000