Deploy MasseurBoost Endpoint API

Dockerfile

@@ -1,27 +1,14 @@
 FROM python:3.11-slim
 
-ENV PYTHONDONTWRITEBYTECODE=1
-ENV PYTHONUNBUFFERED=1
-ENV PORT=7860
-
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    bash \
-    coreutils \
-    findutils \
-    grep \
-    sed \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt /app/requirements.txt
-RUN pip install --no-cache-dir -r /app/requirements.txt
+RUN pip install --no-cache-dir fastapi uvicorn[standard] jinja2
 
-COPY app.py /app/app.py
+COPY . /app
 
-RUN mkdir -p /data/workspace /data/ledger
+# Create data directory for bundled DB
+RUN mkdir -p /data
 
 EXPOSE 7860
 
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,8 @@
----
-title: Endpoint
-emoji: ⚡
-colorFrom: yellow
-colorTo: pink
+title: MasseurBoost Endpoint
+emoji: 💆
+colorFrom: violet
+colorTo: fuchsia
 sdk: docker
+app_port: 7860
 pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+license: mit

app.py

@@ -1,1106 +1,170 @@
+"""josephrw-endpoint HF Space — MasseurBoost API endpoint.
+
+Exposes the SaaS app on Hugging Face Spaces with a lightweight
+read-only mode (no local DB writes, no Selenium).
+"""
 import os
-import re
+import sys
 import json
-import uuid
-import time
-import html
-import socket
-import hashlib
 import sqlite3
-import asyncio
-import shlex
-import ipaddress
 from pathlib import Path
