Update app.py

app.py

@@ -1,1403 +1,33 @@
 import os
-os.environ['TZ'] = 'Asia/Seoul'
-try:
-    import time as _tz_time
-    _tz_time.tzset()
-except: pass
-import json
-import base64
-import asyncio
-import httpx
-import uvicorn
-import threading
-from datetime import datetime, timezone, timedelta
-from collections import Counter, defaultdict
-from pathlib import Path
-from fastapi import FastAPI, Request, BackgroundTasks
-import aiosqlite, shutil
-from fastapi.responses import FileResponse, HTMLResponse, JSONResponse, Response, StreamingResponse
-from fastapi.middleware.cors import CORSMiddleware
-app = FastAPI()
-app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
-@app.exception_handler(Exception)
-async def global_exception_handler(request, exc):
-    import traceback
-    traceback.print_exc()
-    return JSONResponse(
-        status_code=500,
-        content={"error": {"message": str(exc)[:200], "type": "server_error"}},
-    )
-from shared import (
-    GROQ_API_KEY, FAL_KEY, HF_TOKEN, ADMIN_EMAIL, SA_BACKUP_REPO, DATASET_ID,
-    CLIP_BUCKET, CLIP_MAX_BYTES, GROQ_URL, SA_DB_PATH,
-    _init_write_queue, _db_write, _db_write_sync, _db_read, _db_read_one,
-    _db_enqueue, _sa_backup_db, _sanitize_text, _sanitize_messages
-)
-import asyncio as _asyncio
-_PERSISTENT_DIR = "/data"
-_LOCAL_DIR = "./data"
-def _ensure_persistent_storage():
-    _hf_token = os.environ.get("HF_TOKEN", "")
-    if not _hf_token:
-        print("⚠️ HF_TOKEN 없음 — 영구 스토리지 자동 활성화 불가")
-        return
-    if os.path.exists(_PERSISTENT_DIR):
-        try:
-            tf = os.path.join(_PERSISTENT_DIR, ".write_test")
-            with open(tf, "w") as f: f.write("ok")
-            os.remove(tf)
-            print("✅ /data 이미 활성화됨")
+import sys
+
+def main():
+    try:
+        # Get the code from secrets
+        code = os.environ.get("MAIN_CODE")
+        
+        if not code:
+            # Fallback: create a simple error display
+            import gradio as gr
+            with gr.Blocks() as demo:
+                gr.Markdown("# ⚠️ Error")
+                gr.Markdown("The application code wasn't found in secrets. Please add the MAIN_CODE secret.")
+            demo.launch()
             return
-        except:
-            pass
-    try:
-        from huggingface_hub import HfApi
-        api = HfApi(token=_hf_token)
-        space_id = os.environ.get("SPACE_ID", "")
-        if not space_id:
-            space_id = "ginigen-ai/siteagent"
-        api.request_space_storage(space_id, "small")
-        print(f"🔧 영구 스토리지 활성화 요청 완료: {space_id} (small)")
-        print("   → Space가 자동 재시작됩니다. 재시작 후 /data 사용 가능.")
-    except Exception as e:
-        err_str = str(e)
-        if "already" in err_str.lower() or "409" in err_str:
-            print(f"✅ 영구 스토리지 이미 활성화 상태 (API 확인)")
-        else:
-            print(f"⚠️ 영구 스토리지 활성화 실패: {e}")
-_ensure_persistent_storage()
-async def _sa_restore_db():
-    if not HF_TOKEN: return False
-    if os.path.exists(SA_DB_PATH) and os.path.getsize(SA_DB_PATH) > 0:
-        try:
-            import sqlite3
-            conn = sqlite3.connect(SA_DB_PATH, timeout=10)
-            conn.execute("PRAGMA busy_timeout=5000")
-            conn.execute("PRAGMA wal_checkpoint(TRUNCATE)")
-            result = conn.execute("PRAGMA integrity_check").fetchone()
-            conn.close()
-            if result[0] == 'ok':
-                print("📍 [SA-restore] Existing DB healthy, skip restore")
-                return False
-            else:
-                print(f"⚠️ [SA-restore] Existing DB corrupt, restoring...")
-                os.remove(SA_DB_PATH)
-        except Exception as e:
-            print(f"⚠️ [SA-restore] DB check failed: {e}, restoring...")
-            try: os.remove(SA_DB_PATH)
-            except: pass
-    def _sync():
-        from huggingface_hub import HfApi, hf_hub_download
-        try:
-            api = HfApi(token=HF_TOKEN)
-            api.create_repo(repo_id=SA_BACKUP_REPO, repo_type="dataset", private=True, exist_ok=True)
-        except: pass
-        return hf_hub_download(repo_id=SA_BACKUP_REPO, filename="latest/siteagent.db", repo_type="dataset", token=HF_TOKEN)
-    try:
-        import asyncio
-        downloaded = await asyncio.to_thread(_sync)
-        import sqlite3
-        conn = sqlite3.connect(downloaded)
-        result = conn.execute("PRAGMA integrity_check").fetchone()
-        conn.close()
-        if result[0] != 'ok':
-            print("🚨 [SA-restore] Hub backup corrupt, starting fresh")
-            return False
-        for suffix in ['-wal', '-shm']:
-            wf = SA_DB_PATH + suffix
-            if os.path.exists(wf): os.remove(wf)
-        shutil.copy(downloaded, SA_DB_PATH)
-        print("✅ [SA-restore] DB restored from Hub")
-        return True
+        
+        # Execute the code directly
+        exec(compile(code, '<string>', 'exec'), globals())
+        
     except Exception as e:
