Add Node runtime capability probe (userspace, no root)

- node_runtime.py: downloads official Node tarball to local cache, starts
the Next.js standalone backend on 127.0.0.1:3210 as a child process
- node_probe.py: /respite/v2/node/{status,version,server,proxy} routes to
prove bootstrap, child exec, localhost HTTP, and reverse-proxying
- app.py: wire probe routes into the monkey-patched create_app
- drop committed __pycache__ noise

.gitignore

@@ -0,0 +1 @@
+__pycache__/

app.py

@@ -21,6 +21,9 @@ import urllib.request
 import urllib.parse
 import json as _json
 
+import node_probe
+import node_runtime
+
 for _stream in (sys.stdout, sys.stderr):
     if hasattr(_stream, "reconfigure"):
         _stream.reconfigure(encoding="utf-8", errors="backslashreplace")
@@ -864,6 +867,13 @@ def _patched_create_app(blocks, **kwargs):
         job = _start_benchmark_job("benchmark", model.strip() or None, force)
         return JSONResponse({"status": "accepted", "job_id": job, "poll": "/respite/benchmark?job_id=" + job}, status_code=202)
 
+    # Node runtime capability probe + backend proxy
+    try:
+        node_probe.register_routes(fa_app)
+        threading.Thread(target=node_runtime.start_node_backend, daemon=True).start()
+    except Exception as _ne:
+        _log(f"node probe registration failed: {_ne}")
+
     _log("Routes injected via create_app monkey-patch")
     return fa_app
 

node_probe.py

@@ -0,0 +1,99 @@
+"""Minimal Node capability probe — proves the runtime works inside the Space.
+
+Mounted under /respite/v2/node/*:
+  /status  → is the runtime bootstrapped, is the child alive
+  /version → runs `node --version` as a child process
+  /server  → start a trivial Node HTTP server on localhost, then GET it
+  /proxy   → reverse-proxy any /respite/v2/node/proxy/<path> to the Node server
+"""
+
+import json
+import os
+import subprocess
+import threading
+import time
+import urllib.request
+
+import httpx
+from fastapi.responses import JSONResponse, Response
+
+import node_runtime
+
+_TRIVIAL_SERVER_JS = """const http = require('http');
+const s = http.createServer((req, res) => {
+  res.writeHead(200, {'content-type': 'application/json'});
+  res.end(JSON.stringify({ok: true, url: req.url, ts: Date.now()}));
+});
+s.listen(3211, '127.0.0.1', () => console.log('trivial server on 3211'));
+"""
+_trivial_proc = None
+_trivial_lock = threading.Lock()
+
+
+def _node_path() -> str | None:
+    try:
+        return node_runtime.ensure_node()
+    except Exception:
+        return None
+
+
+def register_routes(fa_app):
+    @fa_app.get("/respite/v2/node/status")
+    def _status():
+        return JSONResponse({
+            "runtime_dir": node_runtime.RUNTIME_DIR,
+            "node_bin_exists": os.path.exists(node_runtime.NODE_BIN),
+            "backend_ready": node_runtime.node_ready(),
+            "backend_dir": node_runtime.BACKEND_DIR,
+        })
+
+    @fa_app.get("/respite/v2/node/version")
+    def _version():
+        node = _node_path()
+        if not node:
+            return JSONResponse({"error": "node bootstrap failed"}, status_code=500)
+        r = subprocess.run([node, "--version"], capture_output=True, text=True, timeout=30)
+        return JSONResponse({"stdout": r.stdout.strip(), "stderr": r.stderr.strip()[:400], "code": r.returncode})
+
+    @fa_app.get("/respite/v2/node/server")
+    def _server():
+        """Start a trivial Node HTTP server on 127.0.0.1:3211 and fetch it."""
+        global _trivial_proc
+        node = _node_path()
+        if not node:
+            return JSONResponse({"error": "node bootstrap failed"}, status_code=500)
+        with _trivial_lock:
+            if _trivial_proc is None or _trivial_proc.poll() is not None:
+                path = os.path.join(node_runtime.RUNTIME_DIR, "trivial.js")
+                os.makedirs(node_runtime.RUNTIME_DIR, exist_ok=True)
+                with open(path, "w") as f:
+                    f.write(_TRIVIAL_SERVER_JS)
+                _trivial_proc = subprocess.Popen(
+                    [node, path], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True
+                )
+                time.sleep(1.5)
+        try:
+            with urllib.request.urlopen("http://127.0.0.1:3211/ping", timeout=5) as resp:
+                body = json.loads(resp.read().decode())
+            return JSONResponse({"fetch_ok": True, "body": body})
+        except Exception as e:
+            return JSONResponse({"fetch_ok": False, "error": str(e)}, status_code=500)
+
+    @fa_app.get("/respite/v2/node/proxy/{path:path}")
+    @fa_app.post("/respite/v2/node/proxy/{path:path}")
+    def _proxy(path: str):
+        """Forward to the Node backend on 127.0.0.1:3210 (streaming)."""
+        if not node_runtime.node_ready():
+            start_ok = node_runtime.start_node_backend()
+            if not start_ok:
+                return JSONResponse({"error": "node backend not running"}, status_code=503)
+        url = f"http://127.0.0.1:{node_runtime.NODE_PORT}/{path}"
+        try:
+            with httpx.stream("GET", url, timeout=30.0) as r:
+                headers = dict(r.headers)
+                body = b""
+                for chunk in r.iter_bytes():
+                    body += chunk
+            return Response(content=body, status_code=r.status_code, headers=headers)
+        except Exception as e:
+            return JSONResponse({"error": str(e)}, status_code=502)