-from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional
-from urllib.parse import urlparse
-
-import httpx
-from fastapi import FastAPI, HTTPException, Header, Request
-from fastapi.responses import HTMLResponse, PlainTextResponse, FileResponse, JSONResponse
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel, Field
-
-
-PUBLIC_BASE_URL = os.getenv("PUBLIC_BASE_URL", "https://josephrw-endpoint.hf.space").rstrip("/")
-ADMIN_TOKEN = os.getenv("ADMIN_TOKEN", "").strip()
-APP_NAME = "Self-Relaunching GPT Kernel"
-
-DATA_DIR = Path(os.getenv("DATA_DIR", "/data"))
-WORKSPACE_ROOT = Path(os.getenv("WORKSPACE_ROOT", str(DATA_DIR / "workspaces"))).resolve()
-ARTIFACT_ROOT = Path(os.getenv("ARTIFACT_ROOT", str(DATA_DIR / "artifacts"))).resolve()
-RECEIPTS_ROOT = Path(os.getenv("RECEIPTS_ROOT", str(DATA_DIR / "receipts"))).resolve()
-LEDGER_DB = Path(os.getenv("LEDGER_DB", str(DATA_DIR / "ledger.sqlite3"))).resolve()
-TOOLS_FILE = Path(os.getenv("TOOLS_FILE", str(DATA_DIR / "tools.json"))).resolve()
-RELAUNCH_FLAG = Path(os.getenv("RELAUNCH_FLAG", str(DATA_DIR / "relaunch_requested.json"))).resolve()
-
-MAX_TIMEOUT_SECONDS = int(os.getenv("MAX_TIMEOUT_SECONDS", "30"))
-MAX_OUTPUT_BYTES = int(os.getenv("MAX_OUTPUT_BYTES", "120000"))
-MAX_FILE_BYTES = int(os.getenv("MAX_FILE_BYTES", "20000000"))
-SCRAPE_MAX_BYTES = int(os.getenv("SCRAPE_MAX_BYTES", "1500000"))
-SCRAPE_PREVIEW_CHARS = int(os.getenv("SCRAPE_PREVIEW_CHARS", "18000"))
-
-for p in [DATA_DIR, WORKSPACE_ROOT, ARTIFACT_ROOT, RECEIPTS_ROOT, LEDGER_DB.parent, TOOLS_FILE.parent]:
-    p.mkdir(parents=True, exist_ok=True)
-
-app = FastAPI(
-    title=APP_NAME,
-    version="4.0.0",
-    description=(
-        "GPT Actions compatible self-relaunching kernel with controlled terminal, Python execution, "
-        "public web scraping, file saving, receipts, request analysis, persistent tools, artifacts, "
-        "and admin-protected relaunch."
-    ),
-    openapi_url="/openapi_raw.json",
-    docs_url="/docs",
-)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=False,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-BLOCKED_TOKENS = [
-    "rm -rf /", "mkfs", "dd if=", ":(){", "shutdown", "reboot",
-    "passwd", "useradd", "adduser", "su ", "sudo ", "chown /", "chmod 777 /",
-    "nc ", "ncat ", "telnet ", "ssh ", "scp ", "rsync ",
-    "python -m http.server", "uvicorn ", "gunicorn ", "nohup ", "& disown",
-    "/etc/passwd", "/etc/shadow", "/root", "/proc/self/environ",
-    "apt-get", "apk add", "yum install", "dnf install",
-]
-
-ALLOWED_COMMAND_PREFIXES = [
-    "pwd", "ls", "cat", "head", "tail", "wc", "find", "grep", "sed",
-    "python", "python3", "pytest", "git status", "git diff", "git log",
-    "tree", "du", "df", "date", "whoami", "echo", "touch", "mkdir",
-    "cp", "mv", "sha256sum", "sort", "uniq", "cut", "tr", "printf", "uname",
-    "node", "npm --version", "npx --yes vercel", "vercel --version"
-]
-
-
-def now_iso() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-def sha256_bytes(raw: bytes) -> str:
-    return hashlib.sha256(raw).hexdigest()
-
-
-def sha256_json(payload: Any) -> str:
-    raw = json.dumps(payload, sort_keys=True, ensure_ascii=False, default=str).encode("utf-8")
-    return sha256_bytes(raw)
-
-
-def safe_name(value: str, default: str = "item") -> str:
-    value = (value or default).strip()
-    value = re.sub(r"[^a-zA-Z0-9._-]+", "-", value)
-    value = value.strip(".-")
-    return value[:120] or default
-
-
-def require_admin(x_admin_token: Optional[str]) -> None:
-    if not ADMIN_TOKEN:
-        raise HTTPException(status_code=503, detail="ADMIN_TOKEN is not configured")
-    if x_admin_token != ADMIN_TOKEN:
-        raise HTTPException(status_code=401, detail="Admin token required")
-
-
-def workspace_path(workspace: str, relative_path: str = ".") -> Path:
-    ws = safe_name(workspace, "default")
-    base = (WORKSPACE_ROOT / ws).resolve()
-    base.mkdir(parents=True, exist_ok=True)
-    target = (base / relative_path).resolve()
-    if not str(target).startswith(str(base)):
-        raise HTTPException(status_code=400, detail="Path escapes workspace")
-    return target
-
-
-def artifact_path(relative_path: str) -> Path:
-    safe = relative_path.replace("\\", "/").lstrip("/")
-    target = (ARTIFACT_ROOT / safe).resolve()
-    if not str(target).startswith(str(ARTIFACT_ROOT)):
-        raise HTTPException(status_code=400, detail="Path escapes artifact root")
-    target.parent.mkdir(parents=True, exist_ok=True)
-    return target
-
-
-def validate_command(command: str) -> None:
-    lowered = command.lower()
-    for token in BLOCKED_TOKENS:
-        if token.lower() in lowered:
-            raise HTTPException(status_code=400, detail=f"Blocked command token: {token}")
-
-    lines = [ln.strip() for ln in command.strip().splitlines() if ln.strip()]
-    if not lines:
-        raise HTTPException(status_code=400, detail="Empty command")
-    for line in lines:
-        if not any(line == p or line.startswith(p + " ") for p in ALLOWED_COMMAND_PREFIXES):
-            raise HTTPException(status_code=400, detail=f"Command prefix not allowed: {line[:100]}")
-
-
-def init_db() -> None:
-    with sqlite3.connect(LEDGER_DB, timeout=5) as con:
-        con.execute("PRAGMA journal_mode=WAL")
-        con.execute("""CREATE TABLE IF NOT EXISTS receipts (
-            id TEXT PRIMARY KEY,
-            kind TEXT NOT NULL,
-            actor TEXT,
-            workspace TEXT,
-            summary TEXT,
-            payload_json TEXT NOT NULL,
-            payload_sha256 TEXT NOT NULL,
-            created_at TEXT NOT NULL
-        )""")
-        con.execute("""CREATE INDEX IF NOT EXISTS idx_receipts_kind_time ON receipts(kind, created_at)""")
-        con.execute("""CREATE TABLE IF NOT EXISTS request_log (
-            id TEXT PRIMARY KEY,
-            method TEXT,
-            path TEXT,
-            query TEXT,
-            client TEXT,
-            user_agent TEXT,
-            status_code INTEGER,
-            duration_ms REAL,
-            request_sha256 TEXT,
-            response_sha256 TEXT,
-            created_at TEXT NOT NULL
-        )""")
-        con.execute("""CREATE TABLE IF NOT EXISTS tools (
-            name TEXT PRIMARY KEY,
-            description TEXT,
-            mode TEXT NOT NULL,
-            template TEXT NOT NULL,
-            input_schema_json TEXT DEFAULT '{}',
-            required_args_json TEXT DEFAULT '[]',
-            enabled INTEGER DEFAULT 1,
-            created_at TEXT NOT NULL,
-            updated_at TEXT NOT NULL
-        )""")
-        con.execute("""CREATE TABLE IF NOT EXISTS sessions (
-            id TEXT PRIMARY KEY,
-            workspace TEXT NOT NULL,
-            cwd TEXT NOT NULL,
-            created_at TEXT NOT NULL,
-            updated_at TEXT NOT NULL
-        )""")
-
-
-def save_json(path: Path, payload: Any) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    tmp = path.with_suffix(path.suffix + ".tmp")
-    tmp.write_text(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True, default=str), encoding="utf-8")
-    tmp.replace(path)
-
-
-def make_receipt(kind: str, payload: Dict[str, Any], *, actor: str = "gpt", workspace: Optional[str] = None, summary: str = "") -> Dict[str, Any]:
-    rid = f"receipt_{uuid.uuid4().hex[:16]}"
-    clean = json.loads(json.dumps(payload, ensure_ascii=False, default=str))
-    digest = sha256_json(clean)
-    receipt = {
-        "id": rid,
-        "kind": kind,
-        "actor": actor,
-        "workspace": workspace,
-        "summary": summary or "",
-        "payload_sha256": digest,
-        "payload": clean,
-        "created_at": now_iso(),
-    }
-    save_json(RECEIPTS_ROOT / f"{rid}.json", receipt)
-    with sqlite3.connect(LEDGER_DB, timeout=5) as con:
-        con.execute(
-            "INSERT INTO receipts(id, kind, actor, workspace, summary, payload_json, payload_sha256, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
-            (rid, kind, actor, workspace, summary or "", json.dumps(clean, ensure_ascii=False), digest, receipt["created_at"]),
-        )
-    return {k: v for k, v in receipt.items() if k != "payload"}
-
-
-def attach_receipt(payload: Dict[str, Any], kind: str, *, actor: str = "gpt", workspace: Optional[str] = None, summary: str = "") -> Dict[str, Any]:
-    try:
-        payload["receipt"] = make_receipt(kind, payload, actor=actor, workspace=workspace, summary=summary)
-        payload["receipt_error"] = None
-    except Exception as e:
-        payload["receipt"] = None
-        payload["receipt_error"] = f"{type(e).__name__}: {str(e)}"
-    return payload
-
-
-def private_or_internal_host(hostname: str) -> bool:
-    if not hostname:
-        return True
-    h = hostname.lower().strip(".")
-    if h in {"localhost", "metadata.google.internal"} or h.endswith(".local") or h.endswith(".internal"):
-        return True
-    try:
-        ip = ipaddress.ip_address(h)
-        return ip.is_private or ip.is_loopback or ip.is_link_local or ip.is_multicast or ip.is_reserved or ip.is_unspecified
-    except ValueError:
-        pass
-    try:
-        infos = socket.getaddrinfo(h, None)
-    except socket.gaierror:
-        raise HTTPException(status_code=400, detail="Could not resolve hostname")
-    for info in infos:
-        ip = ipaddress.ip_address(info[4][0])
-        if ip.is_private or ip.is_loopback or ip.is_link_local or ip.is_multicast or ip.is_reserved or ip.is_unspecified:
-            return True
-    return False
-
-
-def extract_title_text(raw: bytes, content_type: str) -> Dict[str, str]:
-    text = raw.decode("utf-8", errors="replace")
-    if "html" in (content_type or "").lower() or "<html" in text[:5000].lower():
-        title_match = re.search(r"<title[^>]*>(.*?)</title>", text, flags=re.I | re.S)
-        title = html.unescape(re.sub(r"\s+", " ", title_match.group(1)).strip()) if title_match else ""
-        no_script = re.sub(r"<(script|style)[^>]*>.*?</\1>", " ", text, flags=re.I | re.S)
-        no_tags = re.sub(r"<[^>]+>", " ", no_script)
-        clean = html.unescape(re.sub(r"\s+", " ", no_tags).strip())
-        return {"title": title, "text": clean}
-    return {"title": "", "text": re.sub(r"\s+", " ", text).strip()}
-
-
-def render_template(template: str, params: Dict[str, Any], required_args: List[str]) -> str:
-    missing = [x for x in required_args if x not in params or params[x] is None]
-    if missing:
-        raise HTTPException(status_code=422, detail={"missing_required_args": missing})
-    rendered = template
-    for k, v in params.items():
-        val = str(v).replace("\\", "\\\\").replace('"', '\\"').replace("`", "\\`").replace("$", "\\$")
-        rendered = rendered.replace("{{" + k + "}}", val)
-    unresolved = re.findall(r"{{\s*([a-zA-Z0-9_.$-]+)\s*}}", rendered)
-    if unresolved:
-        raise HTTPException(status_code=422, detail={"unresolved_params": unresolved})
-    return rendered
-
-
-class TerminalRunRequest(BaseModel):
-    workspace: str = "default"
-    command: str
-    timeout_seconds: int = Field(default=10, ge=1, le=30)
-    cwd: str = "."
-    create_receipt: bool = True
-
-
-class PythonRunRequest(BaseModel):
-    workspace: str = "default"
-    code: str
-    timeout_seconds: int = Field(default=10, ge=1, le=30)
-    create_receipt: bool = True
-
-
-class FileWriteRequest(BaseModel):
-    workspace: str = "default"
-    path: str
-    content: str
-    encoding: str = "utf-8"
-
-
-class FileReadRequest(BaseModel):
-    workspace: str = "default"
-    path: str
-    max_bytes: int = Field(default=120000, ge=1, le=20000000)
-
-
-class FileListRequest(BaseModel):
-    workspace: str = "default"
-    path: str = "."
-    max_items: int = Field(default=250, ge=1, le=5000)
-
-
-class ArtifactRequest(BaseModel):
-    workspace: str = "default"
-    filename: str
-    content: str
-    content_type: str = "text/plain"
-
-
-class WebScrapeRequest(BaseModel):
-    url: str
-    workspace: str = "scrapes"
-    save: bool = True
-    max_bytes: int = Field(default=SCRAPE_MAX_BYTES, ge=1, le=3000000)
-    preview_chars: int = Field(default=SCRAPE_PREVIEW_CHARS, ge=100, le=50000)
-
-
-class ToolRegisterRequest(BaseModel):
-    name: str
-    description: str = ""
-    mode: str = Field(default="command", description="command or python")
-    template: str
-    input_schema: Dict[str, Any] = Field(default_factory=dict)
-    required_args: List[str] = []
-    enabled: bool = True
-
-
-class ToolInvokeRequest(BaseModel):
-    workspace: str = "default"
-    params: Dict[str, Any] = Field(default_factory=dict)
-    timeout_seconds: int = Field(default=10, ge=1, le=30)
-
-
-class SessionCreateRequest(BaseModel):
-    workspace: str = "default"
-    cwd: str = "."
-
-
-class SessionRunRequest(BaseModel):
-    session_id: str
-    command: str
-    timeout_seconds: int = Field(default=10, ge=1, le=30)
-
-
-class AnalyzeRequest(BaseModel):
-    request_text: str
-    context: Dict[str, Any] = {}
-
-
-class RelaunchRequest(BaseModel):
-    reason: str = "manual relaunch requested by Custom GPT"
-    delay_seconds: int = Field(default=1, ge=0, le=10)
-
-
-@app.middleware("http")
-async def request_analysis_middleware(request: Request, call_next):
-    started = time.time()
-    body = b""
-    if request.method in {"POST", "PUT", "PATCH"}:
-        body = await request.body()
-
-        async def receive():
-            return {"type": "http.request", "body": body, "more_body": False}
-        request = Request(request.scope, receive)
-
-    response = await call_next(request)
-    duration_ms = round((time.time() - started) * 1000, 3)
-
-    try:
-        rid = f"req_{uuid.uuid4().hex[:16]}"
-        with sqlite3.connect(LEDGER_DB, timeout=5) as con:
-            con.execute(
-                "INSERT INTO request_log(id, method, path, query, client, user_agent, status_code, duration_ms, request_sha256, response_sha256, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
-                (
-                    rid,
-                    request.method,
-                    request.url.path,
-                    str(request.url.query),
-                    request.client.host if request.client else "",
-                    request.headers.get("user-agent", ""),
-                    response.status_code,
-                    duration_ms,
-                    sha256_bytes(body),
-                    "",
-                    now_iso(),
-                ),
-            )
-    except Exception:
-        pass
-    return response
-
-
-@app.on_event("startup")
-def startup():
-    init_db()
-    # Ensure quadrant workspaces exist
-    for qws in ["quad-a", "quad-b", "quad-c", "quad-d"]:
-        (WORKSPACE_ROOT / qws).mkdir(parents=True, exist_ok=True)
-    try:
-        ws_dir = os.path.join(os.environ.get("WORKSPACE_DIR", "/data/workspaces"), "default")
-        os.makedirs(ws_dir, exist_ok=True)
-        ui_path = os.path.join(ws_dir, "morphos_ui.html")
-        if not os.path.exists(ui_path):
-            # Embed the MorphOS dashboard inline
-            morphos_ui = """<!DOCTYPE html>
-<html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
-<title>MorphOS — Multi-Node Orchestrator</title>
-<style>
-*{margin:0;padding:0;box-sizing:border-box}
-body{background:#0a0a0f;color:#e0e0e8;font-family:'SF Mono',Monaco,monospace}
-.header{padding:12px 24px;background:rgba(10,10,15,0.95);border-bottom:1px solid #1a1a2e;display:flex;align-items:center;justify-content:space-between}
-.logo{font-size:18px;font-weight:bold;color:#7c5cfc}.logo span{color:#e0e0e8}
-.main{padding:24px;display:grid;grid-template-columns:1fr 1fr;gap:20px}
-@media(max-width:768px){.main{grid-template-columns:1fr}}
-.card{background:#12121a;border:1px solid #1e1e30;border-radius:12px;padding:20px}
-.card h2{font-size:14px;color:#7c5cfc;margin-bottom:16px;text-transform:uppercase;letter-spacing:1px}
-.node{background:#1a1a2e;border-radius:8px;padding:14px;margin-bottom:8px;display:flex;justify-content:space-between;align-items:center}
-.node-name{font-size:14px;font-weight:600}.node-kind{font-size:11px;color:#666}
-.node-status{font-size:11px;padding:4px 10px;border-radius:20px}
-.node-status.online{background:rgba(74,222,128,0.15);color:#4ade80}
-.node-status.offline{background:rgba(248,113,113,0.15);color:#f87171}
-.terminal{background:#08080d;border-radius:8px;padding:16px;font-size:13px;max-height:300px;overflow-y:auto;border:1px solid #1e1e30}
-.terminal-line{color:#4ade80;margin-bottom:4px}.terminal-line.info{color:#60a5fa}.terminal-line.error{color:#f87171}
-.btn{padding:10px 20px;border-radius:8px;border:none;cursor:pointer;font-size:13px;font-family:inherit}
-.btn-pause{background:rgba(250,204,21,0.2);color:#facc15;border:1px solid #facc15}
-.btn-resume{background:rgba(74,222,128,0.2);color:#4ade80;border:1px solid #4ade80}
-.cmd-input{display:flex;gap:8px;margin-top:12px}
-.cmd-input input{flex:1;background:#08080d;border:1px solid #2a2a40;color:#e0e0e8;padding:10px;border-radius:8px;font-family:monospace}
-.cmd-input button{background:#7c5cfc;color:#fff;border:none;padding:10px 20px;border-radius:8px;cursor:pointer}
-.app-tag{background:#1a1a2e;padding:6px 12px;border-radius:20px;font-size:12px;border:1px solid #2a2a40;display:inline-block;margin:4px}
-.app-tag.frontmost{border-color:#7c5cfc;color:#7c5cfc}
-.chain{background:#1a1a2e;border-radius:8px;padding:12px;margin-bottom:8px;cursor:pointer}
-.chain-prompt{font-size:13px;margin-bottom:4px}.chain-meta{font-size:11px;color:#666}
-</style></head><body>
-<div class="header"><div class="logo">Morph<span>OS</span></div>
-<div style="font-size:12px;display:flex;gap:16px">
-<span><span style="color:#4ade80">●</span> <span id="health">connecting</span></span>
-<span><span id="node-count">0</span> nodes</span>
-<span><span id="chain-count">0</span> chains</span>
-</div></div>
-<div class="main">
-<div class="card"><h2>Nodes</h2><div id="nodes"></div>
-<div style="margin-top:16px;display:flex;gap:12px">
-<button class="btn btn-pause" onclick="speak(true)">Pause</button>
-<button class="btn btn-resume" onclick="speak(false)">Resume</button></div></div>
-<div class="card"><h2>Prompt Chains</h2><div id="chains" style="max-height:300px;overflow-y:auto">No chains yet</div></div>
-<div class="card"><h2>Terminal</h2><div class="terminal" id="term"><div class="terminal-line info">MorphOS terminal — commands run on this node.</div></div>
-<div class="cmd-input"><input id="cmd" placeholder="Run command..." onkeypress="if(event.key==='Enter')run()"><button onclick="run()">Run</button></div></div>
-<div class="card"><h2>Query</h2><div class="cmd-input"><input id="q" placeholder="What did my prompt do?" onkeypress="if(event.key==='Enter')ask()"><button onclick="ask()">Ask</button></div>
-<div class="terminal" id="qr" style="margin-top:12px"><div class="terminal-line info">Ask about chains.</div></div></div>
-</div>
-<script>
-const A=location.origin;const K='';
-async function api(p,m='GET',b){const o={method:m,headers:{'Content-Type':'application/json'}};if(b)o.body=JSON.stringify(b);try{return await(await fetch(A+p,o)).json()}catch(e){return{error:e.message}}}
-async function r(){const h=await api('/health');document.getElementById('health').textContent=h.status||'?';document.getElementById('node-count').textContent=h.nodes||0;document.getElementById('chain-count').textContent=h.receipts||0;
-try{const n=await api('/nodes');const el=document.getElementById('nodes');if(n.nodes&&n.nodes.length)el.innerHTML=n.nodes.map(x=>`<div class="node"><div><div class="node-name">${x.name}</div><div class="node-kind">${x.kind}</div></div><div class="node-status ${x.status}">${x.status}</div></div>`).join('');else el.innerHTML='<span style="color:#666">No nodes</span>'}catch(e){}try{const c=await api('/chains');const cl=document.getElementById('chains');if(c.chains&&c.chains.length)cl.innerHTML=c.chains.slice(-10).reverse().map(x=>`<div class="chain"><div class="chain-prompt">${x.text}</div><div class="chain-meta">${x.events} events — ${x.status}</div></div>`).join('')}catch(e){}}
-async function speak(s){await api('/speak','POST',{speaking:s});r()}
-async function run(){const c=document.getElementById('cmd').value;if(!c)return;const t=document.getElementById('term');t.innerHTML+=`<div class="terminal-line info">> ${c}</div>`;const res=await api('/terminal/run','POST',{command:c,node:'auto'});if(res.stdout)t.innerHTML+=`<div class="terminal-line">${res.stdout}</div>`;if(res.stderr)t.innerHTML+=`<div class="terminal-line error">${res.stderr}</div>`;if(res.error)t.innerHTML+=`<div class="terminal-line error">${res.error}</div>`;t.scrollTop=t.scrollHeight;document.getElementById('cmd').value=''}
-async function ask(){const q=document.getElementById('q').value;if(!q)return;const el=document.getElementById('qr');el.innerHTML=`<div class="terminal-line info">Q: ${q}</div>`;const r=await api('/query','POST',{question:q});el.innerHTML+=`<div class="terminal-line">${JSON.stringify(r,null,2)}</div>`;el.scrollTop=el.scrollHeight;document.getElementById('q').value=''}
-r();setInterval(r,5000);
-</script></body></html>"""
-            with open(ui_path, "w") as f:
-                f.write(morphos_ui)
-            print(f"Wrote MorphOS UI to {ui_path}")
-    except Exception as e:
-        print(f"Could not write MorphOS UI: {e}")
-
-
-# ── MorphOS 4-Quadrant UI (embedded) ──
-MORPHOS_QUAD_UI = """<!DOCTYPE html>
-<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
-<title>MorphOS — 4-Quadrant Terminal Lab</title>
-<style>
-*{margin:0;padding:0;box-sizing:border-box}
-body{background:#06060a;color:#c0c0d0;font-family:'SF Mono',Monaco,monospace;overflow:hidden;height:100vh}
-.header{height:44px;padding:0 20px;background:rgba(10,10,18,0.98);border-bottom:1px solid #1a1a2e;display:flex;align-items:center;justify-content:space-between;z-index:100}
-.logo{font-size:16px;font-weight:bold;color:#7c5cfc}.logo span{color:#c0c0d0}
-.header-info{font-size:11px;color:#555;display:flex;gap:16px;align-items:center}
-.header-info .dot{width:8px;height:8px;border-radius:50%;display:inline-block;margin-right:4px}
-.dot.green{background:#4ade80}.dot.red{background:#f87171}.dot.yellow{background:#facc15}
-.grid{display:grid;grid-template-columns:1fr 1fr;grid-template-rows:1fr 1fr;height:calc(100vh - 44px);gap:1px;background:#0a0a14}
-.quadrant{background:#0a0a10;display:flex;flex-direction:column;overflow:hidden;position:relative}
-.quadrant-header{height:32px;padding:0 12px;background:#0e0e18;border-bottom:1px solid #1a1a2e;display:flex;align-items:center;justify-content:space-between;flex-shrink:0}
-.quadrant-title{font-size:12px;font-weight:600;color:#7c5cfc;display:flex;align-items:center;gap:8px}
-.quadrant-title .qbadge{background:#1a1a2e;padding:2px 8px;border-radius:4px;font-size:10px;color:#888}
-.quadrant-status{font-size:10px;color:#555}
-.quadrant-status .dot{width:6px;height:6px;border-radius:50%;display:inline-block;margin-right:3px}
-.terminal{flex:1;overflow-y:auto;padding:10px 12px;font-size:12px;line-height:1.5;background:#06060a;cursor:text}
-.terminal .line{white-space:pre-wrap;word-break:break-all}
-.terminal .line.cmd{color:#7c5cfc}.terminal .line.out{color:#c0c0d0}.terminal .line.err{color:#f87171}
-.terminal .line.sys{color:#60a5fa}.terminal .line.ok{color:#4ade80}.terminal .line.dim{color:#444}
-.cmd-bar{display:flex;gap:0;background:#0e0e18;border-top:1px solid #1a1a2e;flex-shrink:0}
-.cmd-bar .prompt{color:#7c5cfc;padding:8px 10px;font-size:12px;user-select:none}
-.cmd-bar input{flex:1;background:transparent;border:none;color:#c0c0d0;padding:8px 4px;font-family:inherit;font-size:12px;outline:none}
-.cmd-bar input::placeholder{color:#333}
-.modal-overlay{position:fixed;top:0;left:0;right:0;bottom:0;background:rgba(0,0,0,0.7);z-index:200;display:none;align-items:center;justify-content:center}
-.modal-overlay.active{display:flex}
-.modal{background:#12121a;border:1px solid #2a2a40;border-radius:12px;padding:24px;max-width:500px;width:90%}
-.modal h2{color:#7c5cfc;font-size:16px;margin-bottom:16px}
-.modal p{color:#888;font-size:13px;margin-bottom:16px;line-height:1.6}
-.modal .field{margin-bottom:12px}.modal label{font-size:11px;color:#555;display:block;margin-bottom:4px}
-.modal input,.modal select{width:100%;background:#08080d;border:1px solid #2a2a40;color:#c0c0d0;padding:8px 10px;border-radius:6px;font-family:inherit;font-size:12px}
-.modal .btns{display:flex;gap:8px;justify-content:flex-end;margin-top:16px}
-.modal .btn{padding:8px 16px;border-radius:6px;border:none;cursor:pointer;font-size:12px;font-family:inherit}
-.modal .btn-primary{background:#7c5cfc;color:#fff}.modal .btn-cancel{background:#1a1a2e;color:#888;border:1px solid #2a2a40}
-@keyframes pulse{0%,100%{opacity:1}50%{opacity:.3}}
-.working{animation:pulse 1.5s ease-in-out infinite}
-</style></head><body>
-<div class="header"><div class="logo">Morph<span>OS</span> — Quad Terminal Lab</div>
-<div class="header-info">
-<span><span class="dot green" id="conn-dot"></span><span id="conn-status">Connected</span></span>
-<span id="speaking-state">Morphing</span>
-<button id="speak-btn" onclick="toggleSpeak()" style="background:rgba(250,204,21,0.15);color:#facc15;border:1px solid #facc15;padding:4px 12px;border-radius:6px;cursor:pointer;font-size:11px;font-family:inherit">Pause</button>
-</div></div>
-<div class="grid" id="grid">
-<div class="quadrant" id="q1" data-qid="q1" data-name="App Lab A" data-workspace="quad-a">
-<div class="quadrant-header"><div class="quadrant-title"><span class="qbadge">Q1</span><span id="q1-name">App Lab A</span></div>
-<div class="quadrant-status"><span class="dot green" id="q1-dot"></span><span id="q1-status">idle</span></div></div>
-<div class="terminal" id="q1-term" onclick="focusQuad('q1')"></div>
-<div class="cmd-bar"><span class="prompt">$</span><input id="q1-input" placeholder="type command or 'help'..." onkeydown="if(event.key==='Enter')runCmd('q1',this.value);if(event.key==='ArrowUp')historyNav('q1',-1);if(event.key==='ArrowDown')historyNav('q1',1)"></div>
-</div>
-<div class="quadrant" id="q2" data-qid="q2" data-name="App Lab B" data-workspace="quad-b">
-<div class="quadrant-header"><div class="quadrant-title"><span class="qbadge">Q2</span><span id="q2-name">App Lab B</span></div>
-<div class="quadrant-status"><span class="dot green" id="q2-dot"></span><span id="q2-status">idle</span></div></div>
-<div class="terminal" id="q2-term" onclick="focusQuad('q2')"></div>
-<div class="cmd-bar"><span class="prompt">$</span><input id="q2-input" placeholder="type command or 'help'..." onkeydown="if(event.key==='Enter')runCmd('q2',this.value);if(event.key==='ArrowUp')historyNav('q2',-1);if(event.key==='ArrowDown')historyNav('q2',1)"></div>
-</div>
-<div class="quadrant" id="q3" data-qid="q3" data-name="App Lab C" data-workspace="quad-c">
-<div class="quadrant-header"><div class="quadrant-title"><span class="qbadge">Q3</span><span id="q3-name">App Lab C</span></div>
-<div class="quadrant-status"><span class="dot green" id="q3-dot"></span><span id="q3-status">idle</span></div></div>
-<div class="terminal" id="q3-term" onclick="focusQuad('q3')"></div>
-<div class="cmd-bar"><span class="prompt">$</span><input id="q3-input" placeholder="type command or 'help'..." onkeydown="if(event.key==='Enter')runCmd('q3',this.value);if(event.key==='ArrowUp')historyNav('q3',-1);if(event.key==='ArrowDown')historyNav('q3',1)"></div>
-</div>
-<div class="quadrant" id="q4" data-qid="q4" data-name="App Lab D" data-workspace="quad-d">
-<div class="quadrant-header"><div class="quadrant-title"><span class="qbadge">Q4</span><span id="q4-name">App Lab D</span></div>
-<div class="quadrant-status"><span class="dot green" id="q4-dot"></span><span id="q4-status">idle</span></div></div>
-<div class="terminal" id="q4-term" onclick="focusQuad('q4')"></div>
-<div class="cmd-bar"><span class="prompt">$</span><input id="q4-input" placeholder="type command or 'help'..." onkeydown="if(event.key==='Enter')runCmd('q4',this.value);if(event.key==='ArrowUp')historyNav('q4',-1);if(event.key==='ArrowDown')historyNav('q4',1)"></div>
-</div>
-</div>
-<div class="modal-overlay" id="rename-modal"><div class="modal"><h2>Configure Quadrant</h2>
-<p>Each quadrant is an independent Linux terminal workspace. ChatGPT can target any quadrant by workspace name.</p>
-<div class="field"><label>Quadrant</label><select id="rename-qid"><option value="q1">Q1</option><option value="q2">Q2</option><option value="q3">Q3</option><option value="q4">Q4</option></select></div>
-<div class="field"><label>App Name</label><input id="rename-name" placeholder="e.g. React Frontend"></div>
-<div class="field"><label>Workspace (for API calls)</label><input id="rename-ws" placeholder="e.g. quad-a"></div>
-<div class="btns"><button class="btn btn-cancel" onclick="closeModal()">Cancel</button><button class="btn btn-primary" onclick="applyRename()">Save</button></div>
-</div></div>
-<script>
-const QUADS=['q1','q2','q3','q4'];const API_BASE=window.location.origin;let focused='q1';let histories={q1:[],q2:[],q3:[],q4:[]};let histIdx={q1:-1,q2:-1,q3:-1,q4:-1};let speaking=false;
-function addLine(qid,text,cls='out'){const t=document.getElementById(qid+'-term');const d=document.createElement('div');d.className='line '+cls;d.textContent=text;t.appendChild(d);t.scrollTop=t.scrollHeight;}
-function setStatus(qid,status,color='green'){document.getElementById(qid+'-status').textContent=status;const dot=document.getElementById(qid+'-dot');dot.className='dot '+color;if(status==='working')dot.classList.add('working');}
-async function runCmd(qid,cmd){if(!cmd.trim())return;const input=document.getElementById(qid+'-input');input.value='';histories[qid].push(cmd);histIdx[qid]=histories[qid].length;
-if(cmd.trim()==='help'){addLine(qid,'-- MorphOS Quad Terminal --','sys');addLine(qid,'Each quadrant = independent Linux workspace.','dim');addLine(qid,'Special: help, clear, rename, apps, ls','dim');return;}
-if(cmd.trim()==='clear'){document.getElementById(qid+'-term').innerHTML='';return;}
-if(cmd.trim()==='rename'){openRenameModal(qid);return;}
-if(cmd.trim()==='apps'){QUADS.forEach(q2=>{addLine(qid,q2.toUpperCase()+': '+document.getElementById(q2).dataset.name+' (ws: '+document.getElementById(q2).dataset.workspace+')','out');});return;}
-const ws=document.getElementById(qid).dataset.workspace;addLine(qid,'$ '+cmd,'cmd');setStatus(qid,'working','yellow');
-try{const r=await fetch(API_BASE+'/terminal/run',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({command:cmd,workspace:ws,timeout_seconds:25,create_receipt:false})});const d=await r.json();if(d.stdout)addLine(qid,d.stdout,'out');if(d.stderr)addLine(qid,d.stderr,'err');const rc=d.returncode??0;if(rc===0){setStatus(qid,'idle','green');addLine(qid,'[exit '+rc+']','dim');}else{setStatus(qid,'error','red');addLine(qid,'[exit '+rc+']','err');}}catch(e){addLine(qid,'Error: '+e.message,'err');setStatus(qid,'offline','red');}}
-function historyNav(qid,dir){const h=histories[qid];if(!h.length)return;histIdx[qid]=Math.max(-1,Math.min(h.length-1,histIdx[qid]+dir));document.getElementById(qid+'-input').value=histIdx[qid]>=0?h[histIdx[qid]]:'';}
-function focusQuad(qid){focused=qid;QUADS.forEach(q=>{document.getElementById(q).style.border=q===qid?'1px solid #7c5cfc':'none';});setTimeout(()=>document.getElementById(qid+'-input').focus(),0);}
-async function toggleSpeak(){speaking=!speaking;const btn=document.getElementById('speak-btn');const st=document.getElementById('speaking-state');try{await fetch(API_BASE+'/speak',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({speaking:speaking})});}catch{}if(speaking){btn.textContent='Resume';btn.style.color='#4ade80';btn.style.borderColor='#4ade80';st.textContent='Paused';st.style.color='#facc15';}else{btn.textContent='Pause';btn.style.color='#facc15';btn.style.borderColor='#facc15';st.textContent='Morphing';st.style.color='#4ade80';}}
-function openRenameModal(qid){document.getElementById('rename-qid').value=qid;document.getElementById('rename-name').value=document.getElementById(qid).dataset.name;document.getElementById('rename-ws').value=document.getElementById(qid).dataset.workspace;document.getElementById('rename-modal').classList.add('active');}
-function closeModal(){document.getElementById('rename-modal').classList.remove('active');}
-function applyRename(){const qid=document.getElementById('rename-qid').value;const n=document.getElementById('rename-name').value;const w=document.getElementById('rename-ws').value;document.getElementById(qid).dataset.name=n;document.getElementById(qid).dataset.workspace=w;document.getElementById(qid+'-name').textContent=n;addLine(qid,'Renamed: '+n+' (ws: '+w+')','sys');closeModal();}
-async function healthCheck(){try{await fetch(API_BASE+'/health');document.getElementById('conn-status').textContent='Connected';document.getElementById('conn-dot').className='dot green';}catch{document.getElementById('conn-status').textContent='Offline';document.getElementById('conn-dot').className='dot red';}}
-async function pollGPT(){try{const r=await fetch(API_BASE+'/receipts?limit=5');const d=await r.json();if(d.receipts){d.receipts.forEach(r=>{if(r.kind==='terminal.run'&&r.workspace){const qid=QUADS.find(q=>document.getElementById(q).dataset.workspace===r.workspace);if(qid&&r.summary){const ex=document.querySelector('[data-rc="'+r.id+'"]');if(!ex)addLine(qid,'[GPT] '+r.summary,'sys');}}});}}catch{}}
-QUADS.forEach(qid=>{addLine(qid,'-- MorphOS Quad Terminal --','sys');addLine(qid,'Workspace: '+document.getElementById(qid).dataset.workspace,'dim');addLine(qid,"Type 'help'. GPT targets via workspace name.",'dim');addLine(qid,'','dim');});
-focusQuad('q1');healthCheck();setInterval(healthCheck,15000);setInterval(pollGPT,5000);
-</script></body></html>"""
-
-@app.get("/", response_class=HTMLResponse, include_in_schema=False)
-def home():
-    return HTMLResponse(MORPHOS_QUAD_UI)
-
-
-@app.get("/favicon.ico", include_in_schema=False)
-def favicon():
-    return PlainTextResponse("", status_code=204)
-
-
-@app.get("/health", operation_id="health")
-def health():
+from fastapi import FastAPI, Request, Query
+from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+
+# ─── Config ──────────────────────────────────────────────────
+# The DB is bundled in the Space repo under /data/masseurs.db
+# Falls back to a small demo DB if not present.
+DB_PATH = Path(os.environ.get("DB_PATH", "/data/masseurs.db"))
+if not DB_PATH.exists():
+    DB_PATH = Path(__file__).parent / "data" / "masseurs.db"
+
+BASE_DIR = Path(__file__).parent
+TEMPLATES_DIR = BASE_DIR / "templates"
+STATIC_DIR = BASE_DIR / "static"
+
+app = FastAPI(title="MasseurBoost Endpoint", docs_url="/api/docs")
+
+if TEMPLATES_DIR.exists():
+    templates = Jinja2Templates(directory=str(TEMPLATES_DIR))
+if STATIC_DIR.exists():
+    app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
+
+RENTMASSEUR_BASE = "https://rentmasseur.com"
+
+
+def get_db():
+    conn = sqlite3.connect(str(DB_PATH))
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+# ─── Health ──────────────────────────────────────────────────
+@app.get("/api/health")
+async def health():
+    return {"status": "ok", "db": str(DB_PATH), "db_exists": DB_PATH.exists()}
+
+
+# ─── Market stats ────────────────────────────────────────────
+@app.get("/api/market-stats")
+async def market_stats():
+    if not DB_PATH.exists():
+        return {"error": "DB not found", "total_masseurs": 0}
+    conn = get_db()
+    c = conn.cursor()
+    total = c.execute("SELECT COUNT(*) FROM masseurs").fetchone()[0]
+    cities = c.execute("SELECT COUNT(DISTINCT city) FROM masseurs").fetchone()[0]
+    gold = c.execute("SELECT COUNT(*) FROM masseurs WHERE is_gold=1").fetchone()[0]
+    avg_vpd = c.execute("SELECT AVG(views_per_day) FROM masseurs WHERE views_per_day > 0").fetchone()[0]
+    conn.close()
     return {
-        "ok": True,
-        "app": APP_NAME,
-        "version": "4.0.0",
-        "public_base_url": PUBLIC_BASE_URL,
-        "openapi_url": f"{PUBLIC_BASE_URL}/openapi.json",
-        "admin_token_enabled": bool(ADMIN_TOKEN),
-        "time": now_iso(),
+        "total_masseurs": total,
+        "cities_covered": cities,
+        "gold_members": gold,
+        "avg_views_per_day": round(avg_vpd or 0, 1),
     }
 
 