-        print(f"⚠️ [SA-restore] failed (first run?): {e}")
-        return False
-async def init_siteagent_db():
-    await _sa_restore_db()
-    async with aiosqlite.connect(SA_DB_PATH, timeout=30.0) as db:
-        await db.execute("PRAGMA journal_mode=WAL")
-        await db.execute("PRAGMA busy_timeout=5000")
-        await db.execute("""CREATE TABLE IF NOT EXISTS users (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            email TEXT UNIQUE NOT NULL,
-            nickname TEXT,
-            role TEXT DEFAULT 'user',
-            visit_count INTEGER DEFAULT 0,
-            last_seen_at REAL,
-            created_at REAL
-        )""")
-        await db.execute("""CREATE TABLE IF NOT EXISTS page_visits (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            email TEXT NOT NULL,
-            url_hash TEXT NOT NULL,
-            url TEXT,
-            title TEXT,
-            domain TEXT,
-            visit_count INTEGER DEFAULT 1,
-            total_duration_sec REAL DEFAULT 0,
-            last_visited_at REAL,
-            created_at REAL,
-            UNIQUE(email, url_hash)
-        )""")
-        await db.execute("""CREATE TABLE IF NOT EXISTS user_inputs (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            email TEXT NOT NULL,
-            url_hash TEXT,
-            url TEXT,
-            input_type TEXT,
-            input_text TEXT,
-            feature TEXT,
-            result_length INTEGER DEFAULT 0,
-            created_at REAL
-        )""")
-        await db.execute("""CREATE TABLE IF NOT EXISTS feature_usage (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            email TEXT NOT NULL,
-            feature TEXT NOT NULL,
-            use_count INTEGER DEFAULT 1,
-            last_used_at REAL,
-            UNIQUE(email, feature)
-        )""")
-        await db.execute("CREATE INDEX IF NOT EXISTS idx_visits_email ON page_visits(email, last_visited_at DESC)")
-        await db.execute("CREATE INDEX IF NOT EXISTS idx_inputs_email ON user_inputs(email, created_at DESC)")
-        await db.execute("CREATE INDEX IF NOT EXISTS idx_usage_email ON feature_usage(email, use_count DESC)")
-        await db.execute("""CREATE TABLE IF NOT EXISTS waitlist (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            email TEXT UNIQUE NOT NULL,
-            name TEXT,
-            interest TEXT,
-            source TEXT DEFAULT 'landing',
-            created_at REAL
-        )""")
-        await db.execute("CREATE INDEX IF NOT EXISTS idx_waitlist_created ON waitlist(created_at DESC)")
-        await db.execute("CREATE INDEX IF NOT EXISTS idx_visits_domain ON page_visits(domain, visit_count DESC)")
-        await db.execute("""CREATE TABLE IF NOT EXISTS sessions (
-            email TEXT PRIMARY KEY,
-            chat TEXT DEFAULT '',
-            cmd TEXT DEFAULT '',
-            url TEXT DEFAULT '',
-            title TEXT DEFAULT '',
-            updated_at REAL DEFAULT 0
-        )""")
-        await db.execute("""CREATE TABLE IF NOT EXISTS analytics (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            email TEXT DEFAULT '',
-            event TEXT NOT NULL,
-            feature TEXT DEFAULT '',
-            domain TEXT DEFAULT '',
-            url TEXT DEFAULT '',
-            provider TEXT DEFAULT 'demo',
-            client TEXT DEFAULT '',
-            model TEXT DEFAULT '',
-            mode TEXT DEFAULT '',
-            engine TEXT DEFAULT '',
-            response_ms INTEGER DEFAULT 0,
-            tokens_used INTEGER DEFAULT 0,
-            success INTEGER DEFAULT 1,
-            error_msg TEXT DEFAULT '',
-            screen TEXT DEFAULT '',
-            os TEXT DEFAULT '',
-            browser TEXT DEFAULT '',
-            language TEXT DEFAULT '',
-            timezone TEXT DEFAULT '',
-            referrer TEXT DEFAULT '',
-            country TEXT DEFAULT '',
-            session_id TEXT DEFAULT '',
-            meta TEXT DEFAULT '',
-            created_at REAL DEFAULT 0
-        )""")
-        await db.execute("CREATE INDEX IF NOT EXISTS idx_analytics_email ON analytics(email, created_at DESC)")
-        await db.execute("CREATE INDEX IF NOT EXISTS idx_analytics_event ON analytics(event, created_at DESC)")
-        await db.execute("CREATE INDEX IF NOT EXISTS idx_analytics_feature ON analytics(feature, created_at DESC)")
-        for col, typ in [
-            ("last_browser", "TEXT DEFAULT ''"),
-            ("last_os", "TEXT DEFAULT ''"),
-            ("last_screen", "TEXT DEFAULT ''"),
-            ("last_language", "TEXT DEFAULT ''"),
-            ("last_timezone", "TEXT DEFAULT ''"),
-            ("last_country", "TEXT DEFAULT ''"),
-            ("last_provider", "TEXT DEFAULT 'demo'"),
-            ("last_client", "TEXT DEFAULT ''"),
-            ("first_referrer", "TEXT DEFAULT ''"),
-            ("total_ai_calls", "INTEGER DEFAULT 0"),
-            ("total_ai_errors", "INTEGER DEFAULT 0"),
-        ]:
-            try:
-                await db.execute(f"ALTER TABLE users ADD COLUMN {col} {typ}")
-            except:
-                pass  # 이미 존재하면 무시
-        import time
-        cursor = await db.execute("SELECT email FROM users WHERE email=?", (ADMIN_EMAIL,))
-        if not await cursor.fetchone():
-            await db.execute("INSERT INTO users (email,nickname,role,created_at) VALUES (?,?,?,?)",
-                           (ADMIN_EMAIL, "🔑관리자", "admin", time.time()))
-        # 🔐 시크릿 메신저 테이블 (암호문만 저장, 평문 접근 불가)
-        await db.execute("""CREATE TABLE IF NOT EXISTS sec_keys (
-            email_hash TEXT PRIMARY KEY,
-            pubkey_jwk TEXT NOT NULL,
-            registered_at REAL
-        )""")
-        await db.execute("""CREATE TABLE IF NOT EXISTS sec_messages (
-            id TEXT PRIMARY KEY,
-            from_hash TEXT NOT NULL,
-            to_hash TEXT NOT NULL,
-            ciphertext TEXT NOT NULL,
-            iv TEXT NOT NULL,
-            group_id TEXT DEFAULT '',
-            ts REAL NOT NULL,
-            delivered INTEGER DEFAULT 0
-        )""")
-        await db.execute("CREATE INDEX IF NOT EXISTS idx_sec_msg_to ON sec_messages(to_hash, ts)")
-        await db.execute("CREATE INDEX IF NOT EXISTS idx_sec_msg_ts ON sec_messages(ts)")
-        await db.commit()
-        count = await db.execute("SELECT COUNT(*) FROM users")
-        cnt = (await count.fetchone())[0]
-        sec_cnt = await db.execute("SELECT COUNT(*) FROM sec_keys")
-        sec_n = (await sec_cnt.fetchone())[0]
-        print(f"✅ SiteAgent DB initialized: {SA_DB_PATH} ({cnt} users, sec_keys: {sec_n})")
-LOG_FILE     = "/tmp/sa_events.jsonl"
-import re as _re
-def _strip_response_tables(data):
-    try:
-        if isinstance(data, dict):
-            for ch in data.get("choices", []):
-                msg = ch.get("message", {})
-                if isinstance(msg.get("content"), str):
-                    msg["content"] = _strip_md_table(msg["content"])
-    except Exception:
-        pass
-    return data
-def _strip_md_table(text):
-    if not isinstance(text, str) or '|' not in text:
-        return text
-    lines = text.split('\n')
-    out = []
-    tbl = []
-    in_tbl = False
-    for line in lines:
-        if _re.match(r'^\s*\|.+\|\s*$', line):
-            in_tbl = True
-            tbl.append(line)
-        else:
-            if in_tbl:
-                _flush_table(tbl, out)
-                tbl = []
-                in_tbl = False
-            out.append(line)
-    if in_tbl:
-        _flush_table(tbl, out)
-    return '\n'.join(out)
-def _flush_table(tbl, out):
-    if len(tbl) < 2:
-        out.extend(tbl)
-        return
-    headers = [c.strip() for c in tbl[0].strip('|').split('|')]
-    for i, tr in enumerate(tbl):
-        cells = [c.strip() for c in tr.strip('|').split('|')]
-        if i == 0:
-            out.append('**' + ' · '.join(c for c in cells if c) + '**')
-        elif i == 1 and _re.match(r'^[\s:\-|]+$', tr):
-            continue
-        else:
-            parts = []
-            for j, cell in enumerate(cells):
-                if cell:
-                    if j < len(headers) and headers[j] and headers[j] != cell:
-                        parts.append(f'**{headers[j]}**: {cell}')
-                    else:
-                        parts.append(cell)
-            out.append('• ' + ' / '.join(parts))
-_PAGE_AGENT_JS: bytes = b""
-def _load_js():
-    global _PAGE_AGENT_JS
-    candidates = [
-        Path(__file__).parent / "secure-pageagent.extend.js",
-        Path(".") / "secure-pageagent.extend.js",
-        Path("/home/user/app") / "secure-pageagent.extend.js",
-    ]
-    for local in candidates:
-        try:
-            if local.exists():
-                _PAGE_AGENT_JS = local.read_bytes()
-                print(f"✅ secure-pageagent.extend.js loaded ({len(_PAGE_AGENT_JS):,} bytes) from {local}")
-                return
-        except:
-            continue
-    print("❌ secure-pageagent.extend.js not found")
-_load_js()
-# ── sa-secret.js 합체 (시크릿 메신저 클라이언트) ──
-def _load_secret_js():
-    global _PAGE_AGENT_JS
-    if not _PAGE_AGENT_JS:
-        return
-    for d in [Path(__file__).parent, Path("."), Path("/home/user/app")]:
-        f = d / "sa-secret.js"
-        try:
-            if f.exists():
-                secret = f.read_bytes()
-                _PAGE_AGENT_JS = _PAGE_AGENT_JS + b"\n;\n" + secret
-                print(f"✅ sa-secret.js appended ({len(secret):,} bytes) → total {len(_PAGE_AGENT_JS):,} bytes")
-                return
-        except:
-            continue
-    print("⚠️ sa-secret.js not found (시크릿 메신저 비활성)")
-_load_secret_js()
-@app.get("/api/agent-script")
-async def agent_script():
-    if not _PAGE_AGENT_JS:
-        return JSONResponse({"error": "agent script not loaded"}, status_code=500)
-    return JSONResponse({
-        "js": base64.b64encode(_PAGE_AGENT_JS).decode(),
-        "size": len(_PAGE_AGENT_JS)
-    })
-MAX_RETRIES = 2
-# ── _chat_log_bg 미정의 방지 ──
-async def _chat_log_bg(*args, **kwargs):
-    pass
-# ═══════════════════════════════════════════════════════
-# 축 1: 의도 분류 (Classify → Route)
-# ═══════════════════════════════════════════════════════
-_READ_KEYWORDS = [
-    "요약","번역","분석","설명","알려","뭐야","뭔가","무엇","읽어","해석","정리","리뷰",
-    "핵심","키워드","내용","뜻","의미","비교해","차이","장단점",
-    "summarize","translate","analyze","explain","what is","what are","compare","review","tell me"
-]
-_ACT_KEYWORDS = [
-    "클릭","눌러","누르","입력","적어","써줘","작성","검색해","찾아","열어","이동","접속",
-    "다운로드","업로드","제출","전송","보내","삭제","로그인","가입","장바구니","담아","구매",
-    "예약","신청","발급","선택","체크","활성","비활성","토글","스크롤","내려","올려",
-    "click","type","input","search","open","go to","navigate","download","submit","login","book"
-]
-def _classify_intent(user_text: str) -> str:
-    """사용자 입력을 READ / ACT 중 하나로 분류. 앞 150자만 사용(DOM 키워드 오염 방지)"""
-    t = user_text[:150].lower().strip()
-    if not t:
-        return "READ"
-    act_score = sum(1 for k in _ACT_KEYWORDS if k in t)
-    read_score = sum(1 for k in _READ_KEYWORDS if k in t)
-    # ACT 키워드가 있고, READ보다 같거나 많으면 ACT (동점이면 행동 우선)
-    if act_score >= 1 and act_score >= read_score:
-        return "ACT"
-    # ACT 키워드가 있지만 READ가 더 많으면 READ
-    # ACT 키워드가 없으면 READ
-    return "READ"
-
-# ═══════════════════════════════════════════════════════
-# 축 2 + 축 3: 모드별 시스템 프롬프트
-# ═══════════════════════════════════════════════════════
-
-# ── 공통 JSON 포맷 + 액션 목록 ──
-_ACTION_FORMAT = """JSON만 출력. 코드블록 금지. done.text는 한국어.
-{"evaluation_previous_goal":"1줄","memory":"핵심만","next_goal":"1줄","action":{액션}}
-액션: done{text,success} | click_element_by_index{index} | input_text{index,text} | select_dropdown_option{index,text} | scroll{down,num_pages} | scroll_horizontally{right,pixels} | wait{seconds} | execute_javascript{script} | ask_user{question}
-★모든 필드는 최대한 짧게. evaluation/memory/next_goal 각각 20자 이내."""
-
-# ── READ 모드 ──
-PROMPT_READ = _ACTION_FORMAT + """
-★READ: DOM 텍스트만으로 즉시 done. scroll/wait/click 절대 금지. 답 없으면 "해당 정보 없음"으로 done."""
-
-# ── ACT 모드 ──
-PROMPT_ACT = _ACTION_FORMAT + """
-★ACT: 최소 스텝. 속도 최우선.
-- 클릭 전 index 확인. contenteditable→click먼저→input_text.
-- 입력 후 제출: 다음 스텝에서 반드시 즉시 검색/제출 버튼 클릭. DOM 분석하지 말고 바로 클릭.
-- ★결과 도착 후: 보이는 텍스트에서 핵심만 뽑아 3문장 이내로 즉시 done. 긴 분석/정리/마크다운 포맷 금지. 짧고 빠르게.
-- 복합작업: memory에 간단한 계획 적고 순서대로.
-- 예약/검색 시 시간 필드 설정(미설정=00:00).
-- 실패→반복금지. ①유사요소 ②JS실행 ③scroll1회 ④ask_user.
-- wait 1회(2초)만. 3스텝 진전없음→결과로 done."""
-
-# ── PLAN은 ACT에 흡수 (별도 모드 불필요) ──
-PROMPT_PLAN = PROMPT_ACT
-
-# ── DOM 크기 제한 ──
-_MAX_DOM_READ = 15000
-_MAX_DOM_ACT  = 10000
-def _truncate_large_dom(msgs: list, intent: str = "READ") -> list:
-    limit = _MAX_DOM_ACT if intent in ("ACT", "PLAN") else _MAX_DOM_READ
-    for m in reversed(msgs):
-        if m.get("role") != "user":
-            continue
-        content = m.get("content", "")
-        if isinstance(content, str) and len(content) > limit:
-            m["content"] = content[:limit] + "\n[...DOM 생략. 보이는 영역 중심으로 즉시 판단하라.]"
-            print(f"[proxy] ⚠️ DOM truncated: {len(content)} → {limit} ({intent})")
-        break
-    return msgs
-@app.post("/api/chat/completions")
-async def chat_proxy(request: Request, background_tasks: BackgroundTasks):
-    try:
-        body = await request.json()
-    except Exception:
-        return JSONResponse({"error": "invalid json"}, status_code=400)
-    if not GROQ_API_KEY:
-        return JSONResponse({"error": "GROQ_API_KEY not set"}, status_code=500)
-    original_tools = body.pop("tools", None)
-    body.pop("tool_choice", None)
-    body.pop("parallel_tool_calls", None)
-    sa_mode = body.pop("sa_mode", None)
-    _sa_email_val = body.pop("sa_email", "")
-    _sa_url_val = body.pop("sa_url", "")
-    if "messages" in body:
-        body["messages"] = _sanitize_messages(body["messages"])
-    import time as _time, hashlib as _hl
-    try:
-        _ref = request.headers.get("referer", "") or request.headers.get("origin", "")
-        _msgs = body.get("messages", [])
-        _last_user = ""
-        for _m in reversed(_msgs):
-            if _m.get("role") == "user":
-                _ct = _m.get("content", "")
-                if isinstance(_ct, str):
-                    _last_user = _ct[:500]
-                elif isinstance(_ct, list):
-                    for _p in _ct:
-                        if isinstance(_p, dict) and _p.get("type") == "text":
-                            _last_user = _p.get("text", "")[:500]
-                            break
-                break
-        _email = _sa_email_val or ""
-        if not _email:
-            try:
-                _row = await _db_read_one("SELECT email FROM users ORDER BY last_seen_at DESC LIMIT 1")
-                if _row: _email = dict(_row).get("email", "")
-            except: pass
-        if not _email: _email = ADMIN_EMAIL
-        _feat = sa_mode if sa_mode else "chat"
-        _uh = _hl.sha256(_ref.encode()).hexdigest()[:16] if _ref else "no_ref"
-        print(f"[log] ★ email={_email}, feat={_feat}, user_msg={bool(_last_user)}, ref={_ref[:50]}")
-        background_tasks.add_task(_chat_log_bg, _email, _uh, _ref, _last_user, _feat, _time.time())
-    except Exception as _le:
+        import gradio as gr
         import traceback
