ltcai 11.5.2 → 11.7.0

package/latticeai/api/setup.py

@@ -1,319 +0,0 @@
-"""Setup wizard and OS permission routes."""
-
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-from fastapi import APIRouter, HTTPException, Request
-from fastapi.responses import StreamingResponse
-from pydantic import BaseModel
-
-from lattice_brain.ingestion import IngestionItem
-from latticeai.core.messages import http_error, resolve_language
-from latticeai.models.router import parse_model_ref
-from latticeai.services.process_audit import command_plan
-from latticeai.setup.auto_setup import (
-    plan as auto_setup_plan,
-)
-from latticeai.setup.auto_setup import (
-    preset as auto_setup_preset,
-)
-from latticeai.setup.auto_setup import (
-    probe as auto_setup_probe,
-)
-from latticeai.setup.auto_setup import (
-    recommend as auto_setup_recommend,
-)
-from latticeai.setup.auto_setup import (
-    verify as auto_setup_verify,
-)
-from latticeai.setup.demo_corpus import (
-    DEMO_DOCUMENTS,
-    DEMO_METADATA_FLAG,
-    DEMO_URI_PREFIX,
-    demo_source_uri,
-    suggested_questions,
-)
-from latticeai.setup.wizard import (
-    get_recommendations,
-    install_stream,
-    open_url,
-    scan_environment,
-)
-
-
-class SetupInstallRequest(BaseModel):
-    items: List[Dict]
-    confirmation_token: Optional[str] = None
-
-
-class DemoCorpusRequest(BaseModel):
-    workspace_id: Optional[str] = None
-
-
-def create_setup_router(
-    *,
-    model_router,
-    require_user,
-    ingestion_pipeline=None,
-    knowledge_graph=None,
-    workspace_service=None,
-) -> APIRouter:
-    api_router = APIRouter()
-    router = model_router
-
-    # ── Setup Wizard ─────────────────────────────────────────────────────────────
-
-    def setup_auto_state() -> Dict[str, Any]:
-        """Return the PPT-aligned zero-config setup state used by setup UI/API."""
-        profile = auto_setup_probe()
-        recommendation = auto_setup_recommend(profile)
-        install_plan = auto_setup_plan(profile, recommendation)
-        return {
-            "probe": profile.to_json(),
-            "recommend": recommendation.to_json(),
-            "plan": install_plan.to_json(),
-            "verify": auto_setup_verify(profile, recommendation),
-            "preset": auto_setup_preset(profile, recommendation),
-        }
-    
-    
-    def primary_setup_model(recs: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-        models = recs.get("models") if isinstance(recs, dict) else None
-        if not isinstance(models, list):
-            return None
-        candidates = [
-            item for item in models
-            if isinstance(item, dict) and not item.get("disabled") and (item.get("model_id") or (item.get("action") or {}).get("model_id"))
-        ]
-        if not candidates:
-            return None
-        return next((item for item in candidates if item.get("checked")), candidates[0])
-    
-    
-    @api_router.get("/setup/scan")
-    async def setup_scan(request: Request):
-        """환경 감지 및 맞춤 추천 반환."""
-        require_user(request)
-        env  = scan_environment()
-        recs = get_recommendations(env)
-        zero_config = setup_auto_state()
-        primary_model = primary_setup_model(recs)
-        if primary_model:
-            model_id = primary_model.get("model_id") or (primary_model.get("action") or {}).get("model_id")
-            model_provider, provider_model = parse_model_ref(str(model_id))
-            primary_runtime = "mlx" if model_provider == "local_mlx" else model_provider
-            zero_config.setdefault("recommend", {})["model_id"] = model_id
-            zero_config["recommend"]["runtime"] = primary_runtime
-            rationale = [
-                item for item in zero_config["recommend"].get("rationale", [])
-                if not (isinstance(item, str) and item.startswith("RAM ") and "→" in item)
-            ]
-            rationale.append(f"실제 다운로드 및 로드 가능한 {primary_runtime} 모델 → {model_id}")
-            zero_config["recommend"]["rationale"] = rationale
-            if isinstance(zero_config.get("plan"), dict):
-                if model_provider == "ollama":
-                    command = ["ollama", "pull", provider_model]
-                elif model_provider in {"vllm", "lmstudio", "llamacpp"}:
-                    command = ["lattice-ai", "models", "load", str(model_id)]
-                else:
-                    command = ["huggingface-cli", "download", str(model_id), "--quiet"]
-                step_plan = command_plan(
-                    command,
-                    name=f"weights:{model_id}",
-                    purpose="auto_setup_install",
-                    metadata={"model_id": str(model_id)},
-                )
-                zero_config["plan"]["steps"] = [{
-                    "name": f"weights:{model_id}",
-                    "why": "추론에 사용할 모델 가중치",
-                    "command": command,
-                    "requires_admin": False,
-                    "command_plan": step_plan,
-                    "confirmation_token": step_plan["confirmation_token"],
-                }]
-            if isinstance(zero_config.get("preset"), dict):
-                zero_config["preset"].setdefault("model", {})["id"] = model_id
-                zero_config["preset"]["model"]["runtime"] = primary_runtime
-        env["zero_config"] = zero_config
-        recs.setdefault("summary", {})["zero_config"] = zero_config["recommend"]
-        recs["install_plan"] = zero_config["plan"]
-        recs["preset"] = zero_config["preset"]
-        return {"environment": env, "recommendations": recs, "zero_config": zero_config}
-    
-    @api_router.get("/setup/auto")
-    async def setup_auto(request: Request):
-        """PPT-aligned zero-config setup pipeline: probe → recommend → plan → verify → preset."""
-        require_user(request)
-        return setup_auto_state()
-    
-    @api_router.post("/setup/install")
-    async def setup_install(req: SetupInstallRequest, request: Request):
-        """선택된 항목을 순서대로 설치 · 로드하는 SSE 스트림."""
-        user_email = require_user(request)
-        async def _gen():
-            async for chunk in install_stream(
-                req.items,
-                router,
-                confirmation_token=req.confirmation_token,
-                user_email=user_email,
-            ):
-                yield chunk
-        return StreamingResponse(_gen(), media_type="text/event-stream",
-                                 headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"})
-    
-    @api_router.post("/setup/open-auth/{mcp_id}")
-    async def setup_open_auth(mcp_id: str, request: Request):
-        require_user(request)
-        """MCP 인증 페이지를 브라우저에서 자동으로 엽니다."""
-        auth_urls: Dict[str, str] = {
-            "github":      "https://github.com/apps",
-            "google-drive": "https://chatgpt.com/connectors",
-            "slack":       "https://chatgpt.com/connectors",
-            "chrome":      "https://chatgpt.com/connectors",
-            "computer-use": "https://chatgpt.com/connectors",
-            "figma":       "https://chatgpt.com/connectors",
-            "notion":      "https://chatgpt.com/connectors",
-            "linear":      "https://chatgpt.com/connectors",
-            "gmail":       "https://chatgpt.com/connectors",
-            "google-calendar": "https://chatgpt.com/connectors",
-            "outlook-email": "https://chatgpt.com/connectors",
-            "outlook-calendar": "https://chatgpt.com/connectors",
-            "teams":       "https://chatgpt.com/connectors",
-            "sharepoint":  "https://chatgpt.com/connectors",
-            "canva":       "https://chatgpt.com/connectors",
-        }
-        url = auth_urls.get(mcp_id)
-        if not url:
-            raise http_error(404, "mcp.unknown_id", resolve_language(request), mcp_id=mcp_id)
-        open_url(url)
-        return {"status": "ok", "opened": url, "mcp_id": mcp_id}
-    
-    
-    # ── First Value Loop demo corpus (backlog #3, review §3.3 P0) ────────────
-
-    def _require_demo_pipeline(request: Request):
-        if ingestion_pipeline is None or not ingestion_pipeline.available():
-            raise http_error(503, "capture.ingestion_disabled", resolve_language(request))
-        if knowledge_graph is None:
-            raise http_error(503, "common.graph_disabled", resolve_language(request))
-
-    def _demo_workspace(request: Request, body_workspace: Optional[str], user: str) -> Optional[str]:
-        header = request.headers.get("X-Workspace-Id")
-        header = header.strip() if header and header.strip() else None
-        supplied = [value for value in (body_workspace, header) if value]
-        if len(set(supplied)) > 1:
-            raise http_error(403, "common.workspace_mismatch", resolve_language(request))
-        requested = supplied[0] if supplied else None
-        if workspace_service is None:
-            return requested
-        try:
-            return workspace_service.resolve_write_scope(requested, user or None)
-        except PermissionError as exc:
-            raise HTTPException(status_code=403, detail=str(exc)) from exc
-
-    @api_router.get("/api/setup/demo-corpus")
-    async def demo_corpus_status(request: Request):
-        """Whether the demo corpus is installed + the suggestion chips."""
-        require_user(request)
-        _require_demo_pipeline(request)
-        installed = knowledge_graph.find_documents_by_uri_prefix(DEMO_URI_PREFIX)
-        return {
-            "installed": bool(installed),
-            "documents": installed,
-            "document_count": len(installed),
-            "suggested_questions": suggested_questions(),
-        }
-
-    @api_router.post("/api/setup/demo-corpus")
-    async def demo_corpus_install(request: Request, req: Optional[DemoCorpusRequest] = None):
-        """One-click ingest of the 3 built-in demo documents (idempotent).
-
-        Every document goes through the normal IngestionPipeline door with
-        ``demo://`` provenance so it is honest (real nodes, real chunks, real
-        provenance) and removable via DELETE. Re-POSTing reports duplicates
-        instead of duplicating.
-        """
-        user = require_user(request)
-        _require_demo_pipeline(request)
-        workspace_id = _demo_workspace(request, req.workspace_id if req else None, user)
-        results = []
-        ingested = 0
-        duplicates = 0
-        failed = 0
-        for doc in DEMO_DOCUMENTS:
-            result = ingestion_pipeline.ingest(
-                IngestionItem(
-                    source_type="note",
-                    title=doc["title"],
-                    text=doc["text"],
-                    source_uri=demo_source_uri(doc["id"]),
-                    owner=user or None,
-                    workspace_id=workspace_id,
-                    metadata={DEMO_METADATA_FLAG: True, "demo_id": doc["id"]},
-                ),
-                user_email=user or None,
-            )
-            if result.status != "ok":
-                failed += 1
-            elif result.duplicate:
-                duplicates += 1
-            else:
-                ingested += 1
-            results.append({
-                "demo_id": doc["id"],
-                "title": doc["title"],
-                "source_uri": demo_source_uri(doc["id"]),
-                "status": result.status,
-                "node_id": result.node_id,
-                "duplicate": result.duplicate,
-                "chunk_count": result.chunk_count,
-                "detail": result.detail,
-            })
-        status = "ok" if failed == 0 else ("partial" if (ingested + duplicates) else "failed")
-        return {
-            "status": status,
-            "ingested": ingested,
-            "duplicates": duplicates,
-            "failed": failed,
-            "documents": results,
-            "suggested_questions": suggested_questions(),
-        }
-
-    @api_router.delete("/api/setup/demo-corpus")
-    async def demo_corpus_remove(request: Request):
-        """Remove every demo document (node + chunks + edges + orphan source)."""
-        require_user(request)
-        _require_demo_pipeline(request)
-        installed = knowledge_graph.find_documents_by_uri_prefix(DEMO_URI_PREFIX)
-        removed = []
-        for doc in installed:
-            outcome = knowledge_graph.delete_document_tree(doc["id"])
-            removed.append({
-                "node_id": doc["id"],
-                "title": doc.get("title"),
-                "source_uri": doc.get("source_uri"),
-                "status": outcome.get("status"),
-                "removed_nodes": outcome.get("removed_nodes", 0),
-            })
-        return {
-            "status": "ok",
-            "removed_count": len(removed),
-            "removed": removed,
-        }
-
-    @api_router.post("/permissions/open/{permission_id}")
-    async def open_permission_settings(permission_id: str, request: Request):
-        require_user(request)
-        """macOS 권한 설정 화면을 엽니다."""
-        urls = {
-            "accessibility": "x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility",
-            "automation": "x-apple.systempreferences:com.apple.preference.security?Privacy_Automation",
-            "screen": "x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenCapture",
-        }
-        url = urls.get(permission_id)
-        if not url:
-            raise http_error(404, "setup.unknown_permission", resolve_language(request))
-        open_url(url)
-        return {"status": "ok", "opened": url, "permission": permission_id}
-    return api_router

package/latticeai/api/static_routes.py

@@ -1,354 +0,0 @@
-"""Static UI and lightweight status routes."""
-
-from __future__ import annotations
-
-import asyncio
-import hashlib
-import hmac
-import re
-import secrets
-import subprocess
-import time
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, Callable, Dict, Optional
-
-from fastapi import APIRouter, Cookie, HTTPException, Request
-from fastapi.responses import FileResponse, HTMLResponse
-
-from latticeai.api.ui_redirects import app_redirect
-from latticeai.core.quiet import quiet
-
-PRODUCTION_CSP = (
-    "default-src 'self'; "
-    "script-src 'self'; "
-    "style-src 'self' 'unsafe-inline'; "
-    "img-src 'self' data: blob: http://127.0.0.1:*; "
-    "font-src 'self' data:; "
-    # No `ws:`: this product has no WebSocket endpoint anywhere. The live
-    # surfaces (chat, agent steps, index progress) are server-sent events, read
-    # with fetch/ReadableStream, which `connect-src` already covers over http.
-    "connect-src 'self' http://127.0.0.1:*; "
-    "frame-src 'none'; "
-    "object-src 'none'; "
-    "base-uri 'none'; "
-    "form-action 'self'; "
-    "frame-ancestors 'none'"
-)
-
-INVITE_COOKIE_NAME = "lattice_invite"
-INVITE_COOKIE_TTL_SECONDS = 60 * 60 * 24 * 7
-
-# Host-capacity plain-language judgment for System basic mode (layout rebuild).
-# Thresholds live here so the frontend never re-derives copy from raw percents.
-SYSINFO_READINESS_ROOMY_MAX = 55.0
-SYSINFO_READINESS_TIGHT_MAX = 80.0
-
-
-def _probe_host_capacity() -> Dict[str, Any]:
-    """Sample CPU / RAM / GPU on this machine. Blocking — call off the loop.
-
-    Extracted from the route so the subprocess sampling can be handed to a
-    worker thread, and so the parsing is testable without an HTTP request.
-    """
-    result: Dict[str, Any] = {
-        "cpu_pct": 0.0,
-        "ram_pct": 0.0,
-        "gpu_mem_pct": 0.0,
-        "gpu_mem_gb": 0.0,
-        "readiness": "roomy",
-    }
-    try:
-        # CPU
-        top_out = subprocess.run(["top", "-l", "1", "-n", "0"], capture_output=True, text=True, timeout=4).stdout
-        for line in top_out.splitlines():
-            if "CPU usage" in line:
-                m = re.search(r"([\d.]+)% user.*?([\d.]+)% sys", line)
-                if m:
-                    result["cpu_pct"] = round(float(m.group(1)) + float(m.group(2)), 1)
-        # RAM
-        vm_out = subprocess.run(["vm_stat"], capture_output=True, text=True, timeout=4).stdout
-        pages: dict = {}
-        for line in vm_out.splitlines():
-            for key in ["Pages free", "Pages active", "Pages inactive", "Pages wired down", "Pages occupied by compressor"]:
-                if line.startswith(key):
-                    m = re.search(r"(\d+)", line)
-                    if m:
-                        pages[key] = int(m.group(1))
-        total = sum(pages.values())
-        used = total - pages.get("Pages free", 0)
-        result["ram_pct"] = round(used / total * 100, 1) if total else 0.0
-        # GPU (MLX / Apple Silicon unified memory)
-        try:
-            import mlx.core as _mx
-            hw_out = subprocess.run(["sysctl", "-n", "hw.memsize"], capture_output=True, text=True, timeout=2).stdout
-            total_bytes = int(hw_out.strip())
-            gpu_bytes = _mx.get_active_memory() + _mx.get_cache_memory()
-            result["gpu_mem_gb"] = round(gpu_bytes / (1024 ** 3), 2)
-            result["gpu_mem_pct"] = round(gpu_bytes / total_bytes * 100, 1) if total_bytes else 0.0
-        except Exception:
-            quiet()
-    except Exception as e:
-        result["error"] = str(e)
-    result["readiness"] = host_capacity_readiness(
-        cpu_pct=float(result.get("cpu_pct") or 0.0),
-        ram_pct=float(result.get("ram_pct") or 0.0),
-        gpu_mem_pct=float(result.get("gpu_mem_pct") or 0.0),
-    )
-    return result
-
-
-def host_capacity_readiness(
-    *,
-    cpu_pct: float = 0.0,
-    ram_pct: float = 0.0,
-    gpu_mem_pct: float = 0.0,
-) -> str:
-    """Map host telemetry to a single plain-language readiness bucket.
-
-    Returns one of ``roomy`` / ``tight`` / ``low``. The product uses this so
-    basic-mode System copy and advanced-mode numbers share one judgment.
-    """
-    load = max(float(cpu_pct or 0.0), float(ram_pct or 0.0), float(gpu_mem_pct or 0.0))
-    if load <= SYSINFO_READINESS_ROOMY_MAX:
-        return "roomy"
-    if load <= SYSINFO_READINESS_TIGHT_MAX:
-        return "tight"
-    return "low"
-
-
-def _sign_invite_cookie(secret: str, *, now: Optional[int] = None) -> str:
-    """Create an expiring, nonce-bearing invite-gate capability cookie."""
-
-    issued_at = int(time.time() if now is None else now)
-    expires_at = issued_at + INVITE_COOKIE_TTL_SECONDS
-    nonce = secrets.token_urlsafe(24)
-    payload = f"{expires_at}.{nonce}"
-    signature = hmac.new(
-        str(secret).encode("utf-8"),
-        payload.encode("utf-8"),
-        hashlib.sha256,
-    ).hexdigest()
-    return f"v1.{payload}.{signature}"
-
-
-def _verify_invite_cookie(
-    value: Optional[str],
-    secret: str,
-    *,
-    now: Optional[int] = None,
-) -> bool:
-    """Verify version, expiry and HMAC without trusting client claims."""
-
-    if not value or not secret:
-        return False
-    try:
-        version, raw_expiry, nonce, supplied_signature = value.split(".", 3)
-        expires_at = int(raw_expiry)
-    except (TypeError, ValueError):
-        return False
-    if version != "v1" or not nonce or expires_at <= int(time.time() if now is None else now):
-        return False
-    payload = f"{expires_at}.{nonce}"
-    expected_signature = hmac.new(
-        str(secret).encode("utf-8"),
-        payload.encode("utf-8"),
-        hashlib.sha256,
-    ).hexdigest()
-    return hmac.compare_digest(supplied_signature, expected_signature)
-
-
-def _invite_denied_response() -> HTMLResponse:
-    return HTMLResponse(
-        content="""
-            <body style="background:#0f1115; color:white; display:flex; flex-direction:column; align-items:center; justify-content:center; height:100vh; font-family:sans-serif;">
-                <div style="background:#16191f; padding:40px; border-radius:24px; border:1px solid rgba(255,255,255,0.1); text-align:center; box-shadow: 0 20px 40px rgba(0,0,0,0.5);">
-                    <div style="font-size:48px; margin-bottom:20px;">🔒</div>
-                    <h1 style="color:#378ADD; margin:0; font-size:24px;">Invitation Required</h1>
-                    <p style="color:#94a3b8; margin:20px 0; line-height:1.6;">이 서비스는 비공개로 운영되고 있습니다.<br>선생님께 받은 <b>초대용 전용 링크</b>를 통해 접속해 주세요.</p>
-                    <div style="margin-top:30px; padding-top:20px; border-top:1px solid rgba(255,255,255,0.05); font-size:11px; color:rgba(255,255,255,0.2); letter-spacing:1px;">LATTICE AI</div>
-                </div>
-            </body>
-        """,
-        status_code=403,
-    )
-
-
-def ui_file_response(path: Path) -> FileResponse:
-    response = FileResponse(path)
-    response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
-    response.headers["Pragma"] = "no-cache"
-    response.headers["Expires"] = "0"
-    response.headers["Content-Security-Policy"] = PRODUCTION_CSP
-    return response
-
-@dataclass(frozen=True)
-class StaticRoutesBundle:
-    router: APIRouter
-    ui_file_response: Callable[[Path], FileResponse]
-    local_sysinfo: Callable[[Request], object]
-    invite_authorized: Callable[[Request], bool]
-
-
-def create_static_routes_router(
-    *,
-    static_dir: Path,
-    invite_gate_enabled: bool,
-    invite_code: str,
-    app_mode: str,
-    model_router,
-    require_user,
-    invite_cookie_secret: str = "",
-    secure_cookies: bool = False,
-) -> StaticRoutesBundle:
-    api_router = APIRouter()
-    STATIC_DIR = static_dir
-    INVITE_GATE_ENABLED = invite_gate_enabled
-    INVITE_CODE = invite_code
-    INVITE_COOKIE_SECRET = invite_cookie_secret or secrets.token_urlsafe(48)
-    SECURE_COOKIES = bool(secure_cookies)
-    APP_MODE = app_mode
-    router = model_router
-
-    def invite_authorized(request: Request) -> bool:
-        """Verify the request's signed invite claim at every gated boundary."""
-
-        if not INVITE_GATE_ENABLED:
-            return True
-        return _verify_invite_cookie(
-            request.cookies.get(INVITE_COOKIE_NAME),
-            INVITE_COOKIE_SECRET,
-        )
-
-    @api_router.get("/")
-    async def root(
-        request: Request,
-        code: Optional[str] = None,
-        invite_cookie: Optional[str] = Cookie(None, alias=INVITE_COOKIE_NAME),
-    ):
-        """로그인/회원가입 페이지. 초대 게이트 활성화 시 코드 검증 후 진입."""
-        if not INVITE_GATE_ENABLED:
-            return app_redirect("account", request)
-
-        # 1. 유효한 서버 서명 쿠키가 있는 경우
-        if invite_authorized(request):
-            return app_redirect("account")
-
-        # 2. 초대 코드가 일치하는 경우 (최초 진입)
-        if INVITE_CODE and code and secrets.compare_digest(code, INVITE_CODE):
-            # Do not retain the invitation code in the redirect URL/history.
-            response = app_redirect("account")
-            response.set_cookie(
-                key=INVITE_COOKIE_NAME,
-                value=_sign_invite_cookie(INVITE_COOKIE_SECRET),
-                httponly=True,
-                secure=SECURE_COOKIES,
-                samesite="lax",
-                max_age=INVITE_COOKIE_TTL_SECONDS,
-                path="/",
-            )
-            return response
-
-        # 3. 인증 실패 시 차단 화면
-        return _invite_denied_response()
-    
-    
-    @api_router.get("/account")
-    async def account_page(
-        request: Request,
-        invite_cookie: Optional[str] = Cookie(None, alias=INVITE_COOKIE_NAME),
-    ):
-        """Direct login/register page route used by logout and manual navigation."""
-        if INVITE_GATE_ENABLED and not invite_authorized(request):
-            return _invite_denied_response()
-        return app_redirect("account")
-    
-    
-    @api_router.get("/manifest.json")
-    async def manifest():
-        p = STATIC_DIR / "manifest.json"
-        if not p.exists():
-            raise HTTPException(status_code=404)
-        return FileResponse(str(p), media_type="application/manifest+json")
-
-    @api_router.api_route("/favicon.ico", methods=["GET", "HEAD"], include_in_schema=False)
-    async def favicon():
-        ico = STATIC_DIR / "favicon.ico"
-        png = STATIC_DIR / "icons" / "favicon-32.png"
-        if ico.exists():
-            return FileResponse(str(ico), media_type="image/x-icon")
-        if png.exists():
-            return FileResponse(str(png), media_type="image/png")
-        raise HTTPException(status_code=404)
-    
-    
-    @api_router.get("/sw.js")
-    async def service_worker():
-        p = STATIC_DIR / "sw.js"
-        if not p.exists():
-            raise HTTPException(status_code=404)
-        resp = FileResponse(str(p), media_type="application/javascript")
-        resp.headers["Service-Worker-Allowed"] = "/"
-        return resp
-    
-    
-    @api_router.get("/chat")
-    async def chat_page(request: Request):
-        return app_redirect("chat", request)
-
-
-    @api_router.get("/app")
-    async def app_shell(
-        request: Request,
-        invite_cookie: Optional[str] = Cookie(None, alias=INVITE_COOKIE_NAME),
-    ):
-        """React desktop single-page workspace shell."""
-        if INVITE_GATE_ENABLED and not invite_authorized(request):
-            return _invite_denied_response()
-        page = STATIC_DIR / "app" / "index.html"
-        if not page.exists():
-            raise HTTPException(status_code=404, detail="React shell not found.")
-        return ui_file_response(page)
-
-
-    @api_router.get("/admin")
-    async def admin_page(request: Request):
-        return app_redirect("admin/users", request)
-    
-    # /workspace and /onboarding UI pages are served by the workspace router
-    # (latticeai.api.workspace), included below after its dependencies are defined.
-    
-    @api_router.get("/status")
-    async def status(request: Request):
-        """서버 상태 및 현재 로드된 모델 정보를 반환합니다."""
-        require_user(request)
-        return {
-            "message": "🧠 Lattice AI MLX Server is running!",
-            "status": "online",
-            "mode": APP_MODE,
-            "loaded_model": router._current or "None"
-        }
-    
-    
-    @api_router.get("/local/sysinfo")
-    async def local_sysinfo(request: Request):
-        """CPU / RAM / GPU(MLX) usage plus a plain-language readiness bucket.
-
-        ``readiness`` is ``roomy`` | ``tight`` | ``low`` so basic System copy
-        does not re-interpret raw percents on the client.
-
-        The probe itself is three subprocesses — ``top -l 1`` alone samples for
-        about a second — so it runs on a worker thread. Run inline it held the
-        event loop for the whole sample, and this route is hit on the System
-        screen *and* during first-run analysis, i.e. exactly while an answer is
-        streaming: one status poll used to stall every open stream.
-        """
-        require_user(request)
-        return await asyncio.to_thread(_probe_host_capacity)
-
-    return StaticRoutesBundle(
-        api_router,
-        ui_file_response,
-        local_sysinfo,
-        invite_authorized,
-    )