-class SpeakRequest(BaseModel):
-    speaking: bool
-
-
-_SPEAKING = False
-
-
-@app.post("/speak", operation_id="speak_toggle")
-def speak_toggle(req: SpeakRequest):
-    global _SPEAKING
-    _SPEAKING = req.speaking
-    return {"speaking": _SPEAKING, "state": "paused" if _SPEAKING else "morphing"}
-
+# ─── Search masseurs (with profile URLs) ─────────────────────
+@app.get("/api/search")
+async def search_masseurs(
+    city: str = Query(""),
+    limit: int = Query(20, le=100),
+    offset: int = Query(0),
+    sort: str = Query("views_per_day"),
+    min_vpd: float = Query(0),
+):
+    if not DB_PATH.exists():
+        return {"error": "DB not found", "total": 0, "results": []}
+    conn = get_db()
+    c = conn.cursor()
+
+    where = "WHERE views_per_day >= ?"
+    params = [min_vpd]
+    if city:
+        where += " AND city = ?"
+        params.append(city)
+
+    valid_sorts = {"views_per_day", "visits", "reviews_count", "rating", "bio"}
+    sort = sort if sort in valid_sorts else "views_per_day"
+
+    total = c.execute(f"SELECT COUNT(*) FROM masseurs {where}", params).fetchone()[0]
+    rows = c.execute(
+        f"SELECT username, city, views_per_day, visits, member_since, rating, reviews_count, is_gold, photo_count FROM masseurs {where} ORDER BY {sort} DESC LIMIT ? OFFSET ?",
+        params + [limit, offset],
+    ).fetchall()
+    conn.close()
 