-        print(f"[log] ❌ ERROR: {_le}")
-        traceback.print_exc()
-    if not sa_mode:
-        sa_mode = request.headers.get("X-SA-Mode", "")
-    body["model"] = "openai/gpt-oss-120b"
-    body["stream"] = False
-    body["temperature"] = 1
-    body["top_p"] = 1
-    body["stop"] = None
-    for k in ["max_tokens", "thinking", "verbosity"]:
-        body.pop(k, None)
-    if sa_mode == "search":
-        body["tools"] = [{"type": "browser_search"}]
-        body["tool_choice"] = "required"
-        body["max_completion_tokens"] = 4096
-        body["reasoning_effort"] = "low"
-        original_tools = None  # tool_call 래핑 안 함
-        msgs = body.get("messages", [])
-        if msgs and msgs[0].get("role") == "system":
-            msgs[0]["content"] += "\n\n[중요] 반드시 자연스러운 한국어로 답변하라."
-        elif msgs:
-            msgs.insert(0, {"role": "system", "content": "반드시 자연스러운 한국어로 답변하라."})
-        body["messages"] = msgs
-        print("[proxy] mode: browser_search")
-    elif sa_mode == "calc":
-        body["tools"] = [{"type": "code_interpreter"}]
-        body["tool_choice"] = "required"
-        body["max_completion_tokens"] = 4096
-        body["reasoning_effort"] = "medium"
-        original_tools = None
-        msgs = body.get("messages", [])
-        if msgs and msgs[0].get("role") == "system":
-            msgs[0]["content"] += "\n\n[중요] 계산 결과를 자연스러운 한국어로 설명하라."
-        elif msgs:
-            msgs.insert(0, {"role": "system", "content": "계산 결과를 자연스러운 한국어로 설명하라."})
-        body["messages"] = msgs
-        print("[proxy] mode: code_interpreter")
-    elif original_tools:
-        msgs = body.get("messages", [])
-        # ── 사용자 마지막 텍스트 추출 ──
-        user_msgs = [m for m in msgs if m.get("role") == "user"]
-        _last_txt = ""
-        for _um in reversed(user_msgs):
-            _umc = _um.get("content","")
-            if isinstance(_umc,str): _last_txt=_umc; break
-            elif isinstance(_umc,list):
-                for _p in _umc:
-                    if isinstance(_p,dict) and _p.get("type")=="text": _last_txt=_p.get("text",""); break
-                break
-        # ── 축 1: 의도 분류 (READ / ACT) ──
-        _intent = _classify_intent(_last_txt)
-        # ── DOM 크기 제한 (모드별 차등) ──
-        msgs = _truncate_large_dom(msgs, _intent)
-        # ── 모드별 프롬프트 + reasoning 전부 low ──
-        if _intent == "READ":
-            _prompt = PROMPT_READ
-            body["max_completion_tokens"] = 4096
-        else:  # ACT
-            _prompt = PROMPT_ACT
-            body["max_completion_tokens"] = 1024
-        body["reasoning_effort"] = "low"
-        # ── 시스템 프롬프트 주입 ──
-        if msgs and msgs[0].get("role") == "system":
-            msgs[0]["content"] = msgs[0]["content"] + "\n" + _prompt
-        else:
-            msgs.insert(0, {"role": "system", "content": _prompt})
-        body["messages"] = msgs
-        print(f"[proxy] mode: dom_action/{_intent} (reasoning: {body['reasoning_effort']}, steps: {len(user_msgs)})")
-    else:
-        body["max_completion_tokens"] = 4096
-        body["reasoning_effort"] = "low"
-        msgs = body.get("messages", [])
-        if msgs and msgs[0].get("role") == "system":
-            if "한국어" not in msgs[0]["content"]:
-                msgs[0]["content"] += "\n\n[중요] 최종 답변은 반드시 자연스러운 한국어로 작성하라."
-        body["messages"] = msgs
-        print("[proxy] mode: text")
-    # ═══ 메모리 컨텍스트 주입 ═══
-    _memory_injected = False
-    if _email and sa_mode not in ("search", "calc") and not original_tools:
-        try:
-            mem_ctx = await build_memory_context(_email, _last_user)
-            if mem_ctx:
-                msgs = body.get("messages", [])
-                if msgs and msgs[0].get("role") == "system":
-                    msgs[0]["content"] = msgs[0]["content"] + "\n\n" + mem_ctx
-                else:
-                    msgs.insert(0, {"role": "system", "content": "당신은 SiteAgent AI 어시스턴트입니다. 사용자의 기억과 이력을 활용해 개인화된 도움을 제공합니다.\n\n" + mem_ctx})
-                body["messages"] = msgs
-                _memory_injected = True
-                print(f"[memory] ✅ injected for {_email} ({len(mem_ctx)} chars)")
-        except Exception as me:
-            print(f"[memory] context error: {me}")
-    groq_headers = {
-        "Authorization": f"Bearer {GROQ_API_KEY}",
-        "Content-Type": "application/json",
-    }
-    data = None
-    status = 500
-    for attempt in range(MAX_RETRIES + 1):
-        try:
-            async with httpx.AsyncClient(timeout=180) as client:
-                resp = await client.post(GROQ_URL, headers=groq_headers, json=body)
-                try:
-                    data = resp.json()
-                except Exception:
-                    print(f"[proxy] Groq returned non-JSON: {resp.text[:200]}")
-                    data = {"error": {"message": "Groq returned invalid response", "type": "proxy_error"}}
-                status = resp.status_code
-            if status == 429:
-                wait = 2 * (attempt + 1)
-                print(f"[proxy] 429 → retry {attempt+1}/{MAX_RETRIES} ({wait}s)")
-                if attempt < MAX_RETRIES:
-                    await asyncio.sleep(wait)
-                    continue
-            elif status >= 500:
-                err_body = str(data)[:300] if data else resp.text[:300]
-                print(f"[proxy] {status} body={err_body} → retry {attempt+1}/{MAX_RETRIES}")
-                if attempt == 0 and "reasoning_effort" in body:
-                    removed = body.pop("reasoning_effort", None)
-                    print(f"[proxy] removed reasoning_effort={removed} for retry")
-                if attempt < MAX_RETRIES:
-                    await asyncio.sleep(1)
-                    continue
-            break
-        except Exception as e:
-            print(f"[proxy] exception: {e}")
-            if attempt < MAX_RETRIES:
-                await asyncio.sleep(1)
-                continue
-            return JSONResponse({"error": {"message": str(e)}}, status_code=502)
-    if status != 200:
-        return JSONResponse(data or {"error": "unknown"}, status_code=status)
-    if sa_mode in ("search", "calc"):
-        try:
-            content = data["choices"][0]["message"].get("content", "")
-            executed = data["choices"][0]["message"].get("executed_tools", [])
-            if executed:
-                print(f"[proxy] executed_tools: {len(executed)} tools used")
-            import re
-            try:
-                msg = data["choices"][0]["message"]
-                if msg.get("content"):
-                    msg["content"] = re.sub(r'【[^】]*】', '', msg["content"]).strip()
-            except: pass
-            return JSONResponse(data)
-        except Exception as e:
-            print(f"[proxy] search/calc extract error: {e}")
-            return JSONResponse(data)
-    if original_tools:
-        raw_text = ""
-        try:
-            raw_text = data["choices"][0]["message"]["content"] or ""
-        except Exception:
-            pass
-        print(f"[proxy] raw ({len(raw_text)}): {raw_text[:300]}...")
-        agent_output = _extract_agent_output(raw_text)
-        wrapped = {
-            "id": data.get("id", "sa"),
-            "object": "chat.completion",
-            "created": data.get("created", 0),
-            "model": "openai/gpt-oss-120b",
-            "choices": [{
-                "index": 0,
-                "message": {
-                    "role": "assistant",
-                    "tool_calls": [{
-                        "id": "call_sa_" + str(data.get("created", 0)),
-                        "type": "function",
-                        "function": {
-                            "name": "AgentOutput",
-                            "arguments": agent_output
-                        }
-                    }]
-                },
-                "finish_reason": "tool_calls"
-            }],
-            "usage": data.get("usage", {})
-        }
-        return JSONResponse(wrapped)
-    _strip_response_tables(data)
-    # ═══ 대화 저장 + 기억 추출 (백그라운드) ═══
-    if _email and sa_mode not in ("dom_action",):
-        try:
-            _ai_reply = ""
-            try: _ai_reply = data.get("choices", [{}])[0].get("message", {}).get("content", "")[:2000]
-            except: pass
-            if _last_user:
-                background_tasks.add_task(save_conversation, _email, "user", _last_user, _sa_url_val, "")
-            if _ai_reply:
-                background_tasks.add_task(save_conversation, _email, "assistant", _ai_reply, _sa_url_val, "")
-            if _last_user and _ai_reply:
-                background_tasks.add_task(extract_memories_from_conversation, _email, _last_user, _ai_reply, _sa_url_val)
-            if _last_user and _feat:
-                background_tasks.add_task(save_task, _email, _feat, _last_user[:500], (_ai_reply or "")[:500], _sa_url_val, "")
-        except Exception as _me:
-            print(f"[memory] save error: {_me}")
-    return JSONResponse(data)
-def _extract_agent_output(raw: str) -> str:
-    text = raw.strip()
-    if text.startswith("```"):
-        text = text.split("\n", 1)[-1] if "\n" in text else text[3:]
-    if text.endswith("```"):
-        text = text[:-3].strip()
-    if text.startswith("json"):
-        text = text[4:].strip()
-    parsed = None
-    try:
-        parsed = json.loads(text)
-    except json.JSONDecodeError:
-        start = text.find("{")
-        end = text.rfind("}")
-        if start >= 0 and end > start:
-            try:
-                parsed = json.loads(text[start:end+1])
-            except json.JSONDecodeError:
-                pass
-    if parsed and isinstance(parsed, dict) and "action" in parsed:
-        action = parsed["action"]
-        if isinstance(action, dict) and "done" in action:
-            done = action["done"]
-            if isinstance(done, dict) and done.get("text"):
-                print(f"[proxy] → done: {done['text'][:80]}...")
-            elif isinstance(done, dict) and not done.get("text"):
-                fill = parsed.get("memory", "") or parsed.get("next_goal", "")
-                if fill:
-                    done["text"] = fill
-                    parsed["action"]["done"] = done
-        for act_name in ["click_element_by_index", "input_text", "scroll",
-                         "select_dropdown_option", "wait", "scroll_horizontally",
-                         "execute_javascript", "ask_user"]:
-            if act_name in action:
-                print(f"[proxy] → action: {act_name} {action[act_name]}")
-        return json.dumps(parsed, ensure_ascii=False)
-    final_text = raw.strip()
-    if parsed and isinstance(parsed, dict):
-        for key in ["text", "content", "answer", "response", "result"]:
-            if key in parsed and isinstance(parsed[key], str):
-                final_text = parsed[key]
-                break
-    print(f"[proxy] → fallback done: {final_text[:80]}...")
-    return json.dumps({
-        "evaluation_previous_goal": "Processed",
-        "memory": "",
-        "next_goal": "",
-        "action": {"done": {"text": final_text or "요청을 처리했습니다.", "success": True}}
-    }, ensure_ascii=False)
-@app.post("/api/search")
-async def search_api(request: Request):
-    try:
-        body = await request.json()
-    except Exception:
-        return JSONResponse({"error": "invalid json"}, status_code=400)
-    query = body.get("query", "")
-    if not query:
-        return JSONResponse({"error": "query required"}, status_code=400)
-    if not GROQ_API_KEY:
-        return JSONResponse({"error": "GROQ_API_KEY not set"}, status_code=500)
-    payload = {
-        "model": "openai/gpt-oss-120b",
-        "messages": [
-            {"role": "system", "content": "반드시 자연스러운 한국어로 답변하라. 핵심만 간결하게. 표(table)는 절대 사용하지 마라. 개조식 서술형으로 작성하라."},
-            {"role": "user", "content": query}
-        ],
-        "tools": [{"type": "browser_search"}],
-        "tool_choice": "required",
-        "max_completion_tokens": 4096,
-        "reasoning_effort": "low",
-        "stream": False
-    }
-    headers = {"Authorization": f"Bearer {GROQ_API_KEY}", "Content-Type": "application/json"}
-    try:
-        async with httpx.AsyncClient(timeout=120) as client:
-            resp = await client.post(GROQ_URL, headers=headers, json=payload)
-            data = resp.json()
-        content = data.get("choices", [{}])[0].get("message", {}).get("content", "검색 결과를 가져올 수 없습니다.")
-        import re
-        content = re.sub(r'【[^】]*】', '', content).strip()
-        content = re.sub(r'\s{2,}', ' ', content)
-        return JSONResponse({"result": content})
-    except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=502)
-@app.post("/api/calc")
-async def calc_api(request: Request):
-    try:
-        body = await request.json()
-    except Exception:
-        return JSONResponse({"error": "invalid json"}, status_code=400)
-    query = body.get("query", "")
-    if not query:
-        return JSONResponse({"error": "query required"}, status_code=400)
-    if not GROQ_API_KEY:
-        return JSONResponse({"error": "GROQ_API_KEY not set"}, status_code=500)
-    payload = {
-        "model": "openai/gpt-oss-120b",
-        "messages": [
-            {"role": "system", "content": "계산 결과를 자연스러운 한국어로 설명하라."},
-            {"role": "user", "content": query}
-        ],
-        "tools": [{"type": "code_interpreter"}],
-        "tool_choice": "required",
-        "max_completion_tokens": 4096,
-        "reasoning_effort": "medium",
-        "stream": False
-    }
-    headers = {"Authorization": f"Bearer {GROQ_API_KEY}", "Content-Type": "application/json"}
-    try:
-        async with httpx.AsyncClient(timeout=120) as client:
-            resp = await client.post(GROQ_URL, headers=headers, json=payload)
-            data = resp.json()
-        content = data.get("choices", [{}])[0].get("message", {}).get("content", "계산 결과를 가져올 수 없습니다.")
-        return JSONResponse({"result": content})
-    except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=502)
-_log_lock = threading.Lock()
-def push_event_sync(event: dict):
-    line = json.dumps(event, ensure_ascii=False) + "\n"
-    with _log_lock:
-        with open(LOG_FILE, "a", encoding="utf-8") as f:
-            f.write(line)
-    if not HF_TOKEN:
-        return
-    try:
-        from huggingface_hub import HfApi, hf_hub_download
-        api = HfApi(token=HF_TOKEN)
-        date_str = datetime.now(timezone.utc).strftime("%Y-%m-%d")
-        path_in_repo = f"logs/{date_str}.jsonl"
-        existing = ""
-        try:
-            local = hf_hub_download(repo_id=DATASET_ID, filename=path_in_repo,
-                                    repo_type="dataset", token=HF_TOKEN)
-            with open(local, encoding="utf-8") as f:
-                existing = f.read()
-        except Exception:
-            pass
-        api.upload_file(
-            path_or_fileobj=(existing + line).encode("utf-8"),
-            path_in_repo=path_in_repo, repo_id=DATASET_ID,
-            repo_type="dataset", token=HF_TOKEN,
-            commit_message=f"track {date_str}")
-    except Exception as e:
-        print(f"[push_event] {e}")
-def calc_stats():
-    events = []
-    if os.path.exists(LOG_FILE):
-        with _log_lock:
-            with open(LOG_FILE, encoding="utf-8") as f:
-                for line in f:
-                    line = line.strip()
-                    if line:
-                        try:
-                            events.append(json.loads(line))
-                        except Exception:
-                            pass
-    if not events:
-        return {"total_sessions":0,"total_commands":0,"total_installs":0,
-                "providers":{},"top_domains":[],"daily_active":[],"events_today":0}
-    sessions=set(); commands=installs=0
-    providers=Counter(); domains=Counter(); daily=defaultdict(set)
-    for e in events:
-        sid=e.get("session_id","")
-        if sid: sessions.add(sid)
-        ev=e.get("event","")
-        if ev=="command": commands+=1
-        if ev=="install": installs+=1
-        if ev=="settings_save":
-            prov=e.get("provider","")
-            if prov: providers[prov]+=1
-        domain=e.get("domain","")
-        if domain: domains[domain]+=1
-        ts=e.get("ts","")
-        if ts and sid: daily[ts[:10]].add(sid)
-    today=datetime.now(timezone.utc).date()
-    daily_active=[{"date":(today-timedelta(days=i)).isoformat(),
-                   "users":len(daily.get((today-timedelta(days=i)).isoformat(),set()))}
-                  for i in range(13,-1,-1)]
-    today_str=today.isoformat()
-    return {"total_sessions":len(sessions),"total_commands":commands,"total_installs":installs,
-            "providers":dict(providers.most_common(10)),
-            "top_domains":[{"domain":d,"count":c} for d,c in domains.most_common(10)],
-            "daily_active":daily_active,
-            "events_today":sum(1 for e in events if e.get("ts","")[:10]==today_str)}
-@app.on_event("startup")
-async def startup_init_db():
-    await init_siteagent_db()
-    await init_memory_tables()
-    # ── DB 안정성: 기본 busy_timeout을 파일 레벨로 설정 ──
-    import sqlite3
-    try:
-        conn = sqlite3.connect(SA_DB_PATH, timeout=10)
-        conn.execute("PRAGMA busy_timeout=5000")
-        conn.execute("PRAGMA journal_mode=WAL")
-        conn.execute("PRAGMA synchronous=NORMAL")
-        conn.execute("PRAGMA wal_autocheckpoint=500")
-        conn.close()
-        print("✅ DB PRAGMA set: busy_timeout=5s, WAL, synchronous=NORMAL")
-    except Exception as e:
-        print(f"⚠️ DB PRAGMA warning: {e}")
-    await _init_write_queue()
-    import asyncio
-    async def _safe_backup():
-        """WAL 체크포인트 후 백업 — DB 일관성 보장"""
-        try:
-            async with aiosqlite.connect(SA_DB_PATH, timeout=15.0) as db:
-                await db.execute("PRAGMA busy_timeout=5000")
-                await db.execute("PRAGMA wal_checkpoint(PASSIVE)")
-        except Exception as e:
-            print(f"[backup] WAL checkpoint warning: {e}")
-        try:
-            await _sa_backup_db()
-        except Exception as e:
-            print(f"[backup] error: {e}")
-    async def _periodic_backup():
-        await asyncio.sleep(30)
-        while True:
-            try:
-                await _safe_backup()
-            except Exception as e:
-                print(f"⚠️ Periodic backup error: {e}")
-            await asyncio.sleep(180)
-    asyncio.create_task(_periodic_backup())
-@app.on_event("startup")
-def restore_logs_from_hf():
-    if not HF_TOKEN:
-        return
-    try:
-        from huggingface_hub import HfApi, hf_hub_download
-        api = HfApi(token=HF_TOKEN)
-        files = [
-            f.rfilename for f in api.list_repo_tree(
-                repo_id=DATASET_ID, repo_type="dataset", token=HF_TOKEN
-            )
-            if f.rfilename.startswith("logs/") and f.rfilename.endswith(".jsonl")
-        ]
-        restored = 0
-        with open(LOG_FILE, "a", encoding="utf-8") as out:
-            for fname in sorted(files):
-                try:
-                    local = hf_hub_download(
-                        repo_id=DATASET_ID, filename=fname,
-                        repo_type="dataset", token=HF_TOKEN
-                    )
-                    with open(local, encoding="utf-8") as f:
-                        for line in f:
-                            line = line.strip()
-                            if line:
-                                out.write(line + "\n")
-                                restored += 1
-                except Exception as e:
-                    print(f"[restore] skip {fname}: {e}")
-        print(f"[restore] {restored} events restored from HF dataset")
-    except Exception as e:
-        print(f"[restore] failed: {e}")
-@app.post("/api/track")
-async def track(request: Request, background_tasks: BackgroundTasks):
-    try:
-        body = await request.json()
-    except Exception:
-        return JSONResponse({"ok": False}, status_code=400)
-    allowed = {"event","session_id","provider","domain","ts","browser","os","lang"}
-    event = {k:v for k,v in body.items() if k in allowed}
-    event["ts"] = event.get("ts") or datetime.now(timezone.utc).isoformat()
-    background_tasks.add_task(push_event_sync, event)
-    return JSONResponse({"ok": True})
-@app.post("/api/waitlist")
-async def waitlist_signup(request: Request):
-    import time
-    try:
-        body = await request.json()
-        email = body.get("email", "").strip().lower()
-        if not email or "@" not in email:
-            return JSONResponse({"error": "유효한 이메일을 입력해주세요."}, status_code=400)
-        name = body.get("name", "").strip()[:50]
-        interest = body.get("interest", "").strip()[:100]
-        source = body.get("source", "landing")[:20]
-        existing = await _db_read_one("SELECT id FROM waitlist WHERE email=?", (email,))
-        if existing:
-            return {"status": "already", "message": "이미 등록된 이메일입니다. 곧 연락드리겠습니다!"}
-        await _db_write(
-            "INSERT INTO waitlist (email,name,interest,source,created_at) VALUES (?,?,?,?,?)",
-            (email, name, interest, source, time.time())
-        )
-        print(f"[waitlist] ✅ New signup: {email}")
-        return {"status": "ok", "message": "등록 완료!"}
-    except Exception as e:
-        return JSONResponse({"error": str(e)[:100]}, status_code=500)
-@app.get("/api/waitlist/count")
-async def waitlist_count(request: Request):
-    admin = request.query_params.get("admin", "")
-    if admin != ADMIN_EMAIL:
-        return JSONResponse({"error": "unauthorized"}, status_code=403)
-    count = await _db_read_one("SELECT COUNT(*) as cnt FROM waitlist")
-    return {"count": dict(count)["cnt"] if count else 0}
-@app.get("/api/admin/waitlist")
-async def admin_waitlist(request: Request):
-    admin = request.query_params.get("admin", "")
-    if admin != ADMIN_EMAIL:
-        return JSONResponse({"error": "unauthorized"}, status_code=403)
-    rows = await _db_read("SELECT id,email,name,interest,source,created_at FROM waitlist ORDER BY created_at DESC")
-    return {"waitlist": [dict(r) for r in rows]}
-@app.post("/api/user/register")
-async def user_register(request: Request):
-    import time
-    try:
-        body = await request.json()
-        email = body.get("email", "").strip().lower()
-        if not email or "@" not in email:
-            return JSONResponse({"error": "invalid email"}, status_code=400)
-        existing = await _db_read_one("SELECT id,role FROM users WHERE email=?", (email,))
-        if existing:
-            await _db_write("UPDATE users SET visit_count=visit_count+1, last_seen_at=? WHERE email=?",
-                          (time.time(), email))
-            return {"status": "exists", "role": dict(existing)["role"]}
-        import random
-        animals = ["🐱고양이","🐶강아지","🦊여우","🐻곰","🐼팬더","🐨코알라","🦁사자","🐯호랑이","🐰토끼","🦝너구리","🐸개구리","🦉올빼미","🦋나비","🐬돌고래","🦈상어","🐧��귄","🦜앵무새","🐢거북이"]
-        nick = "익명" + random.choice(animals) + str(random.randint(10,99))
-        role = "admin" if email == ADMIN_EMAIL else "user"
-        await _db_write("INSERT OR IGNORE INTO users (email,nickname,role,visit_count,last_seen_at,created_at) VALUES (?,?,?,1,?,?)",
-                       (email, nick, role, time.time(), time.time()))
-        _asyncio.create_task(_sa_backup_db())
-        return {"status": "created", "nickname": nick, "role": role}
-    except Exception as e:
-        return JSONResponse({"error": str(e)[:100]}, status_code=500)
-@app.post("/api/user/log")
-async def user_log_activity(request: Request):
-    import time, hashlib
-    try:
-        body = await request.json()
-        email = body.get("email", "").strip().lower()
-        if not email: return JSONResponse({"error": "email required"}, status_code=400)
-        action = body.get("action", "")
-        url = body.get("url", "")
-        title = body.get("title", "")
-        input_text = _sanitize_text(body.get("input_text", ""))
-        feature = body.get("feature", "")
-        url_hash = hashlib.sha256(url.encode()).hexdigest()[:16] if url else ""
-        domain = ""
-        if url:
-            try:
-                from urllib.parse import urlparse
-                domain = urlparse(url).netloc
-            except: pass
-        now = time.time()
-        if action == "visit" and url:
-            await _db_write("INSERT INTO page_visits (email,url_hash,url,title,domain,visit_count,last_visited_at,created_at) VALUES (?,?,?,?,?,1,?,?) ON CONFLICT(email,url_hash) DO UPDATE SET visit_count=visit_count+1, title=excluded.title, last_visited_at=excluded.last_visited_at",
-                          (email, url_hash, url[:500], title[:200] if title else None, domain, now, now))
-        elif action == "input" and input_text:
-            await _db_write("INSERT INTO user_inputs (email,url_hash,url,input_type,input_text,feature,result_length,created_at) VALUES (?,?,?,?,?,?,?,?)",
-                          (email, url_hash, url[:500] if url else None, body.get("input_type","chat"), input_text[:1000], feature, body.get("result_length",0), now))
-        if feature:
-            await _db_write("INSERT INTO feature_usage (email,feature,use_count,last_used_at) VALUES (?,?,1,?) ON CONFLICT(email,feature) DO UPDATE SET use_count=use_count+1, last_used_at=excluded.last_used_at",
-                          (email, feature, now))
-        return {"status": "ok"}
-    except Exception as e:
-        print(f"[user-log] error: {e}")
-        return JSONResponse({"error": str(e)[:100]}, status_code=500)
-@app.get("/api/user/profile")
-async def user_profile(email: str = ""):
-    email = email.strip().lower()
-    if not email: return JSONResponse({"error": "email required"}, status_code=400)
-    user = await _db_read_one("SELECT * FROM users WHERE email=?", (email,))
-    if not user: return JSONResponse({"error": "user not found"}, status_code=404)
-    user_dict = dict(user)
-    visits = await _db_read("SELECT domain, SUM(visit_count) as cnt FROM page_visits WHERE email=? GROUP BY domain ORDER BY cnt DESC LIMIT 10", (email,))
-    user_dict["top_domains"] = [{"domain": dict(v)["domain"], "count": dict(v)["cnt"]} for v in visits]
-    usage = await _db_read("SELECT feature, use_count FROM feature_usage WHERE email=? ORDER BY use_count DESC", (email,))
-    user_dict["feature_usage"] = [{"feature": dict(u)["feature"], "count": dict(u)["use_count"]} for u in usage]
-    inputs = await _db_read("SELECT input_text, feature, url, created_at FROM user_inputs WHERE email=? ORDER BY created_at DESC LIMIT 10", (email,))
-    user_dict["recent_inputs"] = [dict(i) for i in inputs]
-    return user_dict
-import time as _time
-_session_save_cache = {}  # email → (timestamp, body)
-_SESSION_THROTTLE = 5  # 초
-@app.post("/api/session/save")
-async def session_save(request: Request):
-    try:
-        body = await request.json()
-        email = (body.get("email") or "").strip().lower()
-        if not email:
-            return JSONResponse({"ok": False}, status_code=400)
-        # 스로틀: 같은 이메일은 5초에 1번만 실제 DB 기록
-        import time as _t
-        now = _t.time()
-        last = _session_save_cache.get(email, 0)
-        if now - last < _SESSION_THROTTLE:
-            return {"ok": True, "throttled": True}
-        _session_save_cache[email] = now
-        chat = (body.get("chat") or "")[:50000]
-        cmd = (body.get("cmd") or "")[:500]
-        url = (body.get("url") or "")[:2000]
-        title = (body.get("title") or "")[:500]
-        await _db_write("""
-            INSERT INTO sessions (email, chat, cmd, url, title, updated_at)
-            VALUES (?, ?, ?, ?, ?, ?)
-            ON CONFLICT(email) DO UPDATE SET
-                chat=excluded.chat, cmd=excluded.cmd,
-                url=excluded.url, title=excluded.title,
-                updated_at=excluded.updated_at
-        """, (email, chat, cmd, url, title, now))
-        return {"ok": True}
-    except Exception as e:
-        return JSONResponse({"ok": False, "error": str(e)[:100]}, status_code=500)
-@app.get("/api/session/load")
-async def session_load(email: str = ""):
-    email = email.strip().lower()
-    if not email:
-        return JSONResponse({"ok": False}, status_code=400)
-    row = await _db_read_one(
-        "SELECT chat, cmd, url, title, updated_at FROM sessions WHERE email=?", (email,))
-    if not row:
-        return {"ok": True, "chat": "", "cmd": "", "url": "", "title": "", "ts": 0}
-    d = dict(row)
-    return {"ok": True, "chat": d.get("chat",""), "cmd": d.get("cmd",""),
-            "url": d.get("url",""), "title": d.get("title",""),
-            "ts": d.get("updated_at", 0)}
-CLIP_BUCKET = "ginigen-ai/siteagent"
-from clips import router as clips_router
-from imagine import router as imagine_router
-from services import router as services_router
-from admin import router as admin_router
-from marl_routes import router as marl_router
-from saju_routes import router as saju_router
-from face_routes import router as face_router
-from memory import router as memory_router, init_memory_tables, save_conversation, build_memory_context, extract_memories_from_conversation, save_task
-app.include_router(clips_router)
-app.include_router(imagine_router)
-app.include_router(services_router)
-app.include_router(admin_router)
-app.include_router(marl_router)
-app.include_router(saju_router)
-app.include_router(face_router)
-app.include_router(memory_router)
-@app.get("/api/stats")
-async def stats():
-    return JSONResponse(calc_stats())
-@app.get("/api/marl-test")
-async def marl_test():
-    _init_marl()
-    result = {"marl_available": MARL_AVAILABLE, "groq_key_set": bool(GROQ_API_KEY)}
-    if MARL_AVAILABLE:
-        try:
-            config = MarlConfig(mode="insight", return_final_only=True, language="ko", budget_scale=0.5)
-            ml = Marl(call_fn=_groq_call_fn, config=config)
-            import asyncio
-            r = await asyncio.to_thread(ml.run, "1+1=? 한 줄로 답하라.", "한국어로 답변")
-            result["test_answer"] = r.answer[:200] if r.answer else "EMPTY"
-            result["test_elapsed"] = round(r.elapsed, 2)
-            result["test_ok"] = bool(r.answer and not r.answer.startswith("[ERROR"))
-        except Exception as e:
-            result["test_error"] = str(e)
-            result["test_ok"] = False
-    else:
-        result["test_ok"] = False
-        result["test_error"] = "MARL not available"
-    return JSONResponse(result)
-# ═══════════════════════════════════════════════════════
-# 🔐 시크릿 메신저 — E2E 암호화, DB 암호문 보관, 포렌식 차단
-# ═══════════════════════════════════════════════════════
-import secrets as _sec_secrets
-_sec_streams = {}       # email_hash → [asyncio.Queue] (SSE)
-_sec_pubcache = {}      # email_hash → pubkey_jwk (메모리 캐시)
-_SEC_TTL = 604800       # 7일
-
-@app.post("/api/sec/register")
-async def sec_register(request: Request):
-    """공개키 등록 → DB + 메모리 캐시"""
-    try: body = await request.json()
-    except: return JSONResponse({"error": "invalid json"}, status_code=400)
-    email_hash = body.get("email_hash", "").strip()
-    pubkey_jwk = body.get("pubkey_jwk")
-    if not email_hash or not pubkey_jwk or len(email_hash) != 64:
-        return JSONResponse({"error": "email_hash(sha256) and pubkey_jwk required"}, status_code=400)
-    import time, json
-    _sec_pubcache[email_hash] = pubkey_jwk
-    await _db_write("""INSERT INTO sec_keys (email_hash, pubkey_jwk, registered_at)
-        VALUES (?,?,?) ON CONFLICT(email_hash) DO UPDATE SET pubkey_jwk=excluded.pubkey_jwk, registered_at=excluded.registered_at""",
-        (email_hash, json.dumps(pubkey_jwk), time.time()))
-    total = await _db_read_one("SELECT COUNT(*) as c FROM sec_keys")
-    n = total["c"] if total else 0
-    print(f"[sec] 🔑 registered: {email_hash[:12]}... (total: {n})")
-    return {"ok": True, "total_users": n}
-
-@app.get("/api/sec/pubkey")
-async def sec_get_pubkey(target: str = ""):
-    """공개키 조회 → 메모리 캐시 → DB 폴백"""
-    target = target.strip()
-    if not target: return JSONResponse({"error": "target required"}, status_code=400)
-    if target in _sec_pubcache:
-        return {"ok": True, "pubkey_jwk": _sec_pubcache[target]}
-    import json
-    row = await _db_read_one("SELECT pubkey_jwk FROM sec_keys WHERE email_hash=?", (target,))
-    if not row:
-        print(f"[sec] ❌ pubkey MISS: {target[:12]}...")
-        return JSONResponse({"error": "user not found"}, status_code=404)
-    jwk = json.loads(row["pubkey_jwk"])
-    _sec_pubcache[target] = jwk
-    return {"ok": True, "pubkey_jwk": jwk}
-
-@app.post("/api/sec/send")
-async def sec_send(request: Request):
-    """메시지 릴레이 → DB 저장 + SSE 푸시"""
-    try: body = await request.json()
-    except: return JSONResponse({"error": "invalid json"}, status_code=400)
-    to_hash = body.get("to", "").strip()
-    from_hash = body.get("from", "").strip()
-    ciphertext = body.get("ciphertext", "")
-    iv = body.get("iv", "")
-    group_id = body.get("group_id", "")
-    if not to_hash or not from_hash or not ciphertext or not iv:
-        return JSONResponse({"error": "to, from, ciphertext, iv required"}, status_code=400)
-    # 수신자 등록 확인 (캐시 → DB)
-    if to_hash not in _sec_pubcache:
-        row = await _db_read_one("SELECT email_hash FROM sec_keys WHERE email_hash=?", (to_hash,))
-        if not row:
-            return JSONResponse({"error": "recipient not registered"}, status_code=404)
-    import time
-    msg_id = _sec_secrets.token_hex(8)
-    ts = time.time()
-    # DB에 암호문 저장 (서버 재시작해도 보존)
-    await _db_write("INSERT OR IGNORE INTO sec_messages (id,from_hash,to_hash,ciphertext,iv,group_id,ts) VALUES (?,?,?,?,?,?,?)",
-        (msg_id, from_hash, to_hash, ciphertext, iv, group_id, ts))
-    print(f"[sec] ✉️ {from_hash[:8]}→{to_hash[:8]} ({len(ciphertext)}B) id={msg_id}")
-    # SSE 실시간 푸시
-    if to_hash in _sec_streams:
-        import json as _sj
-        payload = _sj.dumps({"id":msg_id,"from":from_hash,"ciphertext":ciphertext,"iv":iv,"group_id":group_id,"ts":ts})
-        for q in _sec_streams[to_hash]:
-            try: q.put_nowait(payload)
-            except: pass
-    return {"ok": True, "id": msg_id, "ts": ts}
-
-@app.get("/api/sec/recv")
-async def sec_recv(email_hash: str = "", since: float = 0):
-    """수신 메시지 조회 (DB 기반, 서버 재시작해도 보존)"""
-    email_hash = email_hash.strip()
-    if not email_hash: return {"ok": True, "messages": []}
-    rows = await _db_read(
-        "SELECT id, from_hash, ciphertext, iv, group_id, ts FROM sec_messages WHERE to_hash=? AND ts>? ORDER BY ts ASC LIMIT 200",
-        (email_hash, since))
-    msgs = [{"id":r["id"],"from":r["from_hash"],"ciphertext":r["ciphertext"],"iv":r["iv"],"group_id":r["group_id"],"ts":r["ts"]} for r in rows]
-    if msgs:
-        print(f"[sec] 📨 {email_hash[:8]}← {len(msgs)} msgs")
-    return {"ok": True, "messages": msgs}
-
-@app.get("/api/sec/stream")
-async def sec_stream(email_hash: str = ""):
-    """SSE 실시간 스트림"""
-    import asyncio, json as _sj
-    email_hash = email_hash.strip()
-    if not email_hash: return JSONResponse({"error": "email_hash required"}, status_code=400)
-    q = asyncio.Queue(maxsize=50)
-    if email_hash not in _sec_streams: _sec_streams[email_hash] = []
-    _sec_streams[email_hash].append(q)
-    print(f"[sec] 📡 SSE connected: {email_hash[:8]}...")
-    async def event_gen():
-        try:
-            yield f"data: {_sj.dumps({'type':'connected'})}\n\n"
-            while True:
-                try:
-                    msg = await asyncio.wait_for(q.get(), timeout=25)
-                    yield f"data: {msg}\n\n"
-                except asyncio.TimeoutError:
-                    yield ": keepalive\n\n"
-        except asyncio.CancelledError: pass
-        finally:
-            if email_hash in _sec_streams and q in _sec_streams[email_hash]:
-                _sec_streams[email_hash].remove(q)
-            print(f"[sec] 📡 SSE disconnected: {email_hash[:8]}...")
-    from starlette.responses import StreamingResponse
-    return StreamingResponse(event_gen(), media_type="text/event-stream",
-        headers={"Cache-Control":"no-cache","X-Accel-Buffering":"no"})
-
-@app.get("/api/sec/status")
-async def sec_status(target: str = ""):
-    """온라인 상태 확인"""
-    target = target.strip()
-    registered = target in _sec_pubcache
-    if not registered:
-        row = await _db_read_one("SELECT email_hash FROM sec_keys WHERE email_hash=?", (target,))
-        registered = bool(row)
-    online = target in _sec_streams and len(_sec_streams[target]) > 0
-    return {"ok": True, "registered": registered, "online": online}
-
-@app.get("/api/sec/contacts")
-async def sec_contacts(email_hash: str = ""):
-    """대화 상대 목록 (DB에서 실제 대화한 상대 조회)"""
-    email_hash = email_hash.strip()
-    if not email_hash: return {"ok": True, "contacts": []}
-    rows = await _db_read("""
-        SELECT partner, MAX(ts) as last_ts, COUNT(*) as msg_count FROM (
-            SELECT from_hash as partner, ts FROM sec_messages WHERE to_hash=?
-            UNION ALL
-            SELECT to_hash as partner, ts FROM sec_messages WHERE from_hash=?
-        ) GROUP BY partner ORDER BY last_ts DESC""", (email_hash, email_hash))
-    contacts = []
-    for r in rows:
-        p = r["partner"]
-        online = p in _sec_streams and len(_sec_streams.get(p,[])) > 0
-        registered = p in _sec_pubcache
-        contacts.append({"hash":p, "online":online, "registered":registered,
-                         "last_ts":r["last_ts"], "msg_count":r["msg_count"]})
-    return {"ok": True, "contacts": contacts}
-
-@app.post("/api/sec/group/create")
-async def sec_group_create(request: Request):
-    """그룹 생성"""
-    try: body = await request.json()
-    except: return JSONResponse({"error": "invalid json"}, status_code=400)
-    group_id = body.get("group_id", _sec_secrets.token_hex(16))
-    return {"ok": True, "group_id": group_id}
-
-@app.post("/api/sec/group/send")
-async def sec_group_send(request: Request):
-    """그룹 메시지 — 각 멤버에게 개별 전송"""
-    try: body = await request.json()
-    except: return JSONResponse({"error": "invalid json"}, status_code=400)
-    group_id = body.get("group_id", "")
-    from_hash = body.get("from", "")
-    per_member = body.get("per_member", {})
-    if not group_id or not from_hash or not per_member:
-        return JSONResponse({"error": "group_id, from, per_member required"}, status_code=400)
-    import time
-    msg_id = _sec_secrets.token_hex(8)
-    ts = time.time()
-    delivered = 0
-    for member_hash, encrypted in per_member.items():
-        if member_hash == from_hash: continue
-        await _db_write("INSERT OR IGNORE INTO sec_messages (id,from_hash,to_hash,ciphertext,iv,group_id,ts) VALUES (?,?,?,?,?,?,?)",
-            (msg_id + "_" + member_hash[:8], from_hash, member_hash, encrypted.get("ciphertext",""), encrypted.get("iv",""), group_id, ts))
-        # SSE 푸시
-        if member_hash in _sec_streams:
-            import json as _sj
-            payload = _sj.dumps({"id":msg_id,"from":from_hash,"ciphertext":encrypted.get("ciphertext",""),"iv":encrypted.get("iv",""),"group_id":group_id,"ts":ts})
-            for q in _sec_streams[member_hash]:
-                try: q.put_nowait(payload)
-                except: pass
-        delivered += 1
-    return {"ok": True, "id": msg_id, "delivered": delivered}
-
-# ── 🔐 시크릿AI 메신저 — 공유 랜딩 페이지 ──
-_EDGE_URL = "https://microsoftedge.microsoft.com/addons/detail/siteagent-ai-web-assist/okphfpmfmmhkmhmjgbemlniahoobhfib"
-
-@app.get("/share")
-async def share_landing():
-    """시크릿AI 메신저 소개 + 설치 랜딩 페이지"""
-    html = f"""<!DOCTYPE html><html lang="ko"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
-<title>🔐 시크릿AI 메신저</title>
-<meta property="og:title" content="🔐 시크릿AI 메신저 — 포렌식 불가 E2E 암호화">
-<meta property="og:description" content="화이트해커가 만든 비밀 메신저. 설치하고 비밀 대화를 시작하세요.">
-<style>
-*{{margin:0;padding:0;box-sizing:border-box}}
-body{{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif;background:#0a0a0f;color:#e0e0e0;min-height:100vh;display:flex;align-items:center;justify-content:center}}
-.card{{background:#12121a;border:1px solid #1e1e2e;border-radius:20px;padding:40px 32px;max-width:420px;width:90%;text-align:center;box-shadow:0 20px 60px rgba(0,0,0,.5)}}
-.logo{{font-size:56px;margin-bottom:16px}}
-h1{{font-size:24px;font-weight:800;color:#00d4aa;margin-bottom:8px}}
-.sub{{font-size:13px;color:#888;line-height:1.7;margin-bottom:24px}}
-.features{{display:grid;grid-template-columns:1fr 1fr;gap:8px;margin-bottom:24px;text-align:left}}
-.feat{{background:rgba(0,212,170,.05);border:1px solid #1e1e2e;border-radius:10px;padding:10px 12px}}
-.feat b{{color:#00d4aa;font-size:11px;display:block;margin-bottom:2px}}
-.feat span{{color:#888;font-size:9px;line-height:1.4}}
-.btn{{display:block;width:100%;padding:14px;border:none;border-radius:12px;font-size:14px;font-weight:700;cursor:pointer;text-decoration:none;margin-bottom:10px;transition:opacity .15s}}
-.btn:hover{{opacity:.85}}
-.btn-edge{{background:linear-gradient(135deg,#0078d4,#00bcf2);color:#fff}}
-.btn-web{{background:linear-gradient(135deg,#00d4aa,#007a6a);color:#fff}}
-.steps{{text-align:left;margin-top:20px;padding:16px;background:rgba(0,212,170,.05);border-radius:12px;font-size:12px;line-height:2;color:#aaa}}
-.steps b{{color:#00d4aa}}
-.footer{{margin-top:20px;font-size:9px;color:#444;line-height:1.6}}
-</style></head><body><div class="card">
-<div class="logo">🔐</div>
-<h1>시크릿AI 메신저</h1>
-<div class="sub">화이트해커가 만든 포렌식 불가 메신저<br>E2E 암호화 · 메모리 전용 · 서버 무저장</div>
-<div class="features">
-<div class="feat"><b>🔒 E2E 암호화</b><span>AES-256-GCM + ECDH</span></div>
-<div class="feat"><b>🕵️ 포렌식 차단</b><span>디스크 기록 ZERO</span></div>
-<div class="feat"><b>🤖 AI 내장</b><span>웹 요약·번역·분석</span></div>
-<div class="feat"><b>👻 은닉</b><span>AI 도우미로 위장</span></div>
-</div>
-<a href="{_EDGE_URL}" class="btn btn-edge" target="_blank">🌐 Edge 확장 설치</a>
-<a href="https://ginigen-ai-siteagent.hf.space" class="btn btn-web" target="_blank">🚀 웹에서 바로 시작</a>
-<div class="steps">
-<b>3단계로 시작:</b><br>
-1️⃣ SiteAgent 설치 → 아무 웹페이지에서 패널 열기<br>
-2️⃣ <b>🔐 시크릿AI</b> 버튼 → 이메일 + 패스프레이즈로 잠금 해제<br>
-3️⃣ <b>+ 대화</b> → 상대방 이메일 입력 → 비밀 대�� 시작!
-</div>
-<div class="footer">
-🔐 대법원 특수감정인 출신 화이트해커가 설계<br>
-AES-256-GCM · ECDH P-256 · Web Crypto API<br>
-Powered by Ginigen AI · SiteAgent
-</div></div></body></html>"""
-    return Response(html, media_type="text/html")
-
-@app.get("/secure-pageagent.extend.js")
-async def serve_js():
-    if _PAGE_AGENT_JS:
-        return Response(_PAGE_AGENT_JS, media_type="application/javascript", headers={"Cache-Control": "no-cache, no-store, must-revalidate", "Pragma": "no-cache", "Expires": "0"})
-    return JSONResponse({"error": "js not found"}, status_code=404)
-@app.get("/style.css")
-async def serve_css():
-    return Response("", media_type="text/css")
-@app.get("/{img_name}.png")
-async def serve_img(img_name: str):
-    """설치 가이드 이미지 서빙"""
-    if not img_name.isalnum() or len(img_name) > 10:
-        return JSONResponse({"error": "not found"}, status_code=404)
-    for d in [Path(__file__).parent, Path("."), Path("/home/user/app")]:
-        f = d / f"{img_name}.png"
-        try:
-            if f.exists():
-                return Response(f.read_bytes(), media_type="image/png", headers={"Cache-Control": "public, max-age=86400"})
-        except: continue
-    return JSONResponse({"error": "not found"}, status_code=404)
-@app.get("/siteagent-extension-v7.zip")
-async def serve_extension_zip():
-    """확장 프로그램 ZIP 다운로드"""
-    for d in [Path(__file__).parent, Path("."), Path("/home/user/app")]:
-        f = d / "siteagent-extension-v7.zip"
-        try:
-            if f.exists():
-                return Response(f.read_bytes(), media_type="application/zip",
-                    headers={"Content-Disposition": "attachment; filename=siteagent-extension-v7.zip", "Cache-Control": "no-cache"})
-        except: continue
-    return JSONResponse({"error": "zip not found"}, status_code=404)
-@app.get("/")
-@app.get("/index.html")
-async def serve_index():
-    path = "index.html"
-    if not os.path.isfile(path):
-        return JSONResponse({"error": "index.html not found"}, status_code=404)
-    return FileResponse(path, media_type="text/html")
-uvicorn.run(app, host="0.0.0.0", port=7860)
-
+        error_msg = traceback.format_exc()
+        
+        with gr.Blocks() as demo:
+            gr.Markdown("# ⚠️ Error Loading Application")
+            gr.Markdown(f"**Error:** {str(e)}")
+            gr.Code(error_msg, language="python", label="Traceback")
+        demo.launch()
+
+if __name__ == "__main__":
+    main()