superbrain-server 1.0.6 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superbrain-server",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "1-Line Auto-Installer and Server Execution wrapper for SuperBrain",
   "main": "index.js",
   "bin": {

package/payload/start.py

@@ -666,7 +666,7 @@ LOCALTUNNEL_ENABLED = BASE_DIR / "config" / "localtunnel_enabled.txt"
 LOCALTUNNEL_LOG = BASE_DIR / "config" / "localtunnel.log"
 
 def setup_remote_access():
-    h1("Step 6 of 7 — Remote Access (localtunnel / Port Forwarding)")
+    h1("Step 6 of 7 — Remote Access (localhost.run / Port Forwarding)")
 
     print(f"""
   The SuperBrain backend runs on {BOLD}port 5000{RESET} on your machine.
@@ -674,10 +674,10 @@ def setup_remote_access():
 
   You have two options:
 
-    {BOLD}Option A — localtunnel (easiest + free){RESET}
-        localtunnel creates a public HTTPS URL that tunnels to your local port 5000.
+    {BOLD}Option A — localhost.run (easiest + free ssh tunnel){RESET}
+        localhost.run creates a public HTTPS URL seamlessly using SSH.
         No account required.
-        Official site: {CYAN}https://theboroer.github.io/localtunnel-www/{RESET}
+        Official site: {CYAN}https://localhost.run/{RESET}
 
   {BOLD}Option B — Your own port forwarding (advanced){RESET}
     Forward {BOLD}TCP port 5000{RESET} on your router to your machine's local IP.
@@ -693,10 +693,10 @@ def setup_remote_access():
   the same network. Use your PC's local IP (e.g. 192.168.x.x) in the app.{RESET}
 """)
 
-    choice = ask_yn("Enable localtunnel on startup?", default=True)
+    choice = ask_yn("Enable localhost.run on startup?", default=True)
     if not choice:
         LOCALTUNNEL_ENABLED.unlink(missing_ok=True)
-        warn("Skipping localtunnel. Use either your own port forwarding or local WiFi.")
+        warn("Skipping localhost.run. Use either your own port forwarding or local WiFi.")
         info("Remember: set the correct server URL in the mobile app Settings.")
         return
 
@@ -711,15 +711,15 @@ def setup_remote_access():
 
     After installing, re-run {BOLD}python start.py{RESET}.
 """)
-        warn("Skipping localtunnel setup.")
+        warn("Skipping localhost.run setup.")
         return
 
     ok("npx binary found")
     LOCALTUNNEL_ENABLED.parent.mkdir(parents=True, exist_ok=True)
     LOCALTUNNEL_ENABLED.write_text("enabled")
-    ok("localtunnel auto-start enabled")
+    ok("localhost.run auto-start enabled")
     nl()
-    info("localtunnel will be started automatically every time you run start.py.")
+    info("localhost.run will be started automatically every time you run start.py.")
 
 # ══════════════════════════════════════════════════════════════════════════════
 # Step 6 — Access Token & Database
@@ -754,83 +754,95 @@ def setup_token_and_db():
 # ══════════════════════════════════════════════════════════════════════════════
 # Launch Backend
 # ══════════════════════════════════════════════════════════════════════════════
-def _extract_localtunnel_url(text: str) -> str | None:
-    """Extract first localtunnel public URL from text."""
+def _extract_localhost_run_url(text: str) -> str | None:
+    """Extract first localhost.run public URL from text."""
     import re
-    m = re.search(r"https://[\w.-]+\.loca\.lt\b", text)
-    return m.group(0) if m else None
+    lines = text.splitlines()
+    for line in reversed(lines):
+        if "tunneled with tls termination" in line or ".lhr.life" in line or ".localhost.run" in line:
+            match = re.search(r'(https://[a-zA-Z0-9-]+\.(?:lhr\.life|localhost\.run))', line)
+            if match:
+                return match.group(1)
+    return None
 
 
-def _find_localtunnel_url_from_log() -> str | None:
+def _find_localhost_run_url_from_log() -> str | None:
     """Read local tunnel log and return detected public URL if available."""
     try:
         if not LOCALTUNNEL_LOG.exists():
             return None
         text = LOCALTUNNEL_LOG.read_text(encoding="utf-8", errors="ignore")
-        return _extract_localtunnel_url(text)
+        return _extract_localhost_run_url(text)
     except Exception:
         return None
 
 
-def _stop_localtunnel_processes():
-    """Stop existing localtunnel processes so only one tunnel remains active."""
+def _stop_localhost_run_processes():
+    """Stop existing localhost.run processes so only one tunnel remains active."""
     try:
         if IS_WINDOWS:
             script = (
                 "Get-CimInstance Win32_Process "
-                "| Where-Object { $_.CommandLine -match 'localtunnel|\\.loca\\.lt' } "
+                "| Where-Object { $_.CommandLine -match 'nokey@localhost.run' } "
                 "| ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue }"
             )
             subprocess.run(["powershell", "-NoProfile", "-Command", script], check=False)
         else:
-            subprocess.run(["pkill", "-f", "localtunnel"], check=False)
+            subprocess.run(["pkill", "-f", "nokey@localhost.run"], check=False)
     except Exception:
         pass
 
 
-def _start_localtunnel(port: int, timeout: int = 25) -> str | None:
-    """Start localtunnel in the background and wait for the public URL."""
+def _start_localhost_run(port: int, timeout: int = 25) -> str | None:
+    """Start localhost.run in the background via SSH and wait for the public URL."""
     import time as _time
 
-    npx_exec = shutil.which("npx") or shutil.which("npx.cmd")
-    if not npx_exec:
+    ssh_exec = shutil.which("ssh")
+    if not ssh_exec:
+        warn("SSH is required to use localhost.run. Please install OpenSSH.")
         return None
 
-    # Clean stale localtunnel processes.
-    _stop_localtunnel_processes()
+    # Clean stale ssh tunnel processes.
+    _stop_localhost_run_processes()
     _time.sleep(0.8)
 
-    info("Starting localtunnel in background …")
+    info("Starting localhost.run SSH tunnel in background …")
     try:
         LOCALTUNNEL_LOG.parent.mkdir(parents=True, exist_ok=True)
         LOCALTUNNEL_LOG.write_text("")
 
         log_handle = open(LOCALTUNNEL_LOG, "a", encoding="utf-8", buffering=1)
         kwargs = {
-            "start_new_session": True,
             "stdout": log_handle,
             "stderr": subprocess.STDOUT,
+            "stdin": subprocess.DEVNULL,
             "text": True,
         }
-        if IS_WINDOWS and npx_exec.lower().endswith(".cmd"):
-            cmd = ["cmd", "/c", npx_exec, "-y", "localtunnel", "--port", str(port)]
-        else:
-            cmd = [npx_exec, "-y", "localtunnel", "--port", str(port)]
-        subprocess.Popen(cmd, **kwargs)
+        if IS_WINDOWS:
+            kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP
+        
+        cmd = [ssh_exec, "-o", "StrictHostKeyChecking=no", "-R", f"80:localhost:{port}", "nokey@localhost.run"]
+        process = subprocess.Popen(cmd, **kwargs)
+        
+        _time.sleep(1.0)
+        if process.poll() is not None:
+            warn(f"Could not start localhost.run, exited with {process.returncode}")
+            return None
+
     except Exception as e:
-        warn(f"Could not start localtunnel: {e}")
+        warn(f"Could not start localhost.run: {e}")
         return None
 
     # Poll log output until URL is emitted.
     deadline = _time.time() + timeout
     while _time.time() < deadline:
         _time.sleep(1)
-        url = _find_localtunnel_url_from_log()
+        url = _find_localhost_run_url_from_log()
         if url:
-            ok(f"localtunnel active  →  {GREEN}{BOLD}{url}{RESET}")
+            ok(f"localhost.run active  →  {GREEN}{BOLD}{url}{RESET}")
             return url
 
-    warn("localtunnel started but URL is not available yet.")
+    warn("localhost.run started but URL is not available yet.")
     info(f"Check tunnel logs in: {LOCALTUNNEL_LOG}")
     return None
 
@@ -1202,26 +1214,26 @@ def launch_backend():
     token = TOKEN_FILE.read_text().strip() if TOKEN_FILE.exists() else "—"
     local_ip = _detect_local_ip()
 
-    localtunnel_enabled = bool(shutil.which("npx") or shutil.which("npx.cmd"))
+    localhost_run_enabled = bool(shutil.which("ssh"))
 
-    localtunnel_url: str | None = None
-    if localtunnel_enabled:
-        localtunnel_url = _start_localtunnel(PORT)
+    localhost_run_url: str | None = None
+    if localhost_run_enabled:
+        localhost_run_url = _start_localhost_run(PORT)
     else:
-        localtunnel_url = _find_localtunnel_url_from_log()
+        localhost_run_url = _find_localhost_run_url_from_log()
 
-    if localtunnel_url:
-        tunnel_line = f"    Public URL   →  {GREEN}{BOLD}{localtunnel_url}{RESET}  {DIM}(localtunnel){RESET}"
-        tunnel_hint = f"         · public     →  {GREEN}{localtunnel_url}{RESET}"
-    elif localtunnel_enabled:
+    if localhost_run_url:
+        tunnel_line = f"    Public URL   →  {GREEN}{BOLD}{localhost_run_url}{RESET}  {DIM}(localhost.run){RESET}"
+        tunnel_hint = f"         · public     →  {GREEN}{localhost_run_url}{RESET}"
+    elif localhost_run_enabled:
         tunnel_line = f"    Public URL   →  {YELLOW}(starting — URL pending, check localtunnel.log){RESET}"
-        tunnel_hint = f"         · public     →  run:  {DIM}npx localtunnel --port {PORT}{RESET}"
+        tunnel_hint = f"         · public     →  run:  {DIM}ssh -R 80:localhost:{PORT} nokey@localhost.run{RESET}"
     else:
         tunnel_line = ""
-        tunnel_hint = f"         · public     →  install Node.js first, then run: {DIM}npx localtunnel --port {PORT}{RESET}"
+        tunnel_hint = f"         · public     →  install OpenSSH first, then run: {DIM}ssh -R 80:localhost:{PORT} nokey@localhost.run{RESET}"
 
     # ── Generate and display QR code ──────────────────────────────────────────
-    qr_url = localtunnel_url if localtunnel_url else f"http://{local_ip}:{PORT}"
+    qr_url = localhost_run_url if localhost_run_url else f"http://{local_ip}:{PORT}"
     _display_connect_qr(qr_url, token)
 
     print(f"""
@@ -1282,7 +1294,7 @@ def launch_backend_status():
             url = match.group(1)
             
     if url == "NOT_FOUND":
-        warn("Could not find a running localtunnel URL in config/localtunnel.log.")
+        warn("Could not find a running localhost.run URL in config/localtunnel.log.")
         nl()
         print("  Wait 5 seconds, or run 'superbrain-server' to start the server.")
         return
@@ -1327,7 +1339,7 @@ def main():
     3 · Configure AI provider keys + Instagram credentials
     4 · Set up an offline AI model via Ollama  (qwen3-vl:4b)
     5 · Set up offline audio transcription     (Whisper + ffmpeg)
-    6 · Configure remote access (localtunnel or port forwarding)
+    6 · Configure remote access (localhost.run or port forwarding)
     7 · Generate Access Token & initialise database
 
   Press {BOLD}Enter{RESET} to accept defaults shown in [{DIM}brackets{RESET}].