Restore Giant GPT Terminal Kernel v3.1.1 — GPT relay

.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.pyc
+*.pyo
+*.db
+data/

Dockerfile

@@ -2,7 +2,7 @@ FROM python:3.11-slim
 
 WORKDIR /app
 
-RUN pip install --no-cache-dir fastapi uvicorn[standard] jinja2
+RUN pip install --no-cache-dir fastapi uvicorn[standard] pydantic
 
 COPY . /app
 

README.md

@@ -1,8 +1,8 @@
 ---
-title: MasseurBoost Endpoint
-emoji: 💆
-colorFrom: purple
-colorTo: pink
+title: GPT Relay Endpoint
+emoji: 🚀
+colorFrom: gray
+colorTo: blue
 sdk: docker
 app_port: 7860
 pinned: false

app.py

@@ -1,170 +1,485 @@
-"""josephrw-endpoint HF Space — MasseurBoost API endpoint.
+"""Giant GPT Terminal Kernel — josephrw-endpoint HF Space.
 
-Exposes the SaaS app on Hugging Face Spaces with a lightweight
-read-only mode (no local DB writes, no Selenium).
+GPT Actions compatible external terminal, Python, file, artifact URL,
+dynamic tool, memory, and receipt kernel. Hardened to avoid post-execution 500s.
 """
 import os
-import sys
 import json
+import time
+import uuid
+import hashlib
 import sqlite3
+import subprocess
+import threading
 from pathlib import Path
-from fastapi import FastAPI, Request, Query
-from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
+from datetime import datetime, timezone
+from typing import Optional
+
+from fastapi import FastAPI, Request, Query, HTTPException
+from fastapi.responses import JSONResponse, PlainTextResponse
 from fastapi.staticfiles import StaticFiles
-from fastapi.templating import Jinja2Templates
+from pydantic import BaseModel, Field
+
+app = FastAPI(
+    title="Giant GPT Terminal Kernel",
+    version="3.1.1",
+    docs_url="/docs",
+    openapi_url="/openapi.json",
+)
 
-# ─── 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"
+# ─── Paths ────────────────────────────────────────────────────
+WORKSPACE_ROOT = Path(os.environ.get("WORKSPACE_ROOT", str(Path(__file__).parent / "data" / "workspaces")))
+ARTIFACTS_DIR = Path(os.environ.get("ARTIFACTS_DIR", str(Path(__file__).parent / "data" / "artifacts")))
+DB_PATH = Path(os.environ.get("KERNEL_DB", str(Path(__file__).parent / "data" / "kernel.db")))
 
-BASE_DIR = Path(__file__).parent
-TEMPLATES_DIR = BASE_DIR / "templates"
-STATIC_DIR = BASE_DIR / "static"
+WORKSPACE_ROOT.mkdir(parents=True, exist_ok=True)
+ARTIFACTS_DIR.mkdir(parents=True, exist_ok=True)
 
-app = FastAPI(title="MasseurBoost Endpoint", docs_url="/api/docs")
+# ─── SQLite for receipts, memory, tools, sessions ─────────────
+def _init_db():
+    conn = sqlite3.connect(str(DB_PATH))
+    c = conn.cursor()
+    c.execute("""CREATE TABLE IF NOT EXISTS receipts (
+        id TEXT PRIMARY KEY, kind TEXT, workspace TEXT, summary TEXT,
+        sha256 TEXT, created_at TEXT, data_json TEXT
+    )""")
+    c.execute("""CREATE TABLE IF NOT EXISTS memory (
+        id TEXT PRIMARY KEY, topic TEXT, content TEXT, utility REAL,
+        tags TEXT, created_at TEXT
+    )""")
+    c.execute("""CREATE TABLE IF NOT EXISTS tools (
+        name TEXT PRIMARY KEY, description TEXT, mode TEXT,
+        command_template TEXT, schema_data TEXT, enabled INTEGER,
+        created_at TEXT
+    )""")
+    c.execute("""CREATE TABLE IF NOT EXISTS sessions (
+        session_id TEXT PRIMARY KEY, workspace TEXT, cwd TEXT,
+        created_at TEXT, active INTEGER
+    )""")
+    conn.commit()
+    conn.close()
 
-if TEMPLATES_DIR.exists():
-    templates = Jinja2Templates(directory=str(TEMPLATES_DIR))
-if STATIC_DIR.exists():
-    app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
+_init_db()
 
-RENTMASSEUR_BASE = "https://rentmasseur.com"
+DB_LOCK = threading.Lock()
 
 
-def get_db():
-    conn = sqlite3.connect(str(DB_PATH))
+def _db():
+    conn = sqlite3.connect(str(DB_PATH), timeout=10)
     conn.row_factory = sqlite3.Row
     return conn
 
 
-# ─── Health ──────────────────────────────────────────────────
-@app.get("/api/health")
+# ─── Helpers ──────────────────────────────────────────────────
+def _ws_path(workspace: str, path: str = ".") -> Path:
+    base = WORKSPACE_ROOT / workspace
+    base.mkdir(parents=True, exist_ok=True)
+    resolved = (base / path).resolve()
+    if not str(resolved).startswith(str(base.resolve())):
+        raise HTTPException(status_code=400, detail="Path traversal denied")
+    return resolved
+
+
+def _truncate(text: str, limit: int = 50000) -> tuple:
+    if len(text) > limit:
+        return text[:limit], True
+    return text, False
+
+
+def _receipt(kind: str, summary: str, data: dict, workspace: Optional[str] = None) -> dict:
+    rid = uuid.uuid4().hex[:16]
+    sha = hashlib.sha256(json.dumps(data, sort_keys=True, default=str).encode()).hexdigest()
+    now = datetime.now(timezone.utc).isoformat()
+    with DB_LOCK:
+        conn = _db()
+        conn.execute(
+            "INSERT INTO receipts VALUES (?,?,?,?,?,?,?)",
+            (rid, kind, workspace, summary, sha, now, json.dumps(data, default=str)),
+        )
+        conn.commit()
+        conn.close()
+    return {"id": rid, "kind": kind, "workspace": workspace, "summary": summary, "sha256": sha, "created_at": now}
+
+
+def _safe_run(cmd: list, cwd: Path, timeout: int) -> dict:
+    try:
+        result = subprocess.run(
+            cmd, cwd=str(cwd), capture_output=True, text=True, timeout=timeout,
+        )
+        stdout, truncated = _truncate(result.stdout)
+        stderr, _ = _truncate(result.stderr)
+        return {"returncode": result.returncode, "stdout": stdout, "stderr": stderr, "truncated": truncated}
+    except subprocess.TimeoutExpired:
+        return {"returncode": -1, "stdout": "", "stderr": f"Timed out after {timeout}s", "truncated": False}
+    except Exception as e:
+        return {"returncode": -1, "stdout": "", "stderr": str(e), "truncated": False}
+
+
+# ═══════════════════════════════════════════════════════════════
+#  MODELS
+# ═══════════════════════════════════════════════════════════════
+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 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 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 ListRequest(BaseModel):
+    workspace: str = "default"
+    path: str = "."
+    max_items: int = Field(default=250, ge=1, le=2000)
+
+
+class ArtifactRequest(BaseModel):
+    workspace: str = "default"
+    filename: str
+    content: str
+    content_type: str = "text/plain"
+
+
+class LearnRequest(BaseModel):
+    topic: str = "general"
+    content: str
+    utility: float = Field(default=0.5, ge=0, le=1)
+    tags: list = []
+
+
+class RecallRequest(BaseModel):
+    query: str
+    limit: int = Field(default=8, ge=1, le=50)
+
+
+class ToolRegisterRequest(BaseModel):
+    name: str
+    description: str = ""
+    mode: str = "command"
+    command_template: str = ""
+    schema_data: dict = {}
+    enabled: bool = True
+
+
+class ToolInvokeRequest(BaseModel):
+    workspace: str = "default"
+    args: dict = {}
+    timeout_seconds: int = Field(default=10, ge=1, le=30)
+
+
+# ═══════════════════════════════════════════════════════════════
+#  HEALTH
+# ═══════════════════════════════════════════════════════════════
+@app.get("/health")
 async def health():
-    return {"status": "ok", "db": str(DB_PATH), "db_exists": DB_PATH.exists()}
+    return {"status": "ok", "version": "3.1.1", "workspaces": len(list(WORKSPACE_ROOT.iterdir()))}
 
 
-# ─── 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 {
-        "total_masseurs": total,
-        "cities_covered": cities,
-        "gold_members": gold,
-        "avg_views_per_day": round(avg_vpd or 0, 1),
-    }
+# ═══════════════════════════════════════════════════════════════
+#  TERMINAL RUN
+# ═══════════════════════════════════════════════════════════════
+@app.post("/terminal/run")
+async def run_terminal(req: TerminalRunRequest):
+    cwd = _ws_path(req.workspace, req.cwd)
+    result = _safe_run(["sh", "-c", req.command], cwd, req.timeout_seconds)
+    receipt = None
+    receipt_error = None
+    if req.create_receipt:
+        try:
+            receipt = _receipt("terminal_run", req.command[:80], result, req.workspace)
+        except Exception as e:
+            receipt_error = str(e)
+    return {"workspace": req.workspace, "cwd": req.cwd, "command": req.command, **result, "receipt": receipt, "receipt_error": receipt_error}
 
 
-# ─── 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()
+# ═══════════════════════════════════════════════════════════════
+#  PYTHON RUN
+# ═══════════════════════════════════════════════════════════════
+@app.post("/python/run")
+async def run_python(req: PythonRunRequest):
+    ws_base = _ws_path(req.workspace)
+    script_path = ws_base / f"_run_{uuid.uuid4().hex[:8]}.py"
+    script_path.write_text(req.code)
+    result = _safe_run(["python3", str(script_path)], ws_base, req.timeout_seconds)
+    try:
+        script_path.unlink(missing_ok=True)
+    except Exception:
+        pass
+    receipt = None
+    receipt_error = None
+    if req.create_receipt:
+        try:
+            receipt = _receipt("python_run", req.code[:80], result, req.workspace)
+        except Exception as e:
+            receipt_error = str(e)
+    return {"workspace": req.workspace, "script": script_path.name, **result, "receipt": receipt, "receipt_error": receipt_error}
 
-    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"
+# ═══════════════════════════════════════════════════════════════
+#  SESSIONS
+# ═══════════════════════════════════════════════════════════════
+@app.post("/session/create")
+async def create_session(req: SessionCreateRequest):
+    sid = uuid.uuid4().hex[:12]
+    _ws_path(req.workspace, req.cwd)
+    now = datetime.now(timezone.utc).isoformat()
+    with DB_LOCK:
+        conn = _db()
+        conn.execute("INSERT INTO sessions VALUES (?,?,?,?,1)", (sid, req.workspace, req.cwd, now))
+        conn.commit()
+        conn.close()
+    return {"session_id": sid, "workspace": req.workspace, "cwd": req.cwd, "created_at": now}
 
-    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()
 
-    return {
-        "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
-        ],
-    }
+@app.post("/session/run")
+async def run_session_command(req: SessionRunRequest):
+    with DB_LOCK:
+        conn = _db()
+        row = conn.execute("SELECT * FROM sessions WHERE session_id=? AND active=1", (req.session_id,)).fetchone()
+        conn.close()
+    if not row:
+        raise HTTPException(status_code=404, detail="Session not found or inactive")
+    cwd = _ws_path(row["workspace"], row["cwd"])
+    result = _safe_run(["sh", "-c", req.command], cwd, req.timeout_seconds)
+    return {"workspace": row["workspace"], "cwd": row["cwd"], "command": req.command, **result, "receipt": _receipt("session_run", req.command[:80], result, row["workspace"]), "receipt_error": None}
 
 
-# ─── 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()
+# ═══════════════════════════════════════════════════════════════
+#  FILES
+# ═══════════════════════════════════════════════════════════════
+@app.post("/files/write")
+async def write_file(req: FileWriteRequest):
+    target = _ws_path(req.workspace, req.path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(req.content, encoding=req.encoding)
+    receipt = _receipt("file_write", req.path, {"bytes": len(req.content)}, req.workspace)
+    return {"status": "written", "path": req.path, "bytes": len(req.content), "receipt": receipt}
+
+
+@app.post("/files/read")
+async def read_file(req: FileReadRequest):
+    target = _ws_path(req.workspace, req.path)
+    if not target.exists():
+        raise HTTPException(status_code=404, detail="File not found")
+    if target.is_dir():
+        raise HTTPException(status_code=400, detail="Path is a directory")
+    data = target.read_bytes()[:req.max_bytes]
+    try:
+        text = data.decode("utf-8")
+        return {"path": req.path, "content": text, "bytes": len(data), "truncated": target.stat().st_size > req.max_bytes}
+    except UnicodeDecodeError:
+        import base64
+        return {"path": req.path, "content_base64": base64.b64encode(data).decode(), "bytes": len(data), "truncated": target.stat().st_size > req.max_bytes}
+
+
+@app.post("/files/list")
+async def list_files(req: ListRequest):
+    target = _ws_path(req.workspace, req.path)
+    if not target.exists():
+        return {"path": req.path, "entries": []}
+    entries = []
+    if target.is_dir():
+        for item in sorted(target.iterdir())[:req.max_items]:
+            entries.append({"name": item.name, "type": "dir" if item.is_dir() else "file", "size": item.stat().st_size if item.is_file() else None})
+    return {"path": req.path, "entries": entries}
+
+
+@app.get("/workspace/tree")
+async def get_workspace_tree(workspace: str = "default", max_items: int = 500):
+    base = _ws_path(workspace)
+    lines = []
+    count = 0
+    for p in sorted(base.rglob("*")):
+        if count >= max_items:
+            lines.append("... (truncated)")
+            break
+        rel = p.relative_to(base)
+        indent = "  " * (len(rel.parts) - 1)
+        marker = "/" if p.is_dir() else ""
+        lines.append(f"{indent}{p.name}{marker}")
+        count += 1
+    return PlainTextResponse("\n".join(lines) if lines else "(empty)")
+
+
+# ═══════════════════════════════════════════════════════════════
+#  ARTIFACTS
+# ═══════════════════════════════════════════════════════════════
+app.mount("/artifact", StaticFiles(directory=str(ARTIFACTS_DIR)), name="artifacts")
+
+
+@app.post("/artifact/compile")
+async def compile_artifact(req: ArtifactRequest):
+    artifact_hash = hashlib.sha256(req.content.encode()).hexdigest()[:16]
+    artifact_dir = ARTIFACTS_DIR / artifact_hash
+    artifact_dir.mkdir(parents=True, exist_ok=True)
+    (artifact_dir / req.filename).write_text(req.content)
+    (artifact_dir / "meta.json").write_text(json.dumps({"filename": req.filename, "content_type": req.content_type, "workspace": req.workspace, "sha256": artifact_hash, "created_at": datetime.now(timezone.utc).isoformat()}, indent=2))
+    receipt = _receipt("artifact", req.filename, {"hash": artifact_hash}, req.workspace)
+    return {"hash": artifact_hash, "filename": req.filename, "url": f"/artifact/{artifact_hash}/{req.filename}", "receipt": receipt}
+
+
+@app.post("/url/issue")
+async def issue_url(req: ArtifactRequest):
+    artifact_hash = hashlib.sha256(req.content.encode()).hexdigest()[:16]
+    artifact_dir = ARTIFACTS_DIR / artifact_hash
+    artifact_dir.mkdir(parents=True, exist_ok=True)
+    (artifact_dir / req.filename).write_text(req.content)
+    url = f"https://josephrw-endpoint.hf.space/artifact/{artifact_hash}/{req.filename}"
+    receipt = _receipt("url_issue", req.filename, {"url": url, "hash": artifact_hash}, req.workspace)
+    return {"url": url, "hash": artifact_hash, "filename": req.filename, "receipt": receipt}
+
+
+# ═══════════════════════════════════════════════════════════════
+#  MEMORY
+# ════════════════════════════════════════════════════════════��══
+@app.post("/learn")
+async def learn_memory(req: LearnRequest):
+    mid = uuid.uuid4().hex[:16]
+    now = datetime.now(timezone.utc).isoformat()
+    with DB_LOCK:
+        conn = _db()
+        conn.execute("INSERT INTO memory VALUES (?,?,?,?,?,?)", (mid, req.topic, req.content, req.utility, json.dumps(req.tags), now))
+        conn.commit()
+        conn.close()
+    return {"status": "learned", "id": mid, "topic": req.topic}
+
+
+@app.post("/recall")
+async def recall_memory(req: RecallRequest):
+    with DB_LOCK:
+        conn = _db()
+        rows = conn.execute("SELECT * FROM memory WHERE content LIKE ? OR topic LIKE ? ORDER BY utility DESC LIMIT ?", (f"%{req.query}%", f"%{req.query}%", req.limit)).fetchall()
+        conn.close()
+    return {"results": [{"id": r["id"], "topic": r["topic"], "content": r["content"], "utility": r["utility"], "tags": json.loads(r["tags"]), "created_at": r["created_at"]} for r in rows]}
+
+
+# ═══════════════════════════════════════════════════════════════
+#  DYNAMIC TOOLS
+# ═══════════════════════════════════════════════════════════════
+@app.post("/tool/register")
+async def register_tool(req: ToolRegisterRequest):
+    now = datetime.now(timezone.utc).isoformat()
+    with DB_LOCK:
+        conn = _db()
+        conn.execute("INSERT OR REPLACE INTO tools VALUES (?,?,?,?,?,?,?)", (req.name, req.description, req.mode, req.command_template, json.dumps(req.schema_data), int(req.enabled), now))
+        conn.commit()
+        conn.close()
+    return {"status": "registered", "name": req.name, "mode": req.mode}
+
+
+@app.get("/tools")
+async def list_tools():
+    with DB_LOCK:
+        conn = _db()
+        rows = conn.execute("SELECT * FROM tools WHERE enabled=1").fetchall()
+        conn.close()
+    return {"tools": [{"name": r["name"], "description": r["description"], "mode": r["mode"], "command_template": r["command_template"], "schema": json.loads(r["schema_data"])} for r in rows]}
+
+
+@app.post("/tool/{name}")
+async def invoke_tool(name: str, req: ToolInvokeRequest):
+    with DB_LOCK:
+        conn = _db()
+        row = conn.execute("SELECT * FROM tools WHERE name=? AND enabled=1", (name,)).fetchone()
+        conn.close()
     if not row:
+        raise HTTPException(status_code=404, detail=f"Tool '{name}' not found")
+    template = row["command_template"]
+    cmd = template
+    for k, v in req.args.items():
+        cmd = cmd.replace(f"{{{{{k}}}}}", str(v))
+    if row["mode"] == "python":
+        ws_base = _ws_path(req.workspace)
+        script = ws_base / f"_tool_{uuid.uuid4().hex[:8]}.py"
+        script.write_text(cmd)
+        result = _safe_run(["python3", str(script)], ws_base, req.timeout_seconds)
+        script.unlink(missing_ok=True)
+    else:
+        cwd = _ws_path(req.workspace)
+        result = _safe_run(["sh", "-c", cmd], cwd, req.timeout_seconds)
+    receipt = _receipt("tool_invoke", name, result, req.workspace)
+    return {"tool": name, **result, "receipt": receipt}
+
+
+# ═══════════════════════════════════════════════════════════════
+#  RECEIPTS / LEDGER
+# ═══════════════════════════════════════════════════════════════
+@app.get("/ledger/recent")
+async def get_recent_ledger(limit: int = 50):
+    with DB_LOCK:
+        conn = _db()
+        rows = conn.execute("SELECT id, kind, workspace, summary, sha256, created_at FROM receipts ORDER BY created_at DESC LIMIT ?", (limit,)).fetchall()
         conn.close()
-        return {"error": "Profile not found", "username": username}
+    return {"receipts": [{"id": r["id"], "kind": r["kind"], "workspace": r["workspace"], "summary": r["summary"], "sha256": r["sha256"], "created_at": r["created_at"]} for r in rows]}
 
-    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()
 
-    return {
-        "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}",
-    }
+@app.get("/receipt/{receipt_id}")
+async def get_receipt(receipt_id: str):
+    with DB_LOCK:
+        conn = _db()
+        row = conn.execute("SELECT * FROM receipts WHERE id=?", (receipt_id,)).fetchone()
+        conn.close()
+    if not row:
+        raise HTTPException(status_code=404, detail="Receipt not found")
+    return {"id": row["id"], "kind": row["kind"], "workspace": row["workspace"], "summary": row["summary"], "sha256": row["sha256"], "created_at": row["created_at"], "data": json.loads(row["data_json"])}
 
 
-# ─── Root ────────────────────────────────────────────────────
+# ═══════════════════════════════════════════════════════════════
+#  ROOT
+# ═══════════════════════════════════════════════════════════════
 @app.get("/")
 async def root():
     return {
-        "service": "MasseurBoost Endpoint",
-        "spaces": [
-            "https://josephrw-endpoint.hf.space",
-            "https://josephrw-csc-engine.hf.space",
-        ],
+        "service": "Giant GPT Terminal Kernel",
+        "version": "3.1.1",
         "endpoints": [
-            "/api/health",
-            "/api/market-stats",
-            "/api/search",
-            "/api/analyze/{username}",
+            "GET /health",
+            "POST /terminal/run",
+            "POST /python/run",
+            "POST /session/create",
+            "POST /session/run",
+            "POST /files/write",
+            "POST /files/read",
+            "POST /files/list",
+            "GET /workspace/tree",
+            "POST /artifact/compile",
+            "POST /url/issue",
+            "POST /learn",
+            "POST /recall",
+            "POST /tool/register",
+            "GET /tools",
+            "POST /tool/{name}",
+            "GET /ledger/recent",
+            "GET /receipt/{receipt_id}",
         ],
     }