Add SearXNG userspace runtime with DDG + Google engines

Bootstrap pattern mirrors node_runtime: fetch source tarball, pip-install
into a userspace venv on first boot, launch bound to 127.0.0.1:8888.
FastAPI bridge exposes /respite/v2/searx/search (JSON API proxy).

app.py

@@ -23,6 +23,8 @@ import json as _json
 
 import node_probe
 import node_runtime
+import searx_bridge
+import searx_runtime
 
 for _stream in (sys.stdout, sys.stderr):
     if hasattr(_stream, "reconfigure"):
@@ -874,6 +876,12 @@ def _patched_create_app(blocks, **kwargs):
     except Exception as _ne:
         _log(f"node probe registration failed: {_ne}")
 
+    try:
+        searx_bridge.register_routes(fa_app)
+        threading.Thread(target=searx_runtime.start_searxng, daemon=True).start()
+    except Exception as _se:
+        _log(f"searxng bridge registration failed: {_se}")
+
     _log("Routes injected via create_app monkey-patch")
     return fa_app
 

searx_bridge.py

@@ -0,0 +1,43 @@
+"""SearXNG bridge — runs a SearXNG metasearch instance inside the Space
+container (userspace venv, no root) and proxies queries to it.
+
+Mounted under /respite/v2/searx/*:
+  /status  → bootstrap state of the runtime
+  /search  → proxy ?q=... queries to SearXNG's JSON API
+
+Engine selection comes from searxng_settings.yml (DDG + Google enabled);
+the frontend picks engines per request via the standard `engines` param.
+"""
+
+import httpx
+from fastapi import Request
+from fastapi.responses import JSONResponse
+
+import searx_runtime
+
+
+def register_routes(fa_app):
+    @fa_app.get("/respite/v2/searx/status")
+    def _status():
+        return JSONResponse({
+            "runtime_dir": searx_runtime.RUNTIME_DIR,
+            "installed": searx_runtime.searxng_ready(),
+            "port": searx_runtime.SEARXNG_PORT,
+        })
+
+    @fa_app.get("/respite/v2/searx/search")
+    async def _search(request: Request):
+        if not searx_runtime.searxng_ready():
+            ok = searx_runtime.start_searxng()
+            if not ok:
+                return JSONResponse({"error": "searxng not running"}, status_code=503)
+        params = dict(request.query_params)
+        # SearXNG's JSON API lives at /search with format=json
+        params.setdefault("format", "json")
+        url = f"http://127.0.0.1:{searx_runtime.SEARXNG_PORT}/search"
+        try:
+            async with httpx.AsyncClient(timeout=httpx.Timeout(30.0, connect=5.0)) as client:
+                r = await client.get(url, params=params)
+                return JSONResponse(r.json(), status_code=r.status_code)
+        except Exception as e:
+            return JSONResponse({"error": str(e)}, status_code=502)

searx_runtime.py