-@app.get("/speak", operation_id="speak_status")
-def speak_status():
-    return {"speaking": _SPEAKING, "state": "paused" if _SPEAKING else "morphing"}
-
-
-@app.get("/capabilities", operation_id="get_capabilities")
-def capabilities():
     return {
-        "kernel": APP_NAME,
-        "version": "4.0.0",
-        "features": [
-            "admin_protected_self_relaunch",
-            "controlled_terminal",
-            "python_execution",
-            "public_web_scrape_with_private_ip_block",
-            "file_save_read_list",
-            "artifact_url_issue",
-            "persistent_json_receipts",
-            "sqlite_ledger",
-            "request_analysis_log",
-            "persistent_parameterized_tools",
-            "sessions",
+        "total": total,
+        "results": [
+            {
+                "username": r[0],
+                "city": r[1],
+                "vpd": r[2],
+                "visits": r[3],
+                "since": r[4],
+                "rating": r[5],
+                "reviews": r[6],
+                "gold": bool(r[7]),
+                "photos": r[8],
+                "profile_url": f"{RENTMASSEUR_BASE}/{r[0]}",
+                "internal_url": f"/profile/{r[0]}",
+            }
+            for r in rows
         ],
-        "mutation_auth": "X-Admin-Token required for relaunch and persistent tool mutation when ADMIN_TOKEN is set",
-        "schema": f"{PUBLIC_BASE_URL}/openapi.json",
-    }
-
-
-@app.post("/terminal/run", operation_id="run_terminal")
-async def terminal_run(req: TerminalRunRequest):
-    validate_command(req.command)
-    cwd = workspace_path(req.workspace, req.cwd)
-    proc = await asyncio.create_subprocess_shell(
-        req.command,
-        cwd=str(cwd),
-        stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.PIPE,
-        env={**os.environ, "HOME": str(workspace_path(req.workspace, "."))},
-    )
-    try:
-        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=req.timeout_seconds)
-    except asyncio.TimeoutError:
-        proc.kill()
-        await proc.communicate()
-        payload = {"workspace": req.workspace, "cwd": str(cwd), "command": req.command, "returncode": 124, "stdout": "", "stderr": "Command timed out", "truncated": False}
-        return attach_receipt(payload, "terminal.timeout", workspace=req.workspace, summary=req.command[:240])
-
-    payload = {
-        "workspace": req.workspace,
-        "cwd": str(cwd),
-        "command": req.command,
-        "returncode": int(proc.returncode or 0),
-        "stdout": stdout[:MAX_OUTPUT_BYTES].decode("utf-8", errors="replace"),
-        "stderr": stderr[:MAX_OUTPUT_BYTES].decode("utf-8", errors="replace"),
-        "truncated": len(stdout) > MAX_OUTPUT_BYTES or len(stderr) > MAX_OUTPUT_BYTES,
-    }
-    if req.create_receipt:
-        payload = attach_receipt(payload, "terminal.run", workspace=req.workspace, summary=req.command[:240])
-    return payload
-
-
-@app.post("/python/run", operation_id="run_python")
-async def python_run(req: PythonRunRequest):
-    ws = workspace_path(req.workspace, ".")
-    run_id = uuid.uuid4().hex[:12]
-    script = ws / f"_run_{run_id}.py"
-    script.write_text(req.code, encoding="utf-8")
-    proc = await asyncio.create_subprocess_shell(
-        f"python {shlex.quote(script.name)}",
-        cwd=str(ws),
-        stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.PIPE,
-        env={**os.environ, "HOME": str(ws), "PYTHONUNBUFFERED": "1"},
-    )
-    try:
-        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=req.timeout_seconds)
-    except asyncio.TimeoutError:
-        proc.kill()
-        await proc.communicate()
-        payload = {"workspace": req.workspace, "script": script.name, "returncode": 124, "stdout": "", "stderr": "Python timed out", "truncated": False}
-        return attach_receipt(payload, "python.timeout", workspace=req.workspace, summary=script.name)
-
-    payload = {
-        "workspace": req.workspace,
-        "script": script.name,
-        "returncode": int(proc.returncode or 0),
-        "stdout": stdout[:MAX_OUTPUT_BYTES].decode("utf-8", errors="replace"),
-        "stderr": stderr[:MAX_OUTPUT_BYTES].decode("utf-8", errors="replace"),
-        "truncated": len(stdout) > MAX_OUTPUT_BYTES or len(stderr) > MAX_OUTPUT_BYTES,
     }
