superbrain-server 1.0.7 → 1.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superbrain-server",
-  "version": "1.0.7",
+  "version": "1.0.11",
   "description": "1-Line Auto-Installer and Server Execution wrapper for SuperBrain",
   "main": "index.js",
   "bin": {
@@ -22,4 +22,4 @@
     "bin/",
     "payload/"
   ]
-}
+}

package/payload/api.py

@@ -289,7 +289,15 @@ class AnalysisResponse(BaseModel):
 @app.get("/")
 async def root():
     """API information and health check (no authentication required)"""
+    
+    backend_id = "unknown"
+    backend_id_path = get_config_path("backend_id.txt")
+    if backend_id_path.exists():
+        backend_id = backend_id_path.read_text().strip()
+    
     return {
+        "backendId": backend_id,
+
         "name": "SuperBrain Instagram Analyzer API",
         "version": "1.02",
         "status": "operational",
@@ -561,12 +569,46 @@ async def analyze_instagram(request: AnalyzeRequest, token: str = Depends(verify
             logger.warning(f"⚠️  [{shortcode}] main.py stderr:\n{stderr[:1000]}")
         
         if returncode == 2:
-            retry_lines = [l.strip() for l in stdout.splitlines() if l.strip().startswith('?')]
-            retry_msg = retry_lines[-1].replace('?', '').strip() if retry_lines else "API quota exhausted or rate limited. Queued for automatic retry in 24 hours."
-            logger.info(f"? [{shortcode}] {retry_msg}")
+            # main.py detected quota exhaustion and queued item for retry.
+            # NOTE: Do NOT remove from queue here — main.py already called
+            # queue_for_retry() which set status='retry'. Removing would lose it.
+            logger.info(f"⏰ [{shortcode}] Quota exhausted — queued for automatic retry")
             raise HTTPException(
                 status_code=202,
-                detail=retry_msg
+                detail="API quota exhausted. Your request has been queued for automatic retry in 24 hours."
+            )
+        
+        if returncode != 0:
+            # Extract last meaningful error line from stdout for the error message
+            error_lines = [l.strip() for l in stdout.splitlines() if l.strip() and ('❌' in l or 'Error' in l or 'failed' in l.lower())]
+            error_detail = error_lines[-1] if error_lines else (stderr.strip()[:200] or "Analysis failed")
+            logger.error(f"❌ [{shortcode}] Analysis failed: {error_detail}")
+            logger.debug(f"[{shortcode}] stdout tail:\n{stdout[-800:]}")
+            raise HTTPException(
+                status_code=400,
+                detail=error_detail
+            )
+        
+        logger.info(f"✅ [{shortcode}] Analysis complete! Fetching from database...")
+        
+        # Get result from database — retry up to 4 times in case the SQLite write
+        # hasn't flushed yet (race condition between subprocess write and our read).
+        analysis = None
+        for _attempt in range(4):
+            analysis = db.check_cache(shortcode)
+            if analysis:
+                if _attempt > 0:
+                    logger.info(f"🔄 [{shortcode}] Found in database on retry {_attempt}")
+                break
+            if _attempt < 3:
+                logger.warning(f"⏳ [{shortcode}] Not in DB yet (attempt {_attempt+1}/4), retrying in 1s…")
+                await asyncio.sleep(1)
+        
+        if not analysis:
+            logger.error(f"❌ [{shortcode}] Not found in database after 4 attempts!")
+            raise HTTPException(
+                status_code=500,
+                detail="Analysis completed but result not found in database"
             )
         
         # Filter response

package/payload/core/model_router.py

@@ -663,6 +663,9 @@ class ModelRouter:
             try:
                 self._refresh_openrouter_models()
             except Exception as e:
+            if "429" in str(e) or "quota" in str(e).lower():
+                raise RateLimitError("Quota limit hit")
+            raise e
                 print(f"⚠️  OpenRouter auto-refresh error: {e}")
             time.sleep(OPENROUTER_FREE_CACHE_HOURS * 3600)
 
@@ -707,6 +710,9 @@ class ModelRouter:
             resp.raise_for_status()
             all_models = resp.json().get("data", [])
         except Exception as e:
+            if "429" in str(e) or "quota" in str(e).lower():
+                raise RateLimitError("Quota limit hit")
+            raise e
             print(f"⚠️  OpenRouter model discovery failed: {e}")
             return
 
@@ -1100,6 +1106,9 @@ class ModelRouter:
                 return result
 
             except Exception as e:
+            if "429" in str(e) or "quota" in str(e).lower():
+                raise RateLimitError("Quota limit hit")
+            raise e
                 status = 429 if "429" in str(e) else 0
                 self._record_failure(key, str(e), status_code=status)
                 print(f"  ✗ Failed ({type(e).__name__}), trying next …", flush=True)
@@ -1144,6 +1153,9 @@ class ModelRouter:
                 return result
 
             except Exception as e:
+            if "429" in str(e) or "quota" in str(e).lower():
+                raise RateLimitError("Quota limit hit")
+            raise e
                 status = 429 if "429" in str(e) else 0
                 self._record_failure(key, str(e), status_code=status)
                 print(f"  ✗ Failed ({type(e).__name__}), trying next …", flush=True)

package/payload/start.py

@@ -22,6 +22,7 @@ import string
 import textwrap
 import time
 import importlib
+import re
 from pathlib import Path
 
 # ── Paths ─────────────────────────────────────────────────────────────────────
@@ -157,6 +158,7 @@ def ensure_runtime_dependencies():
         ("fastapi", "fastapi"),
         ("uvicorn", "uvicorn"),
         ("multipart", "python-multipart"),
+        ("pyngrok", "pyngrok"),
         ("instaloader", "instaloader"),
         ("segno", "segno"),
     ]
@@ -662,64 +664,41 @@ def setup_whisper():
 # ══════════════════════════════════════════════════════════════════════════════
 # Step 6 — Remote Access / Port Forwarding
 # ══════════════════════════════════════════════════════════════════════════════
-LOCALTUNNEL_ENABLED = BASE_DIR / "config" / "localtunnel_enabled.txt"
-LOCALTUNNEL_LOG = BASE_DIR / "config" / "localtunnel.log"
+NGROK_ENABLED = BASE_DIR / "config" / "ngrok_enabled.txt"
+NGROK_TOKEN = BASE_DIR / "config" / "ngrok_token.txt"
 
 def setup_remote_access():
-    h1("Step 6 of 7 — Remote Access (localhost.run / Port Forwarding)")
+    h1("Step 6 of 7 — Remote Access (ngrok)")
 
     print(f"""
-  The SuperBrain backend runs on {BOLD}port 5000{RESET} on your machine.
-  Your phone needs to reach this port over the internet.
-
-  You have two options:
-
-    {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://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.
-    Then use {BOLD}http://<your-public-ip>:5000{RESET} in the mobile app.
-    Steps:
-      1. Find your machine's local IP  →  ip addr  (Linux) / ipconfig (Windows)
-      2. Log into your router admin panel (usually http://192.168.1.1)
-      3. Add a port forwarding rule: External 5000 → Internal <your-local-IP>:5000
-      4. Use your public IP (check https://ipify.org) in the mobile app.
-    {YELLOW}Note: dynamic public IPs change on router restart — consider a DDNS service.{RESET}
-
-  {DIM}You can also run only on your local WiFi — both phone and PC must be on
-  the same network. Use your PC's local IP (e.g. 192.168.x.x) in the app.{RESET}
+  The SuperBrain backend runs locally. Your phone needs to reach it over the internet.
+  We recommend {BOLD}ngrok{RESET} for a secure tunnel.
+
+  Requires a free account from: {CYAN}https://dashboard.ngrok.com/signup{RESET}
+  Get your Authtoken at: {CYAN}https://dashboard.ngrok.com/get-started/your-authtoken{RESET}
 """)
 
-    choice = ask_yn("Enable localhost.run on startup?", default=True)
+    choice = ask_yn("Enable ngrok on startup?", default=True)
     if not choice:
-        LOCALTUNNEL_ENABLED.unlink(missing_ok=True)
-        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.")
+        NGROK_ENABLED.unlink(missing_ok=True)
+        warn("Skipping ngrok. Local WiFi only.")
         return
 
-    if not shutil.which("npx"):
-        print(f"""
-    {YELLOW}npx is not installed / not on PATH.{RESET}
-
-    Install it:
-        Linux   →  {CYAN}Install Node.js (includes npm + npx){RESET}
-        macOS   →  {CYAN}brew install node{RESET}
-        Windows →  Install Node.js LTS from {CYAN}https://nodejs.org/{RESET}
-
-    After installing, re-run {BOLD}python start.py{RESET}.
-""")
-        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("localhost.run auto-start enabled")
-    nl()
-    info("localhost.run will be started automatically every time you run start.py.")
+    ok("ngrok auto-start enabled")
+    NGROK_ENABLED.parent.mkdir(parents=True, exist_ok=True)
+    NGROK_ENABLED.write_text("enabled")
+
+    existing_token = NGROK_TOKEN.read_text().strip() if NGROK_TOKEN.exists() else ""
+    print(f"\n  {YELLOW}Please paste your ngrok Authtoken.{RESET}")
+    if existing_token:
+         print(f"  {DIM}(Leave blank to keep existing token){RESET}")
+         
+    auth_token = ask("Authtoken", default=existing_token, paste=True)
+    if auth_token.strip():
+        NGROK_TOKEN.write_text(auth_token.strip())
+        ok("ngrok token saved.")
+    else:
+        warn("No ngrok token provided. ngrok may disconnect. To fix, re-run setup.")
 
 # ══════════════════════════════════════════════════════════════════════════════
 # Step 6 — Access Token & Database
@@ -754,99 +733,21 @@ def setup_token_and_db():
 # ══════════════════════════════════════════════════════════════════════════════
 # Launch Backend
 # ══════════════════════════════════════════════════════════════════════════════
-def _extract_localhost_run_url(text: str) -> str | None:
-    """Extract first localhost.run public URL from text."""
-    import re
-    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_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_localhost_run_url(text)
-    except Exception:
-        return None
-
-
-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 '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", "nokey@localhost.run"], check=False)
-    except Exception:
-        pass
-
-
-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
-
-    ssh_exec = shutil.which("ssh")
-    if not ssh_exec:
-        warn("SSH is required to use localhost.run. Please install OpenSSH.")
-        return None
-
-    # Clean stale ssh tunnel processes.
-    _stop_localhost_run_processes()
-    _time.sleep(0.8)
-
-    info("Starting localhost.run SSH tunnel in background …")
+def _start_ngrok(port: int) -> str | None:
     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 = {
-            "stdout": log_handle,
-            "stderr": subprocess.STDOUT,
-            "stdin": subprocess.DEVNULL,
-            "text": True,
-        }
-        if IS_WINDOWS:
-            kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP
+        import pyngrok
+        from pyngrok import ngrok
         
-        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
-
+        token = NGROK_TOKEN.read_text().strip() if NGROK_TOKEN.exists() else None
+        if token:
+            ngrok.set_auth_token(token)
+            
+        tunnel = ngrok.connect(port, bind_tls=True)
+        return tunnel.public_url
     except Exception as e:
-        warn(f"Could not start localhost.run: {e}")
+        warn(f"Failed to start ngrok: {e}")
         return None
 
-    # Poll log output until URL is emitted.
-    deadline = _time.time() + timeout
-    while _time.time() < deadline:
-        _time.sleep(1)
-        url = _find_localhost_run_url_from_log()
-        if url:
-            ok(f"localhost.run active  →  {GREEN}{BOLD}{url}{RESET}")
-            return url
-
-    warn("localhost.run started but URL is not available yet.")
-    info(f"Check tunnel logs in: {LOCALTUNNEL_LOG}")
-    return None
-
-
 def _get_windows_pids_on_port(port: int) -> list[int]:
     """Return listener PIDs on Windows using Get-NetTCPConnection when available."""
     pids: set[int] = set()
@@ -1214,26 +1115,27 @@ def launch_backend():
     token = TOKEN_FILE.read_text().strip() if TOKEN_FILE.exists() else "—"
     local_ip = _detect_local_ip()
 
-    localhost_run_enabled = bool(shutil.which("ssh"))
-
-    localhost_run_url: str | None = None
-    if localhost_run_enabled:
-        localhost_run_url = _start_localhost_run(PORT)
-    else:
-        localhost_run_url = _find_localhost_run_url_from_log()
-
-    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}ssh -R 80:localhost:{PORT} nokey@localhost.run{RESET}"
+    # ngrok startup
+    public_url: str | None = None
+    if NGROK_ENABLED.exists():
+        info("Starting ngrok in background...")
+        public_url = _start_ngrok(PORT)
+        
+    tunnel_line = ""
+    tunnel_hint = ""
+    
+    if public_url:
+        tunnel_line = f"    Public URL   →  {GREEN}{BOLD}{public_url}{RESET}  {DIM}(ngrok){RESET}"
+        tunnel_hint = f"         · public     →  {GREEN}{public_url}{RESET}"
+        ok(f"ngrok active  →  {GREEN}{BOLD}{public_url}{RESET}")
+    elif NGROK_ENABLED.exists():
+        tunnel_line = f"    Public URL   →  {YELLOW}(failed to start ngrok){RESET}"
+        tunnel_hint = f"         · public     →  run manually: {DIM}ngrok http {PORT}{RESET}"
     else:
-        tunnel_line = ""
-        tunnel_hint = f"         · public     →  install OpenSSH first, then run: {DIM}ssh -R 80:localhost:{PORT} nokey@localhost.run{RESET}"
+        tunnel_hint = f"         · public     →  enable ngrok via {DIM}python start.py --reset{RESET}"
 
     # ── Generate and display QR code ──────────────────────────────────────────
-    qr_url = localhost_run_url if localhost_run_url else f"http://{local_ip}:{PORT}"
+    qr_url = public_url if public_url else f"http://{local_ip}:{PORT}"
     _display_connect_qr(qr_url, token)
 
     print(f"""
@@ -1286,15 +1188,21 @@ def launch_backend_status():
     if TOKEN_FILE.exists():
         token = TOKEN_FILE.read_text(encoding="utf-8").strip()
 
+    # Fetch ngrok status via API
     url = "NOT_FOUND"
-    log_file = BASE_DIR / "config" / "localtunnel.log"
-    if log_file.exists():
-        match = re.search(r"your url is: (https://[^\s]+)", log_file.read_text(encoding="utf-8"))
-        if match:
-            url = match.group(1)
-            
+    try:
+        import urllib.request, json
+        req = urllib.request.urlopen("http://127.0.0.1:4040/api/tunnels", timeout=2)
+        data = json.loads(req.read())
+        for tunnel in data.get("tunnels", []):
+            if tunnel.get("proto") == "https":
+                url = tunnel.get("public_url")
+                break
+    except Exception:
+        pass
+        
     if url == "NOT_FOUND":
-        warn("Could not find a running localhost.run URL in config/localtunnel.log.")
+        warn("Could not find a running ngrok URL. Is the server running?")
         nl()
         print("  Wait 5 seconds, or run 'superbrain-server' to start the server.")
         return
@@ -1306,11 +1214,11 @@ def launch_backend_status():
     network_url = f"http://{local_ip}:5000"
     
     nl()
-    print(f"    Local URL      ?  {CYAN}{local_url}{RESET}")
-    print(f"    Network URL    ?  {CYAN}{network_url}{RESET}")
-    print(f"    Public URL   ?  {CYAN}{url}{RESET}  (localtunnel)")
-    print(f"    API docs       ?  {CYAN}{local_url}/docs{RESET}")
-    print(f"    Access Token   ?  {BOLD}{MAGENTA}{token}{RESET}")
+    print(f"    Local URL      \u2192  {CYAN}{local_url}{RESET}")
+    print(f"    Network URL    \u2192  {CYAN}{network_url}{RESET}")
+    print(f"    Public URL   \u2192  {CYAN}{url}{RESET}  (localtunnel)")
+    print(f"    API docs       \u2192  {CYAN}{local_url}/docs{RESET}")
+    print(f"    Access Token   \u2192  {BOLD}{MAGENTA}{token}{RESET}")
     nl()
 
 def main():
@@ -1339,7 +1247,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 (localhost.run or port forwarding)
+    6 · Configure remote access (localtunnel or port forwarding)
     7 · Generate Access Token & initialise database
 
   Press {BOLD}Enter{RESET} to accept defaults shown in [{DIM}brackets{RESET}].

package/payload/fix.py

@@ -1,66 +0,0 @@
-import sys, shutil
-path1 = 'D:/superbrain/backend/start.py'
-path2 = 'D:/superbrain/superbrain-cli/payload/start.py'
-
-status_code = '''
-def launch_backend_status():
-    h1("SuperBrain Server Status")
-    PORT = 5000
-    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"))
-    localtunnel_url: str | None = None
-    if localtunnel_enabled:
-        localtunnel_url = _find_localtunnel_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:
-        tunnel_line = f"    Public URL   ?  {YELLOW}(running � URL in localtunnel.log){RESET}"
-        tunnel_hint = f"         � public     ?  run:  {DIM}npx localtunnel --port {PORT}{RESET}"
-    else:
-        tunnel_line = ""
-        tunnel_hint = f"         � public     ?  install Node.js first, then run: {DIM}npx localtunnel --port {PORT}{RESET}"
-
-    qr_url = localtunnel_url if localtunnel_url else f"http://{local_ip}:{PORT}"
-    _display_connect_qr(qr_url, token)
-
-    print(f\"\"\"
-    {GREEN}{BOLD}Server Status{RESET}
-
-    Local URL      ?  {CYAN}http://127.0.0.1:{PORT}{RESET}
-    Network URL    ?  {CYAN}http://{local_ip}:{PORT}{RESET}
-{(tunnel_line + chr(10)) if tunnel_line else ''}    API docs       ?  {CYAN}http://127.0.0.1:{PORT}/docs{RESET}
-    Access Token   ?  {BOLD}{MAGENTA}{token}{RESET}
-
-  {YELLOW}Mobile app setup:{RESET}
-    {BOLD}Option A � Scan QR code:{RESET}
-      1. Open the app  ?  Settings  ?  tap the {BOLD}QR icon{RESET} ??
-      2. Scan the QR code shown above
-
-    {BOLD}Option B � Manual setup:{RESET}
-      1. Go to app  ?  ? settings
-      2. Set {BOLD}Server URL{RESET} to:
-{tunnel_hint}
-           � Same WiFi  ?  http://{local_ip}:{PORT}
-      3. Set {BOLD}Access Token{RESET} to: {BOLD}{MAGENTA}{token}{RESET}
-\"\"\")
-    sys.exit(0)
-
-'''
-
-for path in [path1, path2]:
-    with open(path, 'r', encoding='utf-8') as f:
-        content = f.read()
-
-    if 'def launch_backend_status()' not in content:
-        content = content.replace('def main():', status_code + 'def main():')
-
-    if 'status_mode = "--status" in sys.argv' not in content:
-        content = content.replace('    reset_mode = "--reset" in sys.argv', '    status_mode = "--status" in sys.argv\\n    if status_mode:\\n        launch_backend_status()\\n        return\\n\\n    reset_mode = "--reset" in sys.argv')
-
-    with open(path, 'w', encoding='utf-8') as f:
-        f.write(content)
-print("Done fixing start.py!")

package/payload/fix2.py

@@ -1,63 +0,0 @@
-import sys, shutil
-path1 = 'D:/superbrain/backend/start.py'
-path2 = 'D:/superbrain/superbrain-cli/payload/start.py'
-
-status_code = '''
-def launch_backend_status():
-    h1("SuperBrain Server Status")
-    PORT = 5000
-    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"))
-    localtunnel_url: str | None = None
-    if localtunnel_enabled:
-        localtunnel_url = _find_localtunnel_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:
-        tunnel_line = f"    Public URL   ?  {YELLOW}(running � URL in localtunnel.log){RESET}"
-        tunnel_hint = f"         � public     ?  run:  {DIM}npx localtunnel --port {PORT}{RESET}"
-    else:
-        tunnel_line = ""
-        tunnel_hint = f"         � public     ?  install Node.js first, then run: {DIM}npx localtunnel --port {PORT}{RESET}"
-
-    qr_url = localtunnel_url if localtunnel_url else f"http://{local_ip}:{PORT}"
-    _display_connect_qr(qr_url, token)
-
-    print(f\"\"\"
-    {GREEN}{BOLD}Server Status{RESET}
-
-    Local URL      ?  {CYAN}http://127.0.0.1:{PORT}{RESET}
-    Network URL    ?  {CYAN}http://{local_ip}:{PORT}{RESET}
-{(tunnel_line + chr(10)) if tunnel_line else ''}    API docs       ?  {CYAN}http://127.0.0.1:{PORT}/docs{RESET}
-    Access Token   ?  {BOLD}{MAGENTA}{token}{RESET}
-
-  {YELLOW}Mobile app setup:{RESET}
-    {BOLD}Option A � Scan QR code:{RESET}
-      1. Open the app  ?  Settings  ?  tap the {BOLD}QR icon{RESET} ??
-      2. Scan the QR code shown above
-
-    {BOLD}Option B � Manual setup:{RESET}
-      1. Go to app  ?  ? settings
-      2. Set {BOLD}Server URL{RESET} to:
-{tunnel_hint}
-           � Same WiFi  ?  http://{local_ip}:{PORT}
-      3. Set {BOLD}Access Token{RESET} to: {BOLD}{MAGENTA}{token}{RESET}
-\"\"\")
-    sys.exit(0)
-
-'''
-
-for path in [path1, path2]:
-    with open(path, 'r', encoding='utf-8') as f:
-        content = f.read()
-
-    if 'def launch_backend_status()' not in content:
-        content = content.replace('def main():', status_code + 'def main():')
-
-    with open(path, 'w', encoding='utf-8') as f:
-        f.write(content)
-print("Done fixing start.py again!")