node_runtime.py

@@ -0,0 +1,128 @@
+"""User-space Node.js runtime bootstrap for the Respite backend.
+
+Runs the existing Next.js backend inside the Gradio Space container without
+root: downloads an official self-contained Node tarball to a local cache,
+extracts it, and launches the Next.js standalone server as a child process
+bound to localhost. The FastAPI layer reverse-proxies /api/* to it.
+
+Env:
+  NODE_VERSION   Node version to fetch (default 22.14.0 LTS)
+  NEXT_PORT      localhost port for the Node server (default 3210)
+  NEXT_DIR       directory of the standalone build (default ./respite-backend)
+  NODE_PROXY_OFF  set to "1" to skip the download/proxy entirely
+"""
+
+import os
+import shutil
+import subprocess
+import tarfile
+import threading
+import urllib.request
+
+BACKEND_DIR = os.environ.get("NEXT_DIR", os.path.join(os.path.dirname(os.path.abspath(__file__)), "respite-backend"))
+NODE_VERSION = os.environ.get("NODE_VERSION", "22.14.0")
+NODE_PORT = int(os.environ.get("NEXT_PORT", "3210"))
+
+NODE_TARBALL = f"https://nodejs.org/dist/v{NODE_VERSION}/node-v{NODE_VERSION}-linux-x64.tar.xz"
+RUNTIME_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), ".node-runtime")
+NODE_BIN = os.path.join(RUNTIME_DIR, f"node-v{NODE_VERSION}-linux-x64", "bin", "node")
+
+_node_proc = None
+_node_lock = threading.Lock()
+_node_ready = threading.Event()
+
+
+def _log(msg):
+    print(f"[node-runtime] {msg}", flush=True)
+
+
+def ensure_node() -> str:
+    """Download + extract Node into the local cache once. Returns node path."""
+    if os.path.exists(NODE_BIN):
+        return NODE_BIN
+    os.makedirs(RUNTIME_DIR, exist_ok=True)
+    tgz = os.path.join(RUNTIME_DIR, "node.tar.xz")
+    _log(f"downloading {NODE_TARBALL}")
+    urllib.request.urlretrieve(NODE_TARBALL, tgz)
+    _log("extracting")
+    with tarfile.open(tgz, "r:xz") as tf:
+        tf.extractall(RUNTIME_DIR)
+    os.remove(tgz)
+    os.chmod(NODE_BIN, 0o755)
+    _log(f"node ready at {NODE_BIN}")
+    return NODE_BIN
+
+
+def _wait_ready(proc: subprocess.Popen, timeout: float = 90.0) -> bool:
+    """Wait until the Node server answers on its localhost port."""
+    import socket
+    import time
+
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        if proc.poll() is not None:
+            _log(f"node exited early with code {proc.returncode}")
+            return False
+        try:
+            with socket.create_connection(("127.0.0.1", NODE_PORT), timeout=1):
+                return True
+        except OSError:
+            time.sleep(0.5)
+    return False
+
+
+def start_node_backend() -> bool:
+    """Launch the Next.js standalone server. Safe to call once at startup."""
+    global _node_proc
+    if os.environ.get("NODE_PROXY_OFF") == "1":
+        _log("disabled via NODE_PROXY_OFF")
+        return False
+    if not os.path.isdir(BACKEND_DIR):
+        _log(f"backend dir missing: {BACKEND_DIR}")
+        return False
+    with _node_lock:
+        if _node_proc and _node_proc.poll() is None:
+            return True
+        try:
+            node = ensure_node()
+        except Exception as e:
+            _log(f"node bootstrap failed: {e}")
+            return False
+        server_js = os.path.join(BACKEND_DIR, "server.js")
+        if not os.path.exists(server_js):
+            _log(f"no server.js in {BACKEND_DIR}")
+            return False
+        env = os.environ.copy()
+        env.update({
+            "PORT": str(NODE_PORT),
+            "HOSTNAME": "127.0.0.1",
+            "NODE_ENV": "production",
+        })
+        _log(f"starting node server on 127.0.0.1:{NODE_PORT}")
+        _node_proc = subprocess.Popen(
+            [node, server_js],
+            cwd=BACKEND_DIR,
+            env=env,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+        )
+        threading.Thread(target=_pump_logs, daemon=True).start()
+        ok = _wait_ready(_node_proc)
+        if ok:
+            _log("node backend is READY")
+            _node_ready.set()
+        else:
+            _log("node backend failed to become ready")
+        return ok
+
+
+def _pump_logs():
+    assert _node_proc and _node_proc.stdout
+    for line in _node_proc.stdout:
+        _log(f"[next] {line.rstrip()}")
+
+
+def node_ready() -> bool:
+    return _node_ready.is_set() and _node_proc is not None and _node_proc.poll() is None

requirements.txt

@@ -9,3 +9,4 @@ git+https://github.com/Stability-AI/stable-audio-3.git
 ddgs
 transformers>=4.51.0
 accelerate>=1.6.0
+httpx