-    if req.create_receipt:
-        payload = attach_receipt(payload, "python.run", workspace=req.workspace, summary=script.name)
-    return payload
 
 
-@app.post("/files/write", operation_id="write_file")
-def files_write(req: FileWriteRequest):
-    target = workspace_path(req.workspace, req.path)
-    target.parent.mkdir(parents=True, exist_ok=True)
-    raw = req.content.encode(req.encoding)
-    if len(raw) > MAX_FILE_BYTES:
-        raise HTTPException(status_code=413, detail="File too large")
-    target.write_bytes(raw)
-    payload = {"workspace": req.workspace, "path": req.path, "bytes": len(raw), "sha256": sha256_bytes(raw)}
-    return attach_receipt(payload, "files.write", workspace=req.workspace, summary=req.path)
+# ─── Analyze a profile ───────────────────────────────────────
+@app.get("/api/analyze/{username}")
+async def analyze_profile(username: str):
+    if not DB_PATH.exists():
+        return {"error": "DB not found"}
+    conn = get_db()
+    c = conn.cursor()
+    row = c.execute("SELECT * FROM masseurs WHERE username = ?", (username,)).fetchone()
+    if not row:
+        conn.close()
+        return {"error": "Profile not found", "username": username}
 
+    profile = dict(row)
+    total = c.execute("SELECT COUNT(*) FROM masseurs").fetchone()[0]
+    rank = c.execute("SELECT COUNT(*) FROM masseurs WHERE views_per_day > ?", (profile["views_per_day"],)).fetchone()[0] + 1
+    percentile = round((1 - rank / total) * 100, 1)
+    conn.close()
 
