Update app.py: persistent storage, tiny Netlify, GGUF inference, ChatGPT dApp

app.py

@@ -1,11 +1,9 @@
 #!/usr/bin/env python3
 """
 LocalSpace Deployer — Hugging Face Space (Vanilla)
-
-Drag a DMG. It gets OPENED on the server: extracted, inspected, and its
-app bundle metadata is displayed. The Space itself hosts the DMG contents.
-
-Pure FastAPI + HTML/JS. No Gradio, no Streamlit, no API keys.
+Drag a DMG or GGUF. It gets OPENED on the server: extracted, inspected, and its
+app bundle metadata or model metadata is displayed. The Space itself hosts the
+contents. Pure FastAPI + HTML/JS. No Gradio, no Streamlit, no API keys.
 Public by default.
 """
 from __future__ import annotations
@@ -16,14 +14,16 @@ import os
 import plistlib
 import re
 import shutil
+import struct
 import subprocess
 import time
 import uuid
+import zipfile
 from pathlib import Path
 from typing import Any
 
 from fastapi import FastAPI, File, Request, UploadFile
-from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
+from fastapi.responses import FileResponse, HTMLResponse, JSONResponse, StreamingResponse
 from fastapi.staticfiles import StaticFiles
 
 # Try biplist for binary plists, fall back to plistlib
@@ -33,16 +33,42 @@ try:
 except ImportError:
     HAS_BIPLIST = False
 
-DATA_DIR = Path("data")
-DATA_DIR.mkdir(exist_ok=True)
+# Try llama-cpp-python for GGUF inference (optional)
+try:
+    from llama_cpp import Llama as _Llama
+    HAS_LLAMA = True
+except ImportError:
+    HAS_LLAMA = False
+
+# ─── Persistent storage detection ──────────────────────────────────────────
+# HF Spaces mounts persistent storage at /data when enabled.
+# Fall back to local ./data when running outside HF or without persistent storage.
+_PERSISTENT = Path("/data")
+if _PERSISTENT.exists() and _PERSISTENT.is_dir() and os.access(_PERSISTENT, os.W_OK):
+    DATA_DIR = _PERSISTENT / "localspace"
+else:
+    DATA_DIR = Path("data")
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+
 UPLOAD_DIR = DATA_DIR / "uploads"
 UPLOAD_DIR.mkdir(exist_ok=True)
 EXTRACT_DIR = DATA_DIR / "extracted"
 EXTRACT_DIR.mkdir(exist_ok=True)
+SITES_DIR = DATA_DIR / "sites"
+SITES_DIR.mkdir(exist_ok=True)
+DAPPS_DIR = DATA_DIR / "dapps"
+DAPPS_DIR.mkdir(exist_ok=True)
 DB_PATH = DATA_DIR / "apps.json"
 
+# Inference model cache (in-memory)
+_llm_cache: dict[str, Any] = {}
+
 app = FastAPI(title="LocalSpace Deployer")
-app.mount("/static", StaticFiles(directory="static"), name="static")
+
+# Ensure static dir exists
+STATIC_DIR = Path("static")
+STATIC_DIR.mkdir(exist_ok=True)
+app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
 
 _store: dict[str, dict[str, Any]] = {}
 
@@ -62,7 +88,7 @@ def _save_db() -> None:
 
 
 def _slugify(name: str) -> str:
-    return re.sub(r"[^a-z0-9]+", "-", name.lower().replace(".dmg", "")).strip("-")
+    return re.sub(r"[^a-z0-9]+", "-", name.lower().replace(".dmg", "").replace(".gguf", "").replace(".zip", "").replace(".json", "")).strip("-")
 
 
 def _hash_file(path: Path) -> str:
@@ -73,6 +99,14 @@ def _hash_file(path: Path) -> str:
     return h.hexdigest()
 
 
+def _format_bytes(n: int) -> str:
+    for unit in ["B", "KB", "MB", "GB", "TB"]:
+        if n < 1024:
+            return f"{n:.1f} {unit}"
+        n /= 1024
+    return f"{n:.1f} PB"
+
+
 def _read_plist(path: Path) -> dict[str, Any]:
     """Read a plist file (XML or binary)."""
     try:
@@ -157,6 +191,95 @@ def _inspect_app_bundle(app_path: Path) -> dict[str, Any]:
     }
 
 