@@ -0,0 +1,151 @@
+"""User-space SearXNG bootstrap for the Respite search backend.
+
+SearXNG is not on PyPI (the `searxng` package there is the abandoned
+pre-NG searx). Instead we fetch the upstream source tarball into a local
+cache, install it into a userspace virtualenv on first boot (no root),
+and launch the built-in development server bound to 127.0.0.1:8888.
+
+The instance is configured by searxng_settings.yml in the repo root
+(SEARXNG_SETTINGS_PATH points there), with the DDG + Google engines
+enabled and JSON output on.
+
+Env:
+  SEARXNG_VERSION  source tag/branch to fetch (default: master)
+  SEARXNG_PORT     localhost port (default 8888)
+  SEARXNG_OFF      set to "1" to skip the bootstrap entirely
+"""
+
+import os
+import shutil
+import subprocess
+import tarfile
+import threading
+import time
+import urllib.request
+
+SEARXNG_VERSION = os.environ.get("SEARXNG_VERSION", "master")
+SEARXNG_PORT = int(os.environ.get("SEARXNG_PORT", "8888"))
+SEARXNG_URL = f"https://github.com/searxng/searxng/archive/refs/heads/{SEARXNG_VERSION}.tar.gz"
+
+ROOT = os.path.dirname(os.path.abspath(__file__))
+RUNTIME_DIR = os.path.join(ROOT, ".searxng-runtime")
+SRC_DIR = os.path.join(RUNTIME_DIR, f"searxng-{SEARXNG_VERSION}")
+VENV_DIR = os.path.join(RUNTIME_DIR, "venv")
+VENV_PIP = os.path.join(VENV_DIR, "bin", "pip")
+SETTINGS_FILE = os.path.join(ROOT, "searxng_settings.yml")
+
+_proc = None
+_lock = threading.Lock()
+_ready = threading.Event()
+
+
+def _log(msg):
+    print(f"[searxng] {msg}", flush=True)
+
+
+def _fetch_source() -> bool:
+    if os.path.isdir(SRC_DIR) and os.path.exists(os.path.join(SRC_DIR, "searx", "webapp.py")):
+        return True
+    os.makedirs(RUNTIME_DIR, exist_ok=True)
+    tgz = os.path.join(RUNTIME_DIR, "searxng.tar.gz")
+    _log(f"downloading {SEARXNG_URL}")
+    urllib.request.urlretrieve(SEARXNG_URL, tgz)
+    _log("extracting")
+    with tarfile.open(tgz, "r:gz") as tf:
+        tf.extractall(RUNTIME_DIR)
+    os.remove(tgz)
+    return os.path.isdir(SRC_DIR)
+
+
+def _venv_python() -> str | None:
+    """Create the venv and install searxng + deps (idempotent)."""
+    py = os.path.join(VENV_DIR, "bin", "python")
+    if os.path.exists(py):
+        return py
+    _log("creating venv")
+    if subprocess.run(["python3", "-m", "venv", VENV_DIR], capture_output=True).returncode != 0:
+        _log("venv creation failed")
+        return None
+    _log("installing searxng deps (this takes a few minutes on first boot)")
+    r1 = subprocess.run(
+        [VENV_PIP, "install", "--no-input", "-r", os.path.join(SRC_DIR, "requirements.txt")],
+        capture_output=True, text=True, timeout=900,
+    )
+    if r1.returncode != 0:
+        _log(f"deps install failed: {r1.stderr[-2000:]}")
+        return None
+    r2 = subprocess.run(
+        [VENV_PIP, "install", "--no-input", "--no-deps", "-e", SRC_DIR],
+        capture_output=True, text=True, timeout=300,
+    )
+    if r2.returncode != 0:
+        _log(f"searxng install failed: {r2.stderr[-2000:]}")
+        return None
+    _log("searxng installed")
+    return py
+
+
+def _wait_ready(proc: subprocess.Popen, timeout: float = 120.0) -> bool:
+    import socket
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        if proc.poll() is not None:
+            _log(f"searxng exited early with code {proc.returncode}")
+            return False
+        try:
+            with socket.create_connection(("127.0.0.1", SEARXNG_PORT), timeout=1):
+                return True
+        except OSError:
+            time.sleep(0.5)
+    return False
+
+
+def start_searxng() -> bool:
+    """Launch SearXNG bound to localhost. Safe to call once at startup."""
+    global _proc
+    if os.environ.get("SEARXNG_OFF") == "1":
+        _log("disabled via SEARXNG_OFF")
+        return False
+    with _lock:
+        if _proc and _proc.poll() is None:
+            return True
+        try:
+            if not _fetch_source():
+                _log("source fetch failed")
+                return False
+            py = _venv_python()
+            if not py:
+                return False
+        except Exception as e:
+            _log(f"bootstrap failed: {e}")
+            return False
+        env = os.environ.copy()
+        env["SEARXNG_SETTINGS_PATH"] = SETTINGS_FILE
+        env["PYTHONPATH"] = SRC_DIR
+        _log(f"starting searxng on 127.0.0.1:{SEARXNG_PORT}")
+        _proc = subprocess.Popen(
+            [py, "-m", "searx.webapp"],
+            cwd=SRC_DIR,
+            env=env,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+        )
+        threading.Thread(target=_pump_logs, daemon=True).start()
+        if _wait_ready(_proc):
+            _log("searxng is READY")
+            _ready.set()
+            return True
+        _log("searxng failed to become ready")
+        return False
+
+
+def _pump_logs():
+    assert _proc and _proc.stdout
+    for line in _proc.stdout:
+        _log(line.rstrip())
+
+
+def searxng_ready() -> bool:
+    return _ready.is_set()