-@app.post("/files/read", operation_id="read_file")
-def files_read(req: FileReadRequest):
-    target = workspace_path(req.workspace, req.path)
-    if not target.exists() or not target.is_file():
-        raise HTTPException(status_code=404, detail="File not found")
-    raw_all = target.read_bytes()
-    raw = raw_all[: req.max_bytes]
     return {
-        "workspace": req.workspace,
-        "path": req.path,
-        "bytes": len(raw),
-        "sha256": sha256_bytes(raw_all),
-        "content": raw.decode("utf-8", errors="replace"),
-        "truncated": len(raw_all) > req.max_bytes,
-    }
-
-
-@app.post("/files/list", operation_id="list_files")
-def files_list(req: FileListRequest):
-    base = workspace_path(req.workspace, req.path)
-    if not base.exists():
-        raise HTTPException(status_code=404, detail="Path not found")
-    root = workspace_path(req.workspace, ".")
-    items = []
-    for idx, p in enumerate(sorted(base.iterdir(), key=lambda x: x.name.lower())):
-        if idx >= req.max_items:
-            break
-        items.append({
-            "name": p.name,
-            "path": str(p.relative_to(root)),
-            "type": "dir" if p.is_dir() else "file",
-            "bytes": p.stat().st_size if p.is_file() else None,
-            "modified_at": datetime.fromtimestamp(p.stat().st_mtime, timezone.utc).isoformat(),
-        })
-    return {"workspace": req.workspace, "path": req.path, "items": items}
-
-
-@app.get("/workspace/tree", response_class=PlainTextResponse, operation_id="get_workspace_tree")
-def workspace_tree(workspace: str = "default", max_items: int = 500):
-    base = workspace_path(workspace, ".")
-    lines = [f"{workspace}/"]
-    count = 0
-    for p in sorted(base.rglob("*")):
-        count += 1
-        if count > max_items:
-            lines.append("... truncated ...")
-            break
-        rel = p.relative_to(base)
-        indent = "  " * (len(rel.parts) - 1)
-        lines.append(f"{indent}{rel.name}{'/' if p.is_dir() else ''}")
-    return "\n".join(lines)
-
-
-@app.post("/artifact/compile", operation_id="compile_artifact")
-def artifact_compile(req: ArtifactRequest):
-    filename = safe_name(req.filename, "artifact.txt")
-    if "." not in filename:
-        filename += ".txt"
-    aid = f"art_{uuid.uuid4().hex[:12]}_{filename}"
-    target = artifact_path(aid)
-    raw = req.content.encode("utf-8")
-    if len(raw) > MAX_FILE_BYTES:
-        raise HTTPException(status_code=413, detail="Artifact too large")
-    target.write_bytes(raw)
-    payload = {
-        "artifact_id": aid,
-        "filename": filename,
-        "bytes": len(raw),
-        "sha256": sha256_bytes(raw),
-        "url": f"{PUBLIC_BASE_URL}/u/{aid}",
-        "content_type": req.content_type,
-    }
-    return attach_receipt(payload, "artifact.compile", workspace=req.workspace, summary=filename)
-
-
-@app.post("/url/issue", operation_id="issue_url")
-def url_issue(req: ArtifactRequest):
-    return artifact_compile(req)
-
-
-@app.get("/u/{artifact_id}", include_in_schema=False)
-def artifact_get(artifact_id: str):
-    p = artifact_path(artifact_id)
-    if not p.exists() or not p.is_file():
-        raise HTTPException(status_code=404, detail="Artifact not found")
-    return FileResponse(str(p), filename=p.name)
-
-
-@app.get("/artifacts", operation_id="list_artifacts")
-def list_artifacts(limit: int = 100):
-    items = []
-    for idx, p in enumerate(sorted(ARTIFACT_ROOT.glob("*"), key=lambda x: x.stat().st_mtime, reverse=True)):
-        if idx >= max(1, min(limit, 1000)):
-            break
-        if not p.is_file():
-            continue
-        raw = p.read_bytes()
-        items.append({
-            "artifact_id": p.name,
-            "bytes": len(raw),
-            "sha256": sha256_bytes(raw),
-            "url": f"{PUBLIC_BASE_URL}/u/{p.name}",
-            "modified_at": datetime.fromtimestamp(p.stat().st_mtime, timezone.utc).isoformat(),
-        })
-    return {"items": items}
-
-
-@app.post("/web/scrape", operation_id="scrape_public_url")
-async def web_scrape(req: WebScrapeRequest):
-    parsed = urlparse(req.url)
-    if parsed.scheme not in {"http", "https"}:
-        raise HTTPException(status_code=400, detail="Only http and https URLs are allowed")
-    if private_or_internal_host(parsed.hostname or ""):
-        raise HTTPException(status_code=400, detail="Private/internal hosts are blocked")
-
-    async with httpx.AsyncClient(
-        follow_redirects=True,
-        timeout=15,
-        headers={"User-Agent": "SelfRelaunchingGPTKernel/4.0 public scraper"},
-    ) as client:
-        resp = await client.get(req.url)
-        final_url = str(resp.url)
-        if private_or_internal_host(urlparse(final_url).hostname or ""):
-            raise HTTPException(status_code=400, detail="Redirected to private/internal host")
-        raw = resp.content[: req.max_bytes]
-
-    ctype = resp.headers.get("content-type", "")
-    extracted = extract_title_text(raw, ctype)
-    payload = {
-        "url": req.url,
-        "final_url": final_url,
-        "status_code": resp.status_code,
-        "content_type": ctype,
-        "headers": {k: v for k, v in resp.headers.items() if k.lower() in {"content-type", "content-length", "server", "last-modified", "etag"}},
-        "title": extracted["title"],
-        "text_preview": extracted["text"][: req.preview_chars],
-        "bytes_read": len(raw),
-        "sha256": sha256_bytes(raw),
-        "truncated": len(resp.content) > len(raw),
-        "saved_path": None,
+        "username": username,
+        "rank": rank,
+        "total": total,
+        "percentile": percentile,
+        "views_per_day": profile["views_per_day"],
+        "total_visits": profile["visits"],
+        "member_since": profile["member_since"],
+        "rating": profile["rating"],
+        "reviews_count": profile["reviews_count"],
+        "is_gold": bool(profile["is_gold"]),
+        "photo_count": profile["photo_count"],
+        "bio_length": len(profile.get("bio", "") or ""),
+        "profile_url": f"{RENTMASSEUR_BASE}/{username}",
     }
 