+# ─── GGUF parsing ───────────────────────────────────────────────────────────
+
+GGUF_MAGIC = 0x46554747  # "GGUF" in little-endian
+GGUF_TYPE_MAP = {
+    0: "UINT8", 1: "INT8", 2: "UINT16", 3: "INT16",
+    4: "UINT32", 5: "INT32", 6: "FLOAT32", 7: "BOOL",
+    8: "STRING", 9: "ARRAY", 10: "UINT64", 11: "INT64", 12: "FLOAT64",
+}
+
+
+def _read_gguf_string(f) -> str:
+    n = struct.unpack("<Q", f.read(8))[0]
+    return f.read(n).decode("utf-8", errors="replace")
+
+
+def _read_gguf_value(f, vtype: int) -> Any:
+    if vtype == 0: return struct.unpack("<B", f.read(1))[0]
+    if vtype == 1: return struct.unpack("<b", f.read(1))[0]
+    if vtype == 2: return struct.unpack("<H", f.read(2))[0]
+    if vtype == 3: return struct.unpack("<h", f.read(2))[0]
+    if vtype == 4: return struct.unpack("<I", f.read(4))[0]
+    if vtype == 5: return struct.unpack("<i", f.read(4))[0]
+    if vtype == 6: return struct.unpack("<f", f.read(4))[0]
+    if vtype == 7: return struct.unpack("<?", f.read(1))[0]
+    if vtype == 8: return _read_gguf_string(f)
+    if vtype == 10: return struct.unpack("<Q", f.read(8))[0]
+    if vtype == 11: return struct.unpack("<q", f.read(8))[0]
+    if vtype == 12: return struct.unpack("<d", f.read(8))[0]
+    if vtype == 9:
+        inner = struct.unpack("<I", f.read(4))[0]
+        n = struct.unpack("<Q", f.read(8))[0]
+        return {"type": GGUF_TYPE_MAP.get(inner, str(inner)), "count": n}
+    return None
+
+
+def _inspect_gguf(gguf_path: Path) -> dict[str, Any]:
+    """Parse GGUF header: version, tensor count, metadata KV pairs."""
+    try:
+        with open(gguf_path, "rb") as f:
+            magic = struct.unpack("<I", f.read(4))[0]
+            if magic != GGUF_MAGIC:
+                return {"valid": False, "error": f"Not a GGUF file (magic={magic:#x})"}
+
+            version = struct.unpack("<I", f.read(4))[0]
+            tensor_count = struct.unpack("<Q", f.read(8))[0]
+            kv_count = struct.unpack("<Q", f.read(8))[0]
+
+            metadata = {}
+            for _ in range(kv_count):
+                key = _read_gguf_string(f)
+                vtype = struct.unpack("<I", f.read(4))[0]
+                value = _read_gguf_value(f, vtype)
+                metadata[key] = {
+                    "type": GGUF_TYPE_MAP.get(vtype, str(vtype)),
+                    "value": value,
+                }
+
+            # Read tensor info (names + shapes)
+            tensors = []
+            for _ in range(min(tensor_count, 200)):
+                n_dims = struct.unpack("<I", f.read(4))[0]
+                name = _read_gguf_string(f)
+                dims = [struct.unpack("<Q", f.read(8))[0] for _ in range(n_dims)]
+                dtype = struct.unpack("<I", f.read(4))[0]
+                offset = struct.unpack("<Q", f.read(8))[0]
+                tensors.append({
+                    "name": name,
+                    "dims": dims,
+                    "dtype": GGUF_TYPE_MAP.get(dtype, str(dtype)),
+                    "offset": offset,
+                })
+
+            return {
+                "valid": True,
+                "version": version,
+                "tensor_count": tensor_count,
+                "kv_count": kv_count,
+                "metadata": metadata,
+                "tensors": tensors,
+                "architecture": metadata.get("general.architecture", {}).get("value", "unknown"),
+                "name": metadata.get("general.name", {}).get("value", ""),
+                "quantization": metadata.get("general.quantization_version", {}).get("value", ""),
+                "context_length": metadata.get("general.context_length", {}).get("value", 0),
+                "file_size": gguf_path.stat().st_size,
+            }
+    except Exception as exc:
+        return {"valid": False, "error": str(exc)}
+
+
 def _open_dmg(app_id: str, dmg_path: Path) -> dict[str, Any]:
     """Open a DMG: extract it, find apps, inspect them."""
     extract_to = EXTRACT_DIR / app_id
@@ -211,8 +334,15 @@ def index(request: Request) -> HTMLResponse:
 
 @app.post("/api/upload")
 async def upload_file(file: UploadFile = File(...)) -> JSONResponse:
-    if not file.filename or not file.filename.lower().endswith(".dmg"):
-        return JSONResponse({"error": "Only .dmg files are accepted."}, status_code=400)
+    if not file.filename:
+        return JSONResponse({"error": "No filename provided."}, status_code=400)
+
+    fname = file.filename.lower()
+    is_dmg = fname.endswith(".dmg")
+    is_gguf = fname.endswith(".gguf")
+
+    if not is_dmg and not is_gguf:
+        return JSONResponse({"error": "Only .dmg and .gguf files are accepted."}, status_code=400)
 
     app_id = str(uuid.uuid4())
     slug = _slugify(file.filename)
@@ -222,7 +352,8 @@ async def upload_file(file: UploadFile = File(...)) -> JSONResponse:
         slug = f"{base_slug}-{counter}"
         counter += 1
 
-    dest = UPLOAD_DIR / f"{app_id}.dmg"
+    ext = ".dmg" if is_dmg else ".gguf"
+    dest = UPLOAD_DIR / f"{app_id}{ext}"
     with open(dest, "wb") as f:
         while True:
             chunk = await file.read(65536)
@@ -233,31 +364,51 @@ async def upload_file(file: UploadFile = File(...)) -> JSONResponse:
     sha256 = _hash_file(dest)
     size = dest.stat().st_size
 
-    opened = _open_dmg(app_id, dest)
+    if is_dmg:
+        opened = _open_dmg(app_id, dest)
+        entry = {
+            "app_id": app_id,
+            "slug": slug,
+            "filename": file.filename,
+            "file_type": "dmg",
+            "size": size,
+            "size_human": _format_bytes(size),
+            "sha256": sha256,
+            "download_url": f"/api/download/{app_id}",
+            "opened": opened.get("opened", False),
+            "apps_found": opened.get("apps_found", 0),
+            "apps": opened.get("apps", []),
+            "tree": opened.get("tree", []),
+            "html_files": opened.get("html_files", []),
+            "has_preview": opened.get("has_preview", False),
+            "preview_entry": opened.get("preview_entry", None),
+            "error": opened.get("error"),
+            "created_at": time.time(),
+        }
+        msg = "DMG uploaded and opened." if entry["opened"] else f"DMG uploaded but could not be opened: {entry.get('error', '')}"
+    else:
+        gguf_info = _inspect_gguf(dest)
+        entry = {
+            "app_id": app_id,
+            "slug": slug,
+            "filename": file.filename,
+            "file_type": "gguf",
+            "size": size,
+            "size_human": _format_bytes(size),
+            "sha256": sha256,
+            "download_url": f"/api/download/{app_id}",
+            "gguf": gguf_info,
+            "opened": gguf_info.get("valid", False),
+            "has_preview": False,
+            "preview_entry": None,
+            "created_at": time.time(),
+        }
+        msg = "GGUF uploaded and inspected." if gguf_info.get("valid") else f"GGUF uploaded but inspection failed: {gguf_info.get('error', '')}"
 