-    if req.save:
-        fname = safe_name(parsed.netloc + parsed.path, "scrape") + ".json"
-        target = workspace_path(req.workspace, fname)
-        save_json(target, payload)
-        payload["saved_path"] = str(target.relative_to(workspace_path(req.workspace, ".")))
 
-    return attach_receipt(payload, "web.scrape", workspace=req.workspace, summary=req.url[:240])
-
-
-@app.post("/analyze/request", operation_id="analyze_gpt_request")
-def analyze_request(req: AnalyzeRequest):
-    text = req.request_text
-    lower = text.lower()
-    labels = []
-    if any(x in lower for x in ["trade", "trading", "underwrite", "market", "perp", "futures"]):
-        labels.append("trading_or_underwriting")
-    if any(x in lower for x in ["terminal", "run", "execute", "shell", "command"]):
-        labels.append("terminal_execution")
-    if any(x in lower for x in ["scrape", "crawl", "website", "url", "fetch"]):
-        labels.append("web_retrieval")
-    if any(x in lower for x in ["file", "save", "artifact", "receipt", "ledger"]):
-        labels.append("artifact_or_receipt")
-    if any(x in lower for x in ["relaunch", "restart", "rebuild", "deploy"]):
-        labels.append("deployment_control")
-
-    risk_flags = []
-    if any(x in lower for x in ["api key", "secret", "private key", "password", "token"]):
-        risk_flags.append("credential_sensitive")
-    if any(x in lower for x in ["live order", "real money", "no stop loss", "guaranteed profit"]):
-        risk_flags.append("financial_risk")
-    if any(x in lower for x in ["unrestricted shell", "public shell", "no auth"]):
-        risk_flags.append("unsafe_public_execution")
-
-    payload = {
-        "labels": labels,
-        "risk_flags": risk_flags,
-        "recommended_route": labels[0] if labels else "general",
-        "request_sha256": sha256_bytes(text.encode("utf-8")),
-        "context": req.context,
-    }
-    return attach_receipt(payload, "request.analysis", summary=text[:240])
-
-
-@app.get("/requests/recent", operation_id="recent_request_analysis")
-def recent_requests(limit: int = 100):
-    limit = max(1, min(limit, 500))
-    with sqlite3.connect(LEDGER_DB, timeout=5) as con:
-        rows = con.execute(
-            "SELECT id, method, path, query, client, user_agent, status_code, duration_ms, request_sha256, created_at FROM request_log ORDER BY created_at DESC LIMIT ?",
-            (limit,),
-        ).fetchall()
-    return {"items": [
-        {"id": r[0], "method": r[1], "path": r[2], "query": r[3], "client": r[4], "user_agent": r[5], "status_code": r[6], "duration_ms": r[7], "request_sha256": r[8], "created_at": r[9]}
-        for r in rows
-    ]}
-
-
-@app.post("/tools/register", operation_id="register_tool")
-def register_tool(req: ToolRegisterRequest, x_admin_token: Optional[str] = Header(default=None)):
-    require_admin(x_admin_token)
-    name = safe_name(req.name)
-    if req.mode not in {"command", "python"}:
-        raise HTTPException(status_code=400, detail="mode must be command or python")
-    if req.mode == "command" and req.template:
-        validate_command(render_template(req.template, {k: "x" for k in req.required_args}, req.required_args))
-    now = now_iso()
-    with sqlite3.connect(LEDGER_DB, timeout=5) as con:
-        con.execute(
-            """INSERT INTO tools(name, description, mode, template, input_schema_json, required_args_json, enabled, created_at, updated_at)
-               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-               ON CONFLICT(name) DO UPDATE SET description=excluded.description, mode=excluded.mode, template=excluded.template,
-               input_schema_json=excluded.input_schema_json, required_args_json=excluded.required_args_json, enabled=excluded.enabled, updated_at=excluded.updated_at""",
-            (name, req.description, req.mode, req.template, json.dumps(req.input_schema), json.dumps(req.required_args), 1 if req.enabled else 0, now, now)
-        )
-    payload = {"name": name, "registered": True, "mode": req.mode}
-    return attach_receipt(payload, "tool.register", actor="admin", summary=name)
-
-
-@app.get("/tools", operation_id="list_tools")
-def list_tools():
-    with sqlite3.connect(LEDGER_DB, timeout=5) as con:
-        rows = con.execute("SELECT name, description, mode, enabled, input_schema_json, required_args_json, created_at, updated_at FROM tools ORDER BY name").fetchall()
-    return {"tools": [
-        {"name": r[0], "description": r[1], "mode": r[2], "enabled": bool(r[3]), "input_schema": json.loads(r[4] or "{}"), "required_args": json.loads(r[5] or "[]"), "created_at": r[6], "updated_at": r[7]}
-        for r in rows
-    ]}
-
-
-@app.post("/tool/{name}", operation_id="invoke_tool")
-async def invoke_tool(name: str, req: ToolInvokeRequest):
-    name = safe_name(name)
-    with sqlite3.connect(LEDGER_DB, timeout=5) as con:
-        row = con.execute("SELECT mode, template, enabled, required_args_json FROM tools WHERE name = ?", (name,)).fetchone()
-    if not row:
-        raise HTTPException(status_code=404, detail="Tool not found")
-    mode, template, enabled, required_json = row
-    if not enabled:
-        raise HTTPException(status_code=403, detail="Tool disabled")
-    required = json.loads(required_json or "[]")
-    rendered = render_template(template, req.params, required)
-    if mode == "command":
-        return await terminal_run(TerminalRunRequest(workspace=req.workspace, command=rendered, timeout_seconds=req.timeout_seconds))
-    if mode == "python":
-        code = "ARGS = " + json.dumps(req.params, ensure_ascii=False) + "\n" + rendered
-        return await python_run(PythonRunRequest(workspace=req.workspace, code=code, timeout_seconds=req.timeout_seconds))
-    raise HTTPException(status_code=400, detail="Unknown tool mode")
-
-
-@app.post("/sessions", operation_id="create_session")
-def create_session(req: SessionCreateRequest, x_admin_token: Optional[str] = Header(default=None)):
-    require_admin(x_admin_token)
-    sid = f"sess_{uuid.uuid4().hex[:16]}"
-    cwd = workspace_path(req.workspace, req.cwd)
-    now = now_iso()
-    with sqlite3.connect(LEDGER_DB, timeout=5) as con:
-        con.execute("INSERT INTO sessions(id, workspace, cwd, created_at, updated_at) VALUES (?, ?, ?, ?, ?)", (sid, req.workspace, str(cwd), now, now))
-    return attach_receipt({"session_id": sid, "workspace": req.workspace, "cwd": str(cwd), "created_at": now}, "session.create", actor="admin", workspace=req.workspace, summary=sid)
-
-
-@app.post("/sessions/run", operation_id="run_session")
-async def run_session(req: SessionRunRequest, x_admin_token: Optional[str] = Header(default=None)):
-    require_admin(x_admin_token)
-    with sqlite3.connect(LEDGER_DB, timeout=5) as con:
-        row = con.execute("SELECT workspace, cwd FROM sessions WHERE id = ?", (req.session_id,)).fetchone()
-    if not row:
-        raise HTTPException(status_code=404, detail="Session not found")
-    workspace, cwd = row
-    rel = os.path.relpath(cwd, workspace_path(workspace, "."))
-    return await terminal_run(TerminalRunRequest(workspace=workspace, command=req.command, timeout_seconds=req.timeout_seconds, cwd=rel))
-
-
-@app.get("/receipts", operation_id="list_receipts")
-def list_receipts(kind: Optional[str] = None, q: Optional[str] = None, limit: int = 100):
-    limit = max(1, min(limit, 1000))
-    rows = []
-    with sqlite3.connect(LEDGER_DB, timeout=5) as con:
-        if kind:
-            data = con.execute("SELECT id, kind, actor, workspace, summary, payload_sha256, created_at FROM receipts WHERE kind = ? ORDER BY created_at DESC LIMIT ?", (kind, limit)).fetchall()
-        else:
-            data = con.execute("SELECT id, kind, actor, workspace, summary, payload_sha256, created_at FROM receipts ORDER BY created_at DESC LIMIT ?", (limit,)).fetchall()
-    for r in data:
-        item = {"id": r[0], "kind": r[1], "actor": r[2], "workspace": r[3], "summary": r[4], "payload_sha256": r[5], "created_at": r[6]}
-        if q and q.lower() not in json.dumps(item, ensure_ascii=False).lower():
-            continue
-        rows.append(item)
-    return {"items": rows}
-
-
-@app.get("/receipts/{receipt_id}", operation_id="get_receipt")
-def get_receipt(receipt_id: str):
-    rid = safe_name(receipt_id)
-    path = RECEIPTS_ROOT / f"{rid}.json"
-    if path.exists():
-        return json.loads(path.read_text(encoding="utf-8"))
-    with sqlite3.connect(LEDGER_DB, timeout=5) as con:
-        row = con.execute("SELECT id, kind, actor, workspace, summary, payload_json, payload_sha256, created_at FROM receipts WHERE id = ?", (receipt_id,)).fetchone()
-    if not row:
-        raise HTTPException(status_code=404, detail="Receipt not found")
-    return {"id": row[0], "kind": row[1], "actor": row[2], "workspace": row[3], "summary": row[4], "payload": json.loads(row[5]), "payload_sha256": row[6], "created_at": row[7]}
-
-
-@app.get("/deployment/status", operation_id="deployment_status")
-def deployment_status():
-    checks = {}
-    for label, path in {"data": DATA_DIR, "workspace": WORKSPACE_ROOT, "artifacts": ARTIFACT_ROOT, "receipts": RECEIPTS_ROOT}.items():
-        test = path / f".write_test_{uuid.uuid4().hex[:8]}"
-        try:
-            test.write_text("ok", encoding="utf-8")
-            test.unlink(missing_ok=True)
-            checks[label] = {"path": str(path), "writable": True}
-        except Exception as e:
-            checks[label] = {"path": str(path), "writable": False, "error": f"{type(e).__name__}: {str(e)}"}
-    return {"public_base_url": PUBLIC_BASE_URL, "admin_token_enabled": bool(ADMIN_TOKEN), "relaunch_flag_exists": RELAUNCH_FLAG.exists(), "checks": checks}
-
-
-@app.post("/admin/relaunch", operation_id="admin_relaunch")
-async def admin_relaunch(req: RelaunchRequest, x_admin_token: Optional[str] = Header(default=None)):
-    require_admin(x_admin_token)
-    payload = {"requested": True, "reason": req.reason, "delay_seconds": req.delay_seconds, "created_at": now_iso()}
-    save_json(RELAUNCH_FLAG, payload)
-    receipt = make_receipt("admin.relaunch", payload, actor="admin", summary=req.reason[:240])
-
-    async def delayed_exit():
-        await asyncio.sleep(req.delay_seconds)
-        os._exit(0)
-
-    asyncio.create_task(delayed_exit())
-    return {"accepted": True, "message": "Relaunch requested. The process will exit; Hugging Face should restart the Space.", "receipt": receipt}
-
-
-STRICT_OPENAPI_PATHS = [
-    "/health",
-    "/capabilities",
-    "/terminal/run",
-    "/python/run",
-    "/files/write",
-    "/files/read",
-    "/files/list",
-    "/workspace/tree",
-    "/artifact/compile",
-    "/url/issue",
-    "/artifacts",
-    "/web/scrape",
-    "/analyze/request",
-    "/requests/recent",
-    "/tools/register",
-    "/tools",
-    "/tool/{name}",
-    "/sessions",
-    "/sessions/run",
-    "/receipts",
-    "/receipts/{receipt_id}",
-    "/deployment/status",
-    "/admin/relaunch",
-]
-
-
-@app.get("/openapi.json", include_in_schema=False)
-def actions_openapi():
-    raw = app.openapi()
-    strict = {
-        "openapi": "3.0.3",
-        "info": raw.get("info", {}),
-        "servers": [{"url": PUBLIC_BASE_URL}],
-        "paths": {k: v for k, v in raw.get("paths", {}).items() if k in STRICT_OPENAPI_PATHS},
-        "components": raw.get("components", {}),
+# ─── Root ────────────────────────────────────────────────────
+@app.get("/")
+async def root():
+    return {
+        "service": "MasseurBoost Endpoint",
+        "spaces": [
+            "https://josephrw-endpoint.hf.space",
+            "https://josephrw-csc-engine.hf.space",
+        ],
+        "endpoints": [
+            "/api/health",
+            "/api/market-stats",
+            "/api/search",
+            "/api/analyze/{username}",
+        ],
     }
-
-    def scrub(obj):
-        if isinstance(obj, dict):
-            obj.pop("examples", None)
-            obj.pop("const", None)
-            for k in list(obj.keys()):
-                scrub(obj[k])
-        elif isinstance(obj, list):
-            for x in obj:
-                scrub(x)
-
-    scrub(strict)
-    return JSONResponse(strict)