-    entry = {
-        "app_id": app_id,
-        "slug": slug,
-        "filename": file.filename,
-        "size": size,
-        "sha256": sha256,
-        "download_url": f"/api/download/{app_id}",
-        "opened": opened.get("opened", False),
-        "apps_found": opened.get("apps_found", 0),
-        "apps": opened.get("apps", []),
-        "tree": opened.get("tree", []),
-        "html_files": opened.get("html_files", []),
-        "has_preview": opened.get("has_preview", False),
-        "preview_entry": opened.get("preview_entry", None),
-        "created_at": time.time(),
-    }
     _store[app_id] = entry
     _save_db()
 
-    return JSONResponse({
-        "app": entry,
-        "message": "DMG uploaded and opened." if entry["opened"] else "DMG uploaded but could not be opened.",
-    }, status_code=201)
+    return JSONResponse({"app": entry, "message": msg}, status_code=201)
 
 
 @app.get("/api/apps")
@@ -340,18 +491,16 @@ def download_app(app_id: str):
     if not entry:
         return JSONResponse({"error": "Not found"}, status_code=404)
 
-    path = UPLOAD_DIR / f"{app_id}.dmg"
+    ext = ".dmg" if entry.get("file_type", "dmg") == "dmg" else ".gguf"
+    path = UPLOAD_DIR / f"{app_id}{ext}"
     if not path.exists():
         return JSONResponse({
             "error": "File not found on disk",
-            "detail": "This upload was stored in temporary storage that was cleared during a Space restart. Please re-upload the DMG."
+            "detail": "This upload was stored in temporary storage that was cleared during a Space restart. Please re-upload."
         }, status_code=404)
 
-    return FileResponse(
-        path=path,
-        filename=entry["filename"],
-        media_type="application/x-apple-diskimage",
-    )
+    media = "application/x-apple-diskimage" if ext == ".dmg" else "application/octet-stream"
+    return FileResponse(path=path, filename=entry["filename"], media_type=media)
 
 
 @app.get("/api/browse/{app_id}/{path:path}")
@@ -367,7 +516,7 @@ def browse_extracted(app_id: str, path: str):
     if not base.exists():
         return JSONResponse({
             "error": "Extracted files not found",
-            "detail": "This upload was stored in temporary storage that was cleared during a Space restart. Please re-upload the DMG."
+            "detail": "This upload was stored in temporary storage that was cleared during a Space restart. Please re-upload."
         }, status_code=404)
 
     try:
@@ -404,16 +553,14 @@ def preview_content(app_id: str, path: str):
     if not base.exists():
         return JSONResponse({
             "error": "Extracted files not found",
-            "detail": "This upload was stored in temporary storage that was cleared during a Space restart. Please re-upload the DMG."
+            "detail": "This upload was stored in temporary storage that was cleared during a Space restart. Please re-upload."
         }, status_code=404)
 
     if path:
         target = base / path
     else:
-        # Default to index.html if no path
         target = base / "index.html"
         if not target.exists():
-            # Find any HTML file
             for f in base.rglob("*.html"):
                 target = f
                 break
@@ -421,14 +568,12 @@ def preview_content(app_id: str, path: str):
     if not target.exists():
         return JSONResponse({"error": "Not found"}, status_code=404)
 
-    # Security check
     try:
         target.resolve().relative_to(base.resolve())
     except ValueError:
         return JSONResponse({"error": "Access denied"}, status_code=403)
 
     if target.is_dir():
-        # Look for index.html in directory
         idx = target / "index.html"
         if idx.exists():
             target = idx
@@ -453,10 +598,8 @@ def preview_content(app_id: str, path: str):
     suffix = target.suffix.lower()
     media_type = mime_types.get(suffix, "application/octet-stream")
 
-    # For HTML, inject base tag to handle relative paths
     if media_type == "text/html":
         content = target.read_text(errors="replace")
-        # Inject base tag after <head>
         if "<base" not in content:
             rel_dir = str(target.parent.relative_to(base)) if target.parent != base else ""
             base_tag = f'<base href="/api/preview/{app_id}/{rel_dir}/">' if rel_dir else f'<base href="/api/preview/{app_id}/">'
@@ -485,7 +628,6 @@ def _create_app_bundle(url: str, app_name: str, bundle_id: str, version: str) ->
     macos.mkdir(parents=True)
     resources.mkdir(parents=True)
 
-    # Info.plist
     plist = {
         "CFBundleDevelopmentRegion": "en",
         "CFBundleExecutable": app_name.replace(" ", ""),
@@ -501,7 +643,6 @@ def _create_app_bundle(url: str, app_name: str, bundle_id: str, version: str) ->
     with open(contents / "Info.plist", "wb") as f:
         plistlib.dump(plist, f)
 
-    # Wrapper script that opens URL
     script_path = macos / app_name.replace(" ", "")
     script_content = f'''#!/bin/bash
 # Auto-generated web app wrapper
@@ -509,14 +650,12 @@ URL="{url}"
 if command -v open >/dev/null 2>&1; then
     open "$URL"
 else
-    # Fallback for Linux testing
     xdg-open "$URL" 2>/dev/null || python3 -m webbrowser "$URL"
 fi
 '''
     script_path.write_text(script_content)
     script_path.chmod(0o755)
 
-    # Create a local HTML file as backup/embedded view
     html_path = resources / "index.html"
     html_path.write_text(f'''<!DOCTYPE html>
 <html><head><meta charset="utf-8"><title>{app_name}</title>
@@ -531,7 +670,6 @@ def _create_dmg_from_app(app_bundle: Path, output_name: str) -> Path | None:
     """Best-effort DMG creation. Returns path to DMG or None."""
     dmg_path = WEBAPP_DIR / f"{output_name}.dmg"
 
-    # Try genisoimage + dmg if available (Linux)
     try:
         iso_path = WEBAPP_DIR / f"{output_name}.iso"
         result = subprocess.run(
@@ -540,7 +678,6 @@ def _create_dmg_from_app(app_bundle: Path, output_name: str) -> Path | None:
             capture_output=True, text=True, timeout=30,
         )
         if result.returncode == 0:
-            # Try converting ISO to DMG
             dmg_result = subprocess.run(
                 ["dmg", "iso", str(iso_path), str(dmg_path)],
                 capture_output=True, text=True, timeout=30,
@@ -553,7 +690,6 @@ def _create_dmg_from_app(app_bundle: Path, output_name: str) -> Path | None:
     except Exception:
         pass
 
-    # Fallback: create a ZIP that user can extract on Mac and run hdiutil
     zip_path = WEBAPP_DIR / f"{output_name}.zip"
     shutil.make_archive(
         base_name=str(WEBAPP_DIR / output_name),
@@ -585,7 +721,6 @@ async def create_webapp(request: Request) -> JSONResponse:
     if not app_name:
         return JSONResponse({"error": "App name is required"}, status_code=400)
 
-    # Sanitize
     app_name_safe = re.sub(r'[^a-zA-Z0-9 ]+', '', app_name).strip()
     if not app_name_safe:
         app_name_safe = "WebApp"
@@ -605,7 +740,9 @@ async def create_webapp(request: Request) -> JSONResponse:
             "app_id": pkg_id,
             "slug": _slugify(app_name_safe),
             "filename": dest.name,
+            "file_type": "webapp",
             "size": dest.stat().st_size,
+            "size_human": _format_bytes(dest.stat().st_size),
             "sha256": _hash_file(dest),
             "download_url": f"/api/download/{pkg_id}",
             "source_url": url,
@@ -620,21 +757,686 @@ async def create_webapp(request: Request) -> JSONResponse:
 
         return JSONResponse({
             "app": entry,
-            "message": f"'{app_name_safe}' packaged. Download and extract on macOS, then run 'hdiutil create -srcfolder {app_name_safe}.app {app_name_safe}.dmg' to convert to DMG." if pkg.suffix == ".zip" else f"'{app_name_safe}' DMG created.",
+            "message": f"'{app_name_safe}' packaged." if pkg.suffix == ".zip" else f"'{app_name_safe}' DMG created.",
         }, status_code=201)
     except Exception as exc:
         return JSONResponse({"error": str(exc)}, status_code=500)
 
 
+# ─── Tiny Netlify: deploy static sites from ZIP ─────────────────────────────
+
+def _find_index_html(root: Path) -> str | None:
+    """Find the entry HTML file in a deployed site."""
+    candidates = ["index.html", "index.htm"]
+    for c in candidates:
+        if (root / c).exists():
+            return c
+    # Search one level deep
+    for item in sorted(root.iterdir()):
+        if item.is_dir():
+            for c in candidates:
+                if (item / c).exists():
+                    return f"{item.name}/{c}"
+    # Fallback: any HTML file
+    for f in root.rglob("*.html"):
+        return str(f.relative_to(root))
+    return None
+
+
+def _build_site_tree(root: Path, max_depth: int = 3) -> list[dict[str, Any]]:
+    """Build a file tree for a deployed site."""
+    tree = []
+    try:
+        for item in sorted(root.iterdir()):
+            entry: dict[str, Any] = {
+                "name": item.name,
+                "type": "directory" if item.is_dir() else "file",
+                "size": item.stat().st_size if item.is_file() else 0,
+            }
+            if item.is_dir() and max_depth > 0:
+                entry["children"] = _build_site_tree(item, max_depth - 1)
+            tree.append(entry)
+    except Exception:
+        pass
+    return tree
+
+
+@app.post("/api/deploy-site")
+async def deploy_site(file: UploadFile = File(...)) -> JSONResponse:
+    """Deploy a static site from a ZIP file. Returns a hosted URL."""
+    if not file.filename or not file.filename.lower().endswith(".zip"):
+        return JSONResponse({"error": "Only .zip files are accepted for site deployment."}, status_code=400)
+
+    site_id = str(uuid.uuid4())
+    slug = _slugify(file.filename) or f"site-{site_id[:8]}"
+    base_slug = slug
+    counter = 1
+    while any(a.get("slug") == slug and a.get("file_type") == "site" for a in _store.values()):
+        slug = f"{base_slug}-{counter}"
+        counter += 1
+
+    # Save ZIP
+    zip_path = UPLOAD_DIR / f"{site_id}.zip"
+    with open(zip_path, "wb") as f:
+        while True:
+            chunk = await file.read(65536)
+            if not chunk:
+                break
+            f.write(chunk)
+
+    # Extract
+    site_root = SITES_DIR / site_id
+    site_root.mkdir(parents=True, exist_ok=True)
+    try:
+        with zipfile.ZipFile(zip_path, "r") as zf:
+            zf.extractall(site_root)
+    except zipfile.BadZipFile:
+        shutil.rmtree(site_root)
+        zip_path.unlink(missing_ok=True)
+        return JSONResponse({"error": "Invalid ZIP file."}, status_code=400)
+
+    # Handle nested root: if ZIP contains a single top-level dir, use that as root
+    top_items = list(site_root.iterdir())
+    if len(top_items) == 1 and top_items[0].is_dir():
+        real_root = top_items[0]
+    else:
+        real_root = site_root
+
+    index_file = _find_index_html(real_root)
+    if not index_file:
+        return JSONResponse({"error": "No HTML file found in ZIP."}, status_code=400)
+
+    sha256 = _hash_file(zip_path)
+    file_count = sum(1 for _ in real_root.rglob("*") if _.is_file())
+    total_size = sum(f.stat().st_size for f in real_root.rglob("*") if f.is_file())
+    tree = _build_site_tree(real_root)
+
+    entry = {
+        "app_id": site_id,
+        "slug": slug,
+        "filename": file.filename,
+        "file_type": "site",
+        "size": zip_path.stat().st_size,
+        "size_human": _format_bytes(zip_path.stat().st_size),
+        "sha256": sha256,
+        "site_url": f"/site/{site_id}/",
+        "site_preview": f"/site/{site_id}/{index_file}",
+        "index_file": index_file,
+        "file_count": file_count,
+        "total_size": total_size,
+        "total_size_human": _format_bytes(total_size),
+        "tree": tree,
+        "has_preview": True,
+        "preview_entry": index_file,
+        "opened": True,
+        "created_at": time.time(),
+    }
+    _store[site_id] = entry
+    _save_db()
+
+    return JSONResponse({
+        "app": entry,
+        "message": f"Site deployed. {file_count} files, {entry['size_human']}.",
+        "site_url": entry["site_url"],
+    }, status_code=201)
+
+
+@app.get("/site/{site_id}/", response_class=HTMLResponse)
+@app.get("/site/{site_id}", response_class=HTMLResponse)
+def serve_site_root(site_id: str) -> HTMLResponse:
+    """Serve a deployed static site's index page."""
+    entry = _store.get(site_id)
+    if not entry or entry.get("file_type") != "site":
+        return HTMLResponse("<h1>Site not found</h1>", status_code=404)
+
+    site_root = SITES_DIR / site_id
+    if not site_root.exists():
+        return HTMLResponse("<h1>Site files not found. Storage may have been cleared.</h1>", status_code=404)
+
+    index_file = entry.get("index_file", "index.html")
+    target = site_root / index_file
+    if not target.exists():
+        for f in site_root.rglob("*.html"):
+            target = f
+            break
+
+    if not target.exists():
+        return HTMLResponse("<h1>No HTML found</h1>", status_code=404)
+
+    content = target.read_text(errors="replace")
+    rel_dir = str(target.parent.relative_to(site_root))
+    if "<base" not in content:
+        base_href = f"/site/{site_id}/{rel_dir}/" if rel_dir and rel_dir != "." else f"/site/{site_id}/"
+        base_tag = f'<base href="{base_href}">'
+        content = content.replace("<head>", f"<head>{base_tag}", 1)
+        content = content.replace("<HEAD>", f"<HEAD>{base_tag}", 1)
+
+    return HTMLResponse(content=content)
+
+
+@app.get("/site/{site_id}/{path:path}")
+def serve_site_file(site_id: str, path: str):
+    """Serve any file from a deployed static site."""
+    entry = _store.get(site_id)
+    if not entry or entry.get("file_type") != "site":
+        return JSONResponse({"error": "Site not found"}, status_code=404)
+
+    site_root = SITES_DIR / site_id
+    if not site_root.exists():
+        return JSONResponse({"error": "Site storage cleared"}, status_code=404)
+
+    target = site_root / path
+
+    try:
+        target.resolve().relative_to(site_root.resolve())
+    except ValueError:
+        return JSONResponse({"error": "Access denied"}, status_code=403)
+
+    if not target.exists():
+        return JSONResponse({"error": "File not found"}, status_code=404)
+
+    if target.is_dir():
+        idx = target / "index.html"
+        if idx.exists():
+            content = idx.read_text(errors="replace")
+            rel_dir = str(idx.parent.relative_to(site_root))
+            if "<base" not in content:
+                base_href = f"/site/{site_id}/{rel_dir}/" if rel_dir and rel_dir != "." else f"/site/{site_id}/"
+                content = content.replace("<head>", f'<head><base href="{base_href}">', 1)
+            return HTMLResponse(content=content)
+        return JSONResponse({"error": "No index.html in directory"}, status_code=404)
+
+    mime_types = {
+        ".html": "text/html", ".htm": "text/html",
+        ".js": "application/javascript", ".mjs": "application/javascript",
+        ".css": "text/css",
+        ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg",
+        ".gif": "image/gif", ".svg": "image/svg+xml", ".webp": "image/webp",
+        ".ico": "image/x-icon",
+        ".json": "application/json", ".xml": "application/xml",
+        ".woff2": "font/woff2", ".woff": "font/woff", ".ttf": "font/ttf",
+        ".otf": "font/otf",
+        ".txt": "text/plain", ".md": "text/markdown",
+        ".wasm": "application/wasm",
+        ".map": "application/json",
+    }
+    media_type = mime_types.get(target.suffix.lower(), "application/octet-stream")
+    return FileResponse(path=target, media_type=media_type)
+
+
+# ─── GGUF Inference ─────────────────────────────────────────────────────────
+
+def _get_llm(app_id: str) -> Any | None:
+    """Load a GGUF model into memory, with caching."""
+    if not HAS_LLAMA:
+        return None
+
+    if app_id in _llm_cache:
+        return _llm_cache[app_id]
+
+    entry = _store.get(app_id)
+    if not entry or entry.get("file_type") != "gguf":
+        return None
+
+    gguf_path = UPLOAD_DIR / f"{app_id}.gguf"
+    if not gguf_path.exists():
+        return None
+
+    try:
+        ctx = entry.get("gguf", {}).get("context_length", 2048)
+        n_ctx = min(int(ctx) if ctx else 2048, 4096)
+        llm = _Llama(model_path=str(gguf_path), n_ctx=n_ctx, verbose=False)
+        _llm_cache[app_id] = llm
+        return llm
+    except Exception:
+        return None
+
+
+@app.get("/api/inference/status")
+def inference_status() -> JSONResponse:
+    """Check if GGUF inference is available."""
+    loaded = list(_llm_cache.keys())
+    gguf_apps = [a for a in _store.values() if a.get("file_type") == "gguf"]
+    return JSONResponse({
+        "available": HAS_LLAMA,
+        "loaded_models": len(loaded),
+        "loaded_ids": loaded,
+        "gguf_apps": [{"app_id": a["app_id"], "filename": a["filename"]} for a in gguf_apps],
+    })
+
+
+@app.post("/api/inference/load/{app_id}")
+def load_model(app_id: str) -> JSONResponse:
+    """Load a GGUF model into memory for inference."""
+    if not HAS_LLAMA:
+        return JSONResponse({
+            "error": "llama-cpp-python not installed. Inference unavailable.",
+            "hint": "Add llama-cpp-python to requirements.txt to enable inference.",
+        }, status_code=503)
+
+    entry = _store.get(app_id)
+    if not entry or entry.get("file_type") != "gguf":
+        return JSONResponse({"error": "Not a GGUF artifact."}, status_code=400)
+
+    llm = _get_llm(app_id)
+    if llm is None:
+        return JSONResponse({"error": "Failed to load model."}, status_code=500)
+
+    return JSONResponse({
+        "ok": True,
+        "message": f"Model '{entry['filename']}' loaded.",
+        "context_length": entry.get("gguf", {}).get("context_length", 2048),
+    })
+
+
+@app.post("/api/inference/chat/{app_id}")
+async def inference_chat(app_id: str, request: Request) -> JSONResponse:
+    """OpenAI-compatible chat completion endpoint using a loaded GGUF model."""
+    if not HAS_LLAMA:
+        return JSONResponse({"error": "Inference unavailable. llama-cpp-python not installed."}, status_code=503)
+
+    llm = _get_llm(app_id)
+    if llm is None:
+        return JSONResponse({"error": "Model not loaded. POST /api/inference/load/{app_id} first."}, status_code=400)
+
+    try:
+        data = await request.json()
+    except Exception:
+        return JSONResponse({"error": "Invalid JSON"}, status_code=400)
+
+    messages = data.get("messages", [])
+    if not messages:
+        return JSONResponse({"error": "messages is required"}, status_code=400)
+
+    max_tokens = min(int(data.get("max_tokens", 512)), 2048)
+    temperature = float(data.get("temperature", 0.7))
+    stream = bool(data.get("stream", False))
+
+    if stream:
+        def gen():
+            for chunk in llm.create_chat_completion(
+                messages=messages, max_tokens=max_tokens,
+                temperature=temperature, stream=True,
+            ):
+                yield f"data: {json.dumps(chunk)}\n\n"
+            yield "data: [DONE]\n\n"
+        return StreamingResponse(gen(), media_type="text/event-stream")
+
+    result = llm.create_chat_completion(
+        messages=messages, max_tokens=max_tokens, temperature=temperature,
+    )
+    return JSONResponse(result)
+
+
+@app.post("/api/inference/completion/{app_id}")
+async def inference_completion(app_id: str, request: Request) -> JSONResponse:
+    """Text completion endpoint using a loaded GGUF model."""
+    if not HAS_LLAMA:
+        return JSONResponse({"error": "Inference unavailable. llama-cpp-python not installed."}, status_code=503)
+
+    llm = _get_llm(app_id)
+    if llm is None:
+        return JSONResponse({"error": "Model not loaded."}, status_code=400)
+
+    try:
+        data = await request.json()
+    except Exception:
+        return JSONResponse({"error": "Invalid JSON"}, status_code=400)
+
+    prompt = data.get("prompt", "")
+    if not prompt:
+        return JSONResponse({"error": "prompt is required"}, status_code=400)
+
+    max_tokens = min(int(data.get("max_tokens", 256)), 2048)
+    temperature = float(data.get("temperature", 0.7))
+
+    result = llm(prompt=prompt, max_tokens=max_tokens, temperature=temperature)
+    return JSONResponse(result)
+
+
+# ─── ChatGPT Export → dApp ──────────────────────────────────────────────────
+
+def _parse_chatgpt_export(data: Any) -> dict[str, Any]:
+    """Parse a ChatGPT export conversations.json structure."""
+    conversations = []
+    raw = data if isinstance(data, list) else data.get("conversations", data) if isinstance(data, dict) else []
+
+    for conv in raw:
+        if not isinstance(conv, dict):
+            continue
+        title = conv.get("title", "Untitled")
+        conv_id = conv.get("id", conv.get("uuid", str(uuid.uuid4())))
+        create_time = conv.get("create_time", 0)
+        update_time = conv.get("update_time", 0)
+
+        messages = []
+        mapping = conv.get("mapping", {})
+        if isinstance(mapping, dict):
+            for node_id, node in mapping.items():
+                if not isinstance(node, dict):
+                    continue
+                msg = node.get("message")
+                if not msg or not isinstance(msg, dict):
+                    continue
+                author = msg.get("author", {})
+                role = author.get("role", "unknown")
+                content = msg.get("content", {})
+                parts = content.get("parts", [])
+                text = ""
+                for p in parts:
+                    if isinstance(p, str):
+                        text += p
+                    elif isinstance(p, dict):
+                        text += p.get("text", str(p))
+                if text.strip():
+                    messages.append({
+                        "role": role,
+                        "text": text[:50000],
+                        "create_time": msg.get("create_time", 0),
+                    })
+
+        messages.sort(key=lambda m: m.get("create_time", 0) or 0)
+        conversations.append({
+            "id": str(conv_id),
+            "title": title,
+            "message_count": len(messages),
+            "create_time": create_time,
+            "update_time": update_time,
+            "messages": messages,
+        })
+
+    conversations.sort(key=lambda c: c.get("create_time", 0) or 0, reverse=True)
+    return {"conversations": conversations, "total": len(conversations)}
+
+
+def _generate_dapp_html(parsed: dict[str, Any], title: str) -> str:
+    """Generate a self-contained dApp HTML for browsing ChatGPT conversations."""
+    convs = parsed["conversations"]
+    convs_json = json.dumps(convs[:500])  # Limit to 500 conversations
+
+    return f'''<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>{title} — ChatGPT Archive dApp</title>
+<style>
+* {{ box-sizing: border-box; margin: 0; padding: 0; }}
+body {{ background: #0a0a0f; color: #e2e2e8; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; height: 100vh; display: flex; overflow: hidden; }}
+.sidebar {{ width: 300px; min-width: 300px; background: #14141a; border-right: 1px solid #2a2a35; overflow-y: auto; display: flex; flex-direction: column; }}
+.sidebar-header {{ padding: 16px; border-bottom: 1px solid #2a2a35; }}
+.sidebar-header h2 {{ font-size: 1rem; margin-bottom: 4px; }}
+.sidebar-header .count {{ font-size: 0.8rem; color: #888898; }}
+.search {{ padding: 12px 16px; border-bottom: 1px solid #2a2a35; }}
+.search input {{ width: 100%; background: #0a0a0f; border: 1px solid #2a2a35; color: #e2e2e8; padding: 8px 12px; border-radius: 8px; font-size: 0.85rem; outline: none; }}
+.search input:focus {{ border-color: #6366f1; }}
+.conv-list {{ flex: 1; overflow-y: auto; }}
+.conv-item {{ padding: 12px 16px; border-bottom: 1px solid #1c1c24; cursor: pointer; transition: background 0.15s; }}
+.conv-item:hover {{ background: #1c1c24; }}
+.conv-item.active {{ background: rgba(99,102,241,0.15); border-left: 3px solid #6366f1; }}
+.conv-item .title {{ font-size: 0.88rem; font-weight: 500; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }}
+.conv-item .meta {{ font-size: 0.75rem; color: #5a5a68; margin-top: 2px; }}
+.main {{ flex: 1; overflow-y: auto; padding: 24px 32px; }}
+.welcome {{ display: flex; flex-direction: column; align-items: center; justify-content: center; height: 100%; color: #5a5a68; }}
+.welcome .icon {{ font-size: 3rem; margin-bottom: 12px; }}
+.welcome h3 {{ font-size: 1.1rem; margin-bottom: 4px; color: #888898; }}
+.msg {{ margin-bottom: 20px; max-width: 800px; }}
+.msg .role {{ font-size: 0.78rem; font-weight: 600; margin-bottom: 4px; text-transform: uppercase; letter-spacing: 0.05em; }}
+.msg .role.user {{ color: #6366f1; }}
+.msg .role.assistant {{ color: #22c55e; }}
+.msg .role.system {{ color: #eab300; }}
+.msg .bubble {{ background: #14141a; border: 1px solid #2a2a35; border-radius: 12px; padding: 14px 18px; font-size: 0.9rem; line-height: 1.6; white-space: pre-wrap; word-break: break-word; }}
+.msg .bubble.user {{ border-left: 3px solid #6366f1; }}
+.msg .bubble.assistant {{ border-left: 3px solid #22c55e; }}
+.empty {{ text-align: center; padding: 40px; color: #5a5a68; }}
+</style>
+</head>
+<body>
+<div class="sidebar">
+  <div class="sidebar-header">
+    <h2>⬡ {title}</h2>
+    <div class="count">{parsed["total"]} conversations</div>
+  </div>
+  <div class="search">
+    <input type="text" id="search" placeholder="Search conversations..." oninput="filterConvs()">
+  </div>
+  <div class="conv-list" id="conv-list"></div>
+</div>
+<div class="main" id="main">
+  <div class="welcome">
+    <div class="icon">💬</div>
+    <h3>ChatGPT Archive dApp</h3>
+    <p>Select a conversation to browse</p>
+  </div>
+</div>
+<script>
+const CONVS = {convs_json};
+let activeId = null;
+
+function renderConvList(filter) {{
+  filter = (filter || "").toLowerCase();
+  const list = document.getElementById("conv-list");
+  const filtered = CONVS.filter(c => c.title.toLowerCase().includes(filter));
+  list.innerHTML = filtered.map(c => `
+    <div class="conv-item ${{c.id === activeId ? 'active' : ''}}" onclick="selectConv('${{c.id}}')">
+      <div class="title">${{escHtml(c.title)}}</div>
+      <div class="meta">${{c.message_count}} messages</div>
+    </div>
+  `).join('') || '<div class="empty">No matches</div>';
+}}
+
+function selectConv(id) {{
+  activeId = id;
+  const conv = CONVS.find(c => c.id === id);
+  if (!conv) return;
+  const main = document.getElementById("main");
+  main.innerHTML = `<div style="margin-bottom:20px"><h2 style="font-size:1.2rem">${{escHtml(conv.title)}}</h2><div style="font-size:0.8rem;color:#888898">${{conv.message_count}} messages</div></div>` +
+    conv.messages.map(m => `
+      <div class="msg">
+        <div class="role ${{m.role}}">${{m.role}}</div>
+        <div class="bubble ${{m.role}}">${{escHtml(m.text)}}</div>
+      </div>
+    `).join('');
+  renderConvList(document.getElementById("search").value);
+  main.scrollTop = 0;
+}}
+
+function filterConvs() {{
+  renderConvList(document.getElementById("search").value);
+}}
+
+function escHtml(s) {{
+  if (!s) return '';
+  return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
+}}
+
+renderConvList();
+</script>
+</body>
+</html>'''
+
+
+@app.post("/api/import/chatgpt")
+async def import_chatgpt(file: UploadFile = File(...)) -> JSONResponse:
+    """Import a ChatGPT export (conversations.json) and deploy as a browsable dApp."""
+    if not file.filename:
+        return JSONResponse({"error": "No filename provided."}, status_code=400)
+
+    fname = file.filename.lower()
+    if not (fname.endswith(".json") or fname.endswith(".zip")):
+        return JSONResponse({"error": "Only .json or .zip ChatGPT exports are accepted."}, status_code=400)
+
+    app_id = str(uuid.uuid4())
+    slug = _slugify(file.filename) or f"chatgpt-archive-{app_id[:8]}"
+
+    # Save the uploaded file
+    if fname.endswith(".zip"):
+        zip_path = UPLOAD_DIR / f"{app_id}.zip"
+        with open(zip_path, "wb") as f:
+            while True:
+                chunk = await file.read(65536)
+                if not chunk:
+                    break
+                f.write(chunk)
+        # Extract and find conversations.json
+        extract_to = EXTRACT_DIR / app_id
+        extract_to.mkdir(parents=True, exist_ok=True)
+        try:
+            with zipfile.ZipFile(zip_path, "r") as zf:
+                zf.extractall(extract_to)
+        except zipfile.BadZipFile:
+            shutil.rmtree(extract_to)
+            zip_path.unlink(missing_ok=True)
+            return JSONResponse({"error": "Invalid ZIP file."}, status_code=400)
+
+        # Find conversations.json
+        conv_file = None
+        for f in extract_to.rglob("conversations.json"):
+            conv_file = f
+            break
+        if not conv_file:
+            shutil.rmtree(extract_to)
+            return JSONResponse({"error": "No conversations.json found in ZIP export."}, status_code=400)
+        raw_data = json.loads(conv_file.read_text(encoding="utf-8"))
+        sha256 = _hash_file(zip_path)
+        stored_size = zip_path.stat().st_size
+    else:
+        # Direct JSON upload
+        json_path = UPLOAD_DIR / f"{app_id}.json"
+        with open(json_path, "wb") as f:
+            while True:
+                chunk = await file.read(65536)
+                if not chunk:
+                    break
+                f.write(chunk)
+        try:
+            raw_data = json.loads(json_path.read_text(encoding="utf-8"))
+        except json.JSONDecodeError:
+            json_path.unlink(missing_ok=True)
+            return JSONResponse({"error": "Invalid JSON file."}, status_code=400)
+        sha256 = _hash_file(json_path)
+        stored_size = json_path.stat().st_size
+
+    # Parse the ChatGPT export
+    parsed = _parse_chatgpt_export(raw_data)
+    if parsed["total"] == 0:
+        return JSONResponse({"error": "No conversations found in export."}, status_code=400)
+
+    # Generate dApp HTML
+    title = f"ChatGPT Archive ({parsed['total']} conversations)"
+    dapp_html = _generate_dapp_html(parsed, title)
+
+    # Deploy as a site
+    dapp_root = DAPPS_DIR / app_id
+    dapp_root.mkdir(parents=True, exist_ok=True)
+    (dapp_root / "index.html").write_text(dapp_html, encoding="utf-8")
+
+    entry = {
+        "app_id": app_id,
+        "slug": slug,
+        "filename": file.filename,
+        "file_type": "chatgpt",
+        "size": stored_size,
+        "size_human": _format_bytes(stored_size),
+        "sha256": sha256,
+        "dapp_url": f"/dapp/{app_id}/",
+        "conversation_count": parsed["total"],
+        "total_messages": sum(c["message_count"] for c in parsed["conversations"]),
+        "has_preview": True,
+        "preview_entry": "index.html",
+        "opened": True,
+        "created_at": time.time(),
+    }
+    _store[app_id] = entry
+    _save_db()
+
+    return JSONResponse({
+        "app": entry,
+        "message": f"ChatGPT archive deployed as dApp. {parsed['total']} conversations, {entry['total_messages']} messages.",
+        "dapp_url": entry["dapp_url"],
+    }, status_code=201)
+
+
+@app.get("/dapp/{app_id}/", response_class=HTMLResponse)
+@app.get("/dapp/{app_id}", response_class=HTMLResponse)
+def serve_dapp(app_id: str) -> HTMLResponse:
+    """Serve a deployed ChatGPT dApp."""
+    entry = _store.get(app_id)
+    if not entry or entry.get("file_type") != "chatgpt":
+        return HTMLResponse("<h1>dApp not found</h1>", status_code=404)
+
+    dapp_root = DAPPS_DIR / app_id
+    if not dapp_root.exists():
+        return HTMLResponse("<h1>dApp files not found. Storage may have been cleared.</h1>", status_code=404)
+
+    index = dapp_root / "index.html"
+    if not index.exists():
+        return HTMLResponse("<h1>dApp index not found</h1>", status_code=404)
+
+    return HTMLResponse(content=index.read_text(encoding="utf-8"))
+
+
+@app.get("/dapp/{app_id}/{path:path}")
+def serve_dapp_file(app_id: str, path: str):
+    """Serve any file from a deployed dApp."""
+    entry = _store.get(app_id)
+    if not entry or entry.get("file_type") != "chatgpt":
+        return JSONResponse({"error": "dApp not found"}, status_code=404)
+
+    dapp_root = DAPPS_DIR / app_id
+    if not dapp_root.exists():
+        return JSONResponse({"error": "dApp storage cleared"}, status_code=404)
+
+    target = dapp_root / path
+    try:
+        target.resolve().relative_to(dapp_root.resolve())
+    except ValueError:
+        return JSONResponse({"error": "Access denied"}, status_code=403)
+
+    if not target.exists():
+        return JSONResponse({"error": "File not found"}, status_code=404)
+
+    return FileResponse(path=target)
+
+
+@app.get("/api/storage/status")
+def storage_status() -> JSONResponse:
+    """Check if persistent storage is attached."""
+    persistent = str(DATA_DIR).startswith("/data")
+    return JSONResponse({
+        "persistent": persistent,
+        "data_dir": str(DATA_DIR),
+        "has_uploads": UPLOAD_DIR.exists(),
+        "has_extracted": EXTRACT_DIR.exists(),
+        "has_sites": SITES_DIR.exists(),
+        "has_dapps": DAPPS_DIR.exists(),
+        "inference_available": HAS_LLAMA,
+        "artifact_count": len(_store),
+    })
+
+
 @app.delete("/api/apps/{app_id}")
 def delete_app(app_id: str) -> JSONResponse:
     entry = _store.pop(app_id, None)
     if entry:
-        dmg = UPLOAD_DIR / f"{app_id}.dmg"
-        if dmg.exists():
-            dmg.unlink()
+        # Clean up uploads (all possible extensions)
+        for suffix in [".dmg", ".gguf", ".zip", ".json"]:
+            f = UPLOAD_DIR / f"{app_id}{suffix}"
+            if f.exists():
+                f.unlink()
+        # Clean up extracted files
         extracted = EXTRACT_DIR / app_id
         if extracted.exists():
             shutil.rmtree(extracted)
+        # Clean up deployed sites
+        site = SITES_DIR / app_id
+        if site.exists():
+            shutil.rmtree(site)
+        # Clean up dapps
+        dapp = DAPPS_DIR / app_id
+        if dapp.exists():
+            shutil.rmtree(dapp)
+        # Unload model from inference cache
+        _llm_cache.pop(app_id, None)
         _save_db()
     return JSONResponse({"ok": True})