webchat_server.py

"""Dulus WebChat — in-process mirror of the terminal agent.
"""
from __future__ import annotations

import json
import queue
import threading
import time
import uuid
import webbrowser
import sys
from pathlib import Path
from typing import Any, Generator

from backend.agents_bridge import build_agent_info_list
from backend.context import build_context, build_smart_context, get_compact_context
from backend.personas import create_persona, get_active_persona, get_all_personas, get_persona, load_personas, set_active_persona, update_persona
from backend.plugins import load_all_plugins, get_plugin_info, start_watcher, stop_watcher, watcher_status, reload_plugin, unload_plugin
from task import create_task as task_create, list_tasks as task_list, update_task as task_update, get_task as task_get, delete_task as task_delete
from backend.marketplace import load_registry, search_plugins, get_stats as marketplace_stats, install_plugin, uninstall_plugin
from backend.session_utils import scan_sessions, save_session, delete_session as _delete_session_disk

def _resolve_dashboard_dir() -> Path:
    """Find docs/dashboard whether running from source or installed package."""
    # 1. Try source layout (development)
    src = Path(__file__).parent / "docs" / "dashboard"
    if src.exists():
        return src
    # 2. Try installed package (docs is now a package)
    try:
        import docs as _docs_pkg
        pkg = Path(_docs_pkg.__file__).parent / "dashboard"
        if pkg.exists():
            return pkg
    except Exception:
        pass
    # 3. Fallback — will 404 gracefully
    return src

def _resolve_webchat_ui_dir() -> Path:
    """Find webchat_ui whether running from source or installed package."""
    # 1. Try source layout (development)
    src = Path(__file__).parent / "webchat_ui"
    if src.exists() and (src / "index.html").exists():
        return src
    # 2. Try installed package (wheel layout mirrors source)
    try:
        import webchat_ui as _wui_pkg
        pkg = Path(_wui_pkg.__file__).parent
        if pkg.exists() and (pkg / "index.html").exists():
            return pkg
    except Exception:
        pass
    # 3. Fallback — caller should check existence
    return src


DASHBOARD_DIR = _resolve_dashboard_dir()
WEBCHAT_UI_DIR = _resolve_webchat_ui_dir()

from flask import Flask, request, jsonify, Response, stream_with_context, send_from_directory
from flask.typing import ResponseReturnValue

from agent import (
    run as agent_run,
    AgentState,
    TextChunk,
    ThinkingChunk,
    ToolStart,
    ToolEnd,
    TurnDone,
    PermissionRequest,
)
from context import build_system_prompt
from common import sanitize_text

# Ensure tools are registered
import tools as _tools_init
import memory.tools as _mem_tools_init
import multi_agent.tools as _ma_tools_init
import skill.tools as _sk_tools_init
import dulus_mcp.tools as _mcp_tools_init
import task.tools as _task_tools_init

try:
    import tmux_tools as _tmux_tools_init
except Exception:
    pass

# ─────────── SSE Broadcast System ───────────
_sse_clients: list[queue.Queue] = []
_sse_lock = threading.Lock()

def _add_sse_client(q: queue.Queue):
    with _sse_lock:
        _sse_clients.append(q)

def _remove_sse_client(q: queue.Queue):
    with _sse_lock:
        if q in _sse_clients:
            _sse_clients.remove(q)

def broadcast_event(event_type: str, payload: dict):
    """Broadcast JSON event to all connected SSE clients."""
    data = json.dumps({"type": event_type, "data": payload, "ts": time.time()})
    msg = f"event: {event_type}\ndata: {data}\n\n"
    with _sse_lock:
        dead = []
        for q in _sse_clients:
            try:
                q.put_nowait(msg)
            except queue.Full:
                dead.append(q)
        for q in dead:
            _sse_clients.remove(q)

def _sse_heartbeat():
    """Send periodic ping to keep connections alive."""
    while True:
        time.sleep(15)
        broadcast_event("ping", {"status": "ok"})

threading.Thread(target=_sse_heartbeat, daemon=True, name="sse-heartbeat").start()

# ── shared refs ────────────────────────────────────────────────────────────
STATE: AgentState | None = None
CONFIG: dict | None = None
_LOCK = threading.Lock()
_PENDING_PERMISSIONS: dict[str, tuple[PermissionRequest, threading.Event]] = {}

# ── AskUserQuestion bridge (mirrors the permission flow) ───────────────────
# tools._ask_user_question() blocks a background thread waiting for someone
# to drain tools._pending_questions. In the terminal the REPL does that; in
# the webchat we poll it with a watcher thread, surface the question as an
# SSE event, and answer it via POST /question.
_PENDING_QUESTIONS: dict[str, dict] = {}

# Per-request cancellation tokens for the main WebChat. Concurrent browser
# turns stay isolated by run_id.
_WEBCHAT_STOP_EVENTS: dict[str, threading.Event] = {}
_WEBCHAT_STOP_EVENTS_LOCK = threading.Lock()


def _start_question_watcher(q: "queue.Queue", stop_evt: threading.Event) -> threading.Thread:
    """Poll tools._pending_questions and forward AskUserQuestion prompts to the
    SSE stream as {"type": "question", ...} events (same pattern as permissions)."""
    def watcher():
        import time as _t_time
        import tools as _t
        while not stop_evt.is_set():
            grabbed: list[dict] = []
            try:
                with _t._ask_lock:
                    if _t._pending_questions:
                        grabbed = list(_t._pending_questions)
                        _t._pending_questions.clear()
            except Exception:
                pass
            # Purge entries the agent already gave up on (AskUserQuestion
            # times out after 300s) so a late click can never land on a dead
            # entry and look "answered" while nobody is listening.
            try:
                with _LOCK:
                    _now = _t_time.time()
                    for _qid, _e in list(_PENDING_QUESTIONS.items()):
                        if _now - float(_e.get("_ts", _now)) > 310:
                            _PENDING_QUESTIONS.pop(_qid, None)
            except Exception:
                pass
            for entry in grabbed:
                entry["_ts"] = _t_time.time()
                qid = str(uuid.uuid4())
                with _LOCK:
                    _PENDING_QUESTIONS[qid] = entry
                q.put({
                    "type": "question",
                    "id": qid,
                    "question": entry.get("question", ""),
                    "options": entry.get("options") or [],
                    "allow_freetext": bool(entry.get("allow_freetext", True)),
                })
            stop_evt.wait(0.25)
    t = threading.Thread(target=watcher, daemon=True)
    t.start()
    return t

# Session context deferment
_PENDING_HISTORY: list[dict] = []
_PENDING_SESSION_ID: str | None = None

_SERVER_THREAD: threading.Thread | None = None
_SERVER_PORT: int = 5000
_WERKZEUG_SERVER = None

# ── WebChat authentication ─────────────────────────────────────────────────
# This API can run shell (/api/sandbox/exec), read and write files, and spend
# model tokens. That is harmless on loopback, where only you can reach it, and
# dangerous the moment the server binds anything else — a LAN, a container, a
# cloud host. So auth switches itself on exactly when the bind leaves loopback.
#
#   DULUS_WEBCHAT_TOKEN — the shared secret. Auto-generated and printed once
#                         at startup when unset.
#   DULUS_WEBCHAT_AUTH  — "auto" (default: on only once exposed) | "always" | "off"
#
# Clients may present it as `X-Dulus-Token`, `Authorization: Bearer <tok>`,
# or `?token=`.
import os as _os_env
import secrets as _secrets
from urllib.parse import urlparse as _urlparse

_WEBCHAT_TOKEN: str | None = None
_TOKEN_AUTOGEN = False
_LAN_EXPOSED = False  # True once the bind leaves loopback (0.0.0.0 / a LAN IP)
_LOOPBACK_ADDRS = {"127.0.0.1", "::1", "localhost"}
_LOOPBACK_ORIGIN_HOSTS = {"localhost", "127.0.0.1", "::1"}


def _resolve_token() -> tuple[str, bool]:
    env_tok = _os_env.environ.get("DULUS_WEBCHAT_TOKEN", "").strip()
    if env_tok:
        return env_tok, False
    return _secrets.token_urlsafe(24), True


def _auth_mode() -> str:
    mode = _os_env.environ.get("DULUS_WEBCHAT_AUTH", "auto").strip().lower()
    return mode if mode in ("auto", "always", "off") else "auto"


def _auth_active() -> bool:
    mode = _auth_mode()
    if mode == "always":
        return True
    if mode == "off":
        return False
    return _LAN_EXPOSED


def _request_token() -> str:
    tok = (request.headers.get("X-Dulus-Token") or "").strip()
    if not tok:
        auth = (request.headers.get("Authorization") or "").strip()
        if auth.lower().startswith("bearer "):
            tok = auth[7:].strip()
    if not tok:
        tok = (request.args.get("token") or "").strip()
    return tok


def _token_ok(tok: str) -> bool:
    return bool(_WEBCHAT_TOKEN) and bool(tok) and _secrets.compare_digest(tok, _WEBCHAT_TOKEN)


def _cross_site_browser_ride() -> bool:
    """Anti-CSRF: a browser sitting on some other site poking the local server."""
    sfs = (request.headers.get("Sec-Fetch-Site") or "").lower()
    if sfs == "cross-site":
        return True
    origin = request.headers.get("Origin")
    if origin:
        try:
            host = (_urlparse(origin).hostname or "").lower()
        except Exception:
            return True
        if host not in _LOOPBACK_ORIGIN_HOSTS:
            return True
    return False


def _local_ui_exempt() -> bool:
    """The UI this server itself served, over a real loopback socket.

    Requires a genuine loopback peer (a remote client cannot forge remote_addr)
    plus browser evidence of same-origin. A malicious page sends its own Origin
    or a cross-site Sec-Fetch-Site, so it never qualifies.
    """
    if (request.remote_addr or "") not in _LOOPBACK_ADDRS:
        return False
    origin = request.headers.get("Origin")
    if origin:
        try:
            host = (_urlparse(origin).hostname or "").lower()
        except Exception:
            return False
        return host in _LOOPBACK_ORIGIN_HOSTS
    sfs = (request.headers.get("Sec-Fetch-Site") or "").lower()
    return sfs in ("same-origin", "same-site", "none")


def _is_public_path() -> bool:
    """Health probe and the static UI. Serving the HTML/JS is not privileged —
    every functional call it then makes is still gated."""
    path = request.path or "/"
    if path == "/api/health":
        return True
    return request.method == "GET" and not path.startswith("/api/") and path != "/chat"


def _require_auth():
    """Gate every request. None to allow, or (response, status) to reject.

    Applied as a before_request hook so endpoints added later are protected by
    default rather than by remembering to opt in.
    """
    if request.method == "OPTIONS" or _is_public_path():
        return None
    if _token_ok(_request_token()):
        return None
    if not _auth_active():
        # Loopback-only: no token needed, but never let another site ride along.
        if _cross_site_browser_ride():
            return jsonify(error="forbidden: cross-site request blocked"), 403
        return None
    if _local_ui_exempt():
        return None
    return jsonify(error="unauthorized: token required (X-Dulus-Token)"), 401

def _ensure_plugin_tools() -> None:
    try:
        from plugin.loader import register_plugin_tools
        register_plugin_tools()
    except Exception:
        pass


_ANSI_RE = None


def _strip_ansi(text: str) -> str:
    global _ANSI_RE
    if _ANSI_RE is None:
        import re
        _ANSI_RE = re.compile(r'\x1b\[[0-9;]*m')
    return _ANSI_RE.sub('', text)



_GOLD_MARKER = "[Golden Memory Loaded:"
_WELCOME_MARKER = "<!-- dulus:welcome -->"


def _preload_gold_memories(state, cfg: dict) -> None:
    """Seed a session with gold *display* copies for the GUI transcript.

    Model source of truth is ``build_system_prompt`` → ``gold_system_fragment()``.
    These assistant-role blobs only exist so the GUI can render gold in history;
    agent.py strips them before the provider call.

    Deliberately NOT gated by ``mem_palace``.
    """
    try:
        for m in state.messages:
            if isinstance(m, dict) and str(m.get("content", "")).startswith(_GOLD_MARKER):
                return
        token = str(cfg.get("_session_id") or "fresh")
        if cfg.get("_gold_preloaded") == token:
            return
        cfg["_gold_preloaded"] = token
        from memory import gold_context_messages
        msgs = gold_context_messages()
        if not msgs:
            return
        with _LOCK:
            for offset, msg in enumerate(msgs):
                state.messages.insert(offset, msg)
    except Exception:
        pass


def _inject_mempalace(user_input: str, config: dict) -> str:
    """Inject relevant memories from MemPalace into the user message.
    Mirrors the logic in dulus.py REPL for consistent behavior.
    """
    if not config.get("mem_palace", True):
        return user_input
    if not user_input or len(user_input.strip()) < 12:
        return user_input
    _trivial = {"hola", "klk", "gracias", "ok", "si", "no", "dale",
                "exit", "quit", "help", "thanks", "bien"}
    _first = user_input.strip().lower().split()[0].strip(".,!?;:")
    if _first in _trivial:
        return user_input
    try:
        _q = user_input.strip()[:200]
        _raw_hits = []
        # Primary: query the real MemPalace (~/.mempalace/palace)
        try:
            # mempalace >=3.10 exec()s `search_memories` into the searcher
            # package globals, so it resolves at runtime but not statically.
            from mempalace.searcher import search_memories as _mp_search  # type: ignore[attr-defined]
            from mempalace.config import MempalaceConfig as _MPCfg
            _palace = _MPCfg().palace_path
            _res = _mp_search(_q, _palace, n_results=3)
            for _hit in (_res or {}).get("results", []):
                _meta = _hit.get("metadata") or {}
                _src = _meta.get("source_file") or _meta.get("name") or "palace"
                _name = str(_src).rsplit("/", 1)[-1].rsplit("\\", 1)[-1].rsplit(".", 1)[0]
                _vec = max(0.0, 1.0 - float(_hit.get("distance", 1.0)))
                _bm = float(_hit.get("bm25_score", 0.0))
                _raw_hits.append({
                    "name": _name,
                    "description": _meta.get("wing") or _meta.get("room") or "",
                    "content": _hit.get("text", ""),
                    "keyword_score": max(_vec, _bm),
                })
        except Exception:
            pass
        # Fallback: Dulus's local memory dir
        if not _raw_hits:
            from memory import find_relevant_memories
            _raw_hits = find_relevant_memories(_q, max_results=3)
        _MIN_SCORE = 0.15
        _kept = [h for h in _raw_hits if float(h.get("keyword_score", 0.0)) >= _MIN_SCORE]
        # Skip short_memory/soul — already in system-prompt baseline.
        try:
            from memory import is_baseline_memory_name
            _kept = [
                h for h in _kept
                if not is_baseline_memory_name(h.get("name"))
            ]
        except Exception:
            pass
        # Dedup against session cache
        import hashlib as _hashlib
        def _mp_dedup_key(h):
            content = (h.get("content") or "").strip()[:240]
            return _hashlib.md5(content.encode("utf-8", errors="ignore")).hexdigest()[:12]
        _seen = config.setdefault("_mp_injected_keys", set())
        _this_turn = set()
        _filtered = []
        for _h in _kept:
            _k = _mp_dedup_key(_h)
            if _k in _seen or _k in _this_turn:
                continue
            _this_turn.add(_k)
            _filtered.append(_h)
        _kept = _filtered
        if not _kept:
            return user_input
        _BODY_BUDGET = 1800
        _per_hit = max(300, _BODY_BUDGET // len(_kept))
        _parts = []
        for _i, _h in enumerate(_kept, 1):
            _name = _h.get("name", f"hit_{_i}")
            _desc = _h.get("description", "")
            _body = _h.get("content", "").strip()
            _snip = _body[:_per_hit] + ("..." if len(_body) > _per_hit else "")
            if _desc:
                _parts.append(f"### {_name}\n_{_desc}_\n{_snip}")
            else:
                _parts.append(f"### {_name}\n{_snip}")
        _hits_str = "\n\n".join(_parts)
        if len(_hits_str) > 2000:
            _hits_str = _hits_str[:2000] + "\n[...truncated]"
        _inject = (
            "[MemPalace — relevant memories pre-loaded for this turn. "
            "Do NOT re-query unless the user explicitly asks for more. "
            "The answer to the user's question is very likely already "
            "below — read it BEFORE reaching for any tool.]\n\n"
            + _hits_str
        )
        # Mark these as injected so we don't repeat them next turn
        for _h in _kept:
            _seen.add(_mp_dedup_key(_h))
        return _inject + "\n\n---\n\n[USER MESSAGE]\n" + user_input
    except Exception:
        return user_input


def _run_slash_command(cmd_line: str) -> tuple[str, str | None]:
    """Run a slash command through the REPL's registered handler,
    capturing stdout. Mirrors the Telegram bridge behavior
    (dulus.py:_handle_slash_from_telegram).

    Returns (output_text, assistant_reply_or_None).
    `assistant_reply` is set when the slash triggered a model query
    (cmd_type == "query") so the caller can stream it as a separate chunk.
    """
    import io
    if CONFIG is None:
        return ("[webchat] server not initialized", None)
    slash_cb = CONFIG.get("_handle_slash_callback")
    if not slash_cb:
        return (
            f"[webchat] slash commands unavailable — REPL not active.\n"
            f"Command was: {cmd_line}",
            None,
        )

    old_stdout = sys.stdout
    buf = io.StringIO()
    sys.stdout = buf
    try:
        try:
            cmd_type = slash_cb(cmd_line)
        except Exception as e:
            return (f"⚠ Error: {type(e).__name__}: {e}", None)
    finally:
        sys.stdout = old_stdout

    captured = _strip_ansi(buf.getvalue()).strip()
    if not captured and cmd_type == "simple":
        cmd_name = cmd_line.strip().split()[0]
        captured = f"✅ {cmd_name} executed."

    assistant_reply: str | None = None
    if cmd_type == "query" and STATE is not None and STATE.messages:
        for m in reversed(STATE.messages):
            if m.get("role") == "assistant":
                content = m.get("content", "")
                if isinstance(content, list):
                    parts = []
                    for block in content:
                        if isinstance(block, dict) and block.get("type") == "text":
                            parts.append(block["text"])
                        elif isinstance(block, str):
                            parts.append(block)
                    content = "\n".join(parts)
                if content:
                    assistant_reply = content
                break

    return (captured, assistant_reply)


def _run_agent_mirror(user_message: str, cancel_check=None) -> Generator:
    """Run the agent loop with shared state/config, yielding all events."""
    _ensure_plugin_tools()
    if STATE is None or CONFIG is None:
        raise RuntimeError("webchat server not initialized")

    cfg = CONFIG
    state = STATE
    user_input = sanitize_text(user_message)

    # ── Dulus Bar (Dynamic Island) — live status for single-agent surfaces ──
    # WebChat and the desktop GUI both run through this mirror. Lazy-start
    # is idempotent. Optional: not enabled / no island / no dulus-bar → no-op.
    try:
        import dulus_bar_client as _bar
        if _bar.enabled(cfg):
            _bmodel = cfg.get("model", "")
            _bar.get().start(model=_bmodel, session_id=cfg.get("_session_id"))
            _bctx = ""
            try:
                from compaction import estimate_tokens, get_context_limit
                _bused = estimate_tokens(state.messages, _bmodel, cfg, fast=True)
                _blimit = get_context_limit(_bmodel) or 128000
                _bpct = (_bused * 100 / _blimit) if _blimit else 0
                _bctx = f"{_bpct:.1f}%" if _bpct < 1 else f"{int(_bpct)}%"
            except Exception:
                pass
            _bar.get().status(model=_bmodel, ctx=_bctx)
    except Exception:
        pass

    _skill_body = cfg.pop("_skill_inject", "")
    if _skill_body:
        user_input = (
            "[SKILL CONTEXT — follow these instructions for this turn]\n\n"
            + _skill_body
            + "\n\n---\n\n[USER MESSAGE]\n"
            + user_input
        )

    user_input = _inject_mempalace(user_input, cfg)

    # Gold display copies for GUI transcript (model gets them via system prompt).
    _preload_gold_memories(state, cfg)

    system_prompt = build_system_prompt(cfg)
    cfg.pop("_in_telegram_turn", None)
    cfg["_last_interaction_time"] = time.time()

    # ── Handle deferred loading ───────────────────────────────────────
    global _PENDING_HISTORY, _PENDING_SESSION_ID
    if _PENDING_HISTORY:
        with _LOCK:
            state.messages.clear()
            # Allow next turn to re-seed gold display copies
            try:
                CONFIG.pop("_gold_preloaded", None)
            except Exception:
                pass
            for m in _PENDING_HISTORY:
                state.messages.append(m)
            cfg["_session_id"] = _PENDING_SESSION_ID
            _PENDING_HISTORY = []
            _PENDING_SESSION_ID = None

    # track tool calls in this turn to group them if verbose is OFF
    _turn_tools = []
    _is_verbose = cfg.get("verbose", False)

    for event in agent_run(user_input, state, cfg, system_prompt, cancel_check=cancel_check):
        if not _is_verbose and isinstance(event, (ToolStart, ToolEnd)):
            _turn_tools.append(event)
            # If start, we might want to yield a minimal 'working' sign
            if isinstance(event, ToolStart):
                yield ToolStart(name="working...", inputs={})
            continue
        
        if isinstance(event, TurnDone) and not _is_verbose and _turn_tools:
            # Yield a summary of grouped tools before finishing
            names = list(dict.fromkeys(t.name for t in _turn_tools if isinstance(t, ToolStart)))
            summary = f"Used tools: {', '.join(names)}"
            yield ToolEnd(name="Summary", result=summary, permitted=True)
            _turn_tools = []

        yield event

    try:
        import checkpoint as ckpt
        session_id = cfg.get("_session_id", "default")
        tracked = ckpt.get_tracked_edits()
        last_snaps = ckpt.list_snapshots(session_id)
        skip = False
        if not tracked and last_snaps:
            if len(state.messages) == last_snaps[-1].get("message_index", -1):
                skip = True
        if not skip:
            ckpt.make_snapshot(session_id, state, cfg, user_input, tracked_edits=tracked)
        ckpt.reset_tracked()
    except Exception:
        pass


def _event_to_dict(event, bar_ok: bool = True) -> "dict | tuple | None":
    if isinstance(event, TextChunk):
        return {"type": "text", "text": event.text}
    elif isinstance(event, ThinkingChunk):
        return {"type": "thinking", "text": event.text}
    elif isinstance(event, ToolStart):
        return {"type": "tool_start", "name": event.name, "inputs": event.inputs}
    elif isinstance(event, ToolEnd):
        return {"type": "tool_end", "name": event.name, "result": event.result, "permitted": event.permitted}
    elif isinstance(event, TurnDone):
        return {
            "type":        "turn_done",
            "in":          event.input_tokens,
            "out":         event.output_tokens,
            "cache_read":  getattr(event, "cache_read_tokens", 0),
            "cache_write": getattr(event, "cache_creation_tokens", 0),
        }
    elif isinstance(event, PermissionRequest):
        pid = str(uuid.uuid4())
        evt = threading.Event()
        _PENDING_PERMISSIONS[pid] = (event, evt)
        # Dulus Bar: mirror the prompt to the island and let an Allow/Deny click
        # there resolve it (single-agent only — bar_ok=False for Round Table).
        try:
            import dulus_bar_client as _bar
            if bar_ok and _bar.enabled(CONFIG):
                _bar.get().start(model=(CONFIG or {}).get("model", ""))
                _bar.get().tool_request(event.description or "tool")

                def _island_resolve(approved, _sid, _evt=evt, _ev=event, _pid=pid):
                    if _evt.is_set():
                        return
                    _ev.granted = bool(approved)
                    _PENDING_PERMISSIONS.pop(_pid, None)
                    try:
                        _bar.get().tool_result(bool(approved))
                    except Exception:
                        pass
                    _evt.set()

                _bar.get().on_decision(_island_resolve)
        except Exception:
            pass
        payload = {"type": "permission", "id": pid, "description": event.description}
        return payload, evt
    return None


def _sanitize_for_api(text: str) -> str:
    """Aggressive sanitize: remove control chars (except \n\r\t), surrogates, and normalize."""
    if not isinstance(text, str):
        text = str(text)
    # Step 1: remove UTF-16 surrogates
    text = "".join(c for c in text if not (0xD800 <= ord(c) <= 0xDFFF))
    # Step 2: remove control characters except newline, carriage return, tab
    text = "".join(c for c in text if ord(c) >= 32 or c in "\n\r\t")
    # Step 3: normalize fancy quotes to plain quotes
    text = text.replace("\u201c", '"').replace("\u201d", '"')
    text = text.replace("\u2018", "'").replace("\u2019", "'")
    text = text.replace("\u2013", "-").replace("\u2014", "-")
    # Step 4: strip leading/trailing whitespace per line but keep structure
    return text.strip()


# ── Flask app ──────────────────────────────────────────────────────────────

def create_app() -> Flask:
    app = Flask(__name__)
    import logging as _logging
    _logging.getLogger("werkzeug").setLevel(_logging.ERROR)
    app.logger.disabled = True

    # Gate every request before it reaches a route (see _require_auth). Doing
    # it here, rather than per-endpoint, means a route added later is protected
    # by default instead of by remembering to opt in.
    @app.before_request
    def _auth_gate():  # type: ignore[unused-ignore]
        denied = _require_auth()
        if denied is not None:
            body, status = denied
            return body, status
        return None

    # ── CORS: open allow-list for cross-origin clients ───────────────────
    # The Android sandbox APK loads its bundled React UI from a synthetic
    # https://appassets.androidplatform.net/ origin via WebViewAssetLoader,
    # then fetches the daemon's REST/SSE endpoints over LAN HTTP. That's
    # a cross-origin request — without these headers Android WebView
    # silently drops every response and the in-APK sandbox shows the OS
    # shell but every app stays disconnected (the documented symptom).
    # Browser-on-phone hits :5000/sandbox/ as same-origin and bypasses
    # CORS entirely, which is why it "just works" outside the APK.
    @app.after_request
    def _cors_headers(resp):
        resp.headers["Access-Control-Allow-Origin"] = "*"
        resp.headers["Access-Control-Allow-Methods"] = "GET, POST, PUT, PATCH, DELETE, OPTIONS"
        resp.headers["Access-Control-Allow-Headers"] = "Content-Type, Authorization, X-Requested-With"
        resp.headers["Access-Control-Expose-Headers"] = "Content-Type, X-Session-Id"
        resp.headers["Access-Control-Max-Age"] = "3600"
        return resp

    @app.route("/<path:_any>", methods=["OPTIONS"])
    @app.route("/", methods=["OPTIONS"])
    def _cors_preflight(_any=""):
        # OPTIONS preflight comes in before any real call. Return 204 with
        # the CORS headers (the after_request hook fills them in).
        return ("", 204)

    # ───────────────────────── Chat Normal HTML ─────────────────────────
    CHAT_PAGE = r"""<!doctype html>
<html lang="es"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><link rel="icon" type="image/png" href="/dulus-bird.png">
<title>Dulus WebChat</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;700;800&family=Archivo+Black&display=swap" rel="stylesheet">
<style>
:root{
  --bg:#0a0a0a;--bg2:#0f0f12;--bg3:#15151a;--bg4:#1a1a20;
  --ink:#f0e8df;--dim:#6a6470;--dim2:#3a3840;
  --accent:#ff6b1f;--accent2:#ffb347;
  --mono:'JetBrains Mono',monospace;
  --display:'Archivo Black','Impact',sans-serif;
  --radius:4px;
  --green:#7cffb5;--red:#ff5a6e;--yellow:#ffd166;
}
*{box-sizing:border-box;margin:0;padding:0}
html{scroll-behavior:smooth;font-size:16px}
body{background:var(--bg);color:var(--ink);font-family:var(--mono);height:100vh;display:flex;flex-direction:column;position:relative;overflow:hidden}
::-webkit-scrollbar{width:6px}
::-webkit-scrollbar-track{background:var(--bg)}
::-webkit-scrollbar-thumb{background:var(--accent);border-radius:3px}
.grid-bg{
  position:fixed;inset:0;pointer-events:none;z-index:0;
  background-image:linear-gradient(rgba(255,107,31,.06) 1px,transparent 1px),
                   linear-gradient(90deg,rgba(255,107,31,.06) 1px,transparent 1px);
  background-size:40px 40px;
  mask-image:radial-gradient(ellipse at center,black 30%,transparent 80%);
}
#app{display:flex;height:100vh;overflow:hidden;position:relative}

/* ===== Sidebar ===== */
#sidebar{
  width:260px;min-width:260px;background:var(--bg2);border-right:1px solid rgba(255,107,31,.12);
  display:flex;flex-direction:column;transition:width .25s ease,min-width .25s ease;margin-left:0;
  position:relative;z-index:200;height:100vh
}
#sidebar.collapsed{width:48px;min-width:48px}
#sidebar.collapsed .sidebar-expanded{display:none!important}
#sidebar:not(.collapsed) .sidebar-collapsed{display:none!important}
.sidebar-collapsed{display:flex;flex-direction:column;align-items:center;height:100%;padding:12px 0}
.sidebar-logo-btn{
  width:32px;height:32px;background:url(/dulus-bird.png) center/contain no-repeat;
  display:grid;place-items:center;cursor:pointer;border:none;flex-shrink:0;
  font-size:0;color:transparent;padding:0
}
.sidebar-collapsed .sidebar-logo-btn{margin-bottom:auto}
.sidebar-collapsed .sidebar-bottom-btn{
  width:32px;height:32px;display:flex;align-items:center;justify-content:center;
  background:transparent;border:1px solid var(--dim2);border-radius:var(--radius);
  color:var(--dim);cursor:pointer;transition:all .2s;margin-top:6px;padding:0
}
.sidebar-collapsed .sidebar-bottom-btn:hover{border-color:var(--accent);color:var(--accent);background:rgba(255,107,31,.1)}
.sidebar-expanded{display:flex;flex-direction:column;height:100%}
.sidebar-header{
  display:flex;align-items:center;gap:10px;padding:16px;border-bottom:1px solid rgba(255,255,255,.05);flex-shrink:0
}
.sidebar-header h2{font-family:var(--display);font-size:14px;letter-spacing:-.01em;color:var(--ink)}
.sidebar-search{padding:12px 16px;border-bottom:1px solid rgba(255,255,255,.05);flex-shrink:0}
.sidebar-search input{
  width:100%;background:var(--bg3);color:var(--ink);border:1px solid var(--dim2);padding:8px 12px;
  border-radius:var(--radius);font-family:var(--mono);font-size:12px;outline:none;transition:border-color .2s
}
.sidebar-search input:focus{border-color:var(--accent)}
.sidebar-search input::placeholder{color:var(--dim)}
#sessionList{flex:1;overflow-y:auto;padding:8px}
.session-item{
  display:flex;align-items:center;gap:10px;padding:10px 12px;border-radius:var(--radius);
  cursor:pointer;transition:background .15s;border-left:3px solid transparent;margin-bottom:2px;
  position:relative;user-select:none
}
.session-item:hover{background:rgba(255,255,255,.03)}
.session-item.active{
  background:rgba(255,107,31,.08);border-left-color:var(--accent)
}
.session-icon{
  width:28px;height:28px;min-width:28px;border-radius:var(--radius);background:var(--bg3);
  display:grid;place-items:center;font-size:12px;color:var(--dim);border:1px solid var(--dim2)
}
.session-item.active .session-icon{border-color:var(--accent);color:var(--accent)}
.session-info{flex:1;min-width:0;overflow:hidden}
.session-title{
  font-size:12px;color:var(--ink);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;
  font-weight:500;line-height:1.3
}
.session-time{font-size:10px;color:var(--dim);margin-top:2px}
.session-item.active .session-title{color:var(--accent2)}
.session-actions{
  display:flex;gap:2px;opacity:0;transition:opacity .15s
}
.session-item:hover .session-actions{opacity:1}
.session-actions button{
  width:24px;height:24px;display:flex;align-items:center;justify-content:center;
  background:transparent;border:none;color:var(--dim);cursor:pointer;border-radius:3px;transition:all .15s;
  padding:0
}
.session-actions button:hover{background:rgba(255,255,255,.08);color:var(--accent)}
.session-item.renaming .session-info{display:none}
.session-item.renaming .session-actions{display:none}
.session-rename-input{
  flex:1;background:var(--bg3);color:var(--ink);border:1px solid var(--accent);padding:6px 8px;
  border-radius:var(--radius);font-family:var(--mono);font-size:12px;outline:none
}
.sidebar-bottom{
  border-top:1px solid rgba(255,255,255,.05);padding:10px 16px;display:flex;gap:6px;flex-shrink:0
}
.sidebar-bottom button{
  flex:1;display:flex;align-items:center;justify-content:center;gap:6px;
  background:var(--bg3);color:var(--dim);border:1px solid var(--dim2);padding:8px 0;
  border-radius:var(--radius);cursor:pointer;font-family:var(--mono);font-size:11px;font-weight:700;
  letter-spacing:.05em;text-transform:uppercase;transition:all .2s
}
.sidebar-bottom button:hover{background:rgba(255,107,31,.1);border-color:var(--accent);color:var(--accent)}
.sidebar-bottom button svg{width:14px;height:14px}

/* ===== Main ===== */
#main{flex:1;display:flex;flex-direction:column;min-width:0;position:relative}

/* ===== Header ===== */
header{
  padding:0 24px;height:56px;background:rgba(10,10,10,.7);backdrop-filter:blur(16px);
  border-bottom:1px solid rgba(255,107,31,.12);display:flex;justify-content:space-between;
  align-items:center;gap:10px;position:relative;z-index:100
}
header .header-left{display:flex;align-items:center;gap:12px}
header h1{
  font-family:var(--display);font-size:18px;letter-spacing:-.02em;color:var(--ink);
  display:flex;align-items:center;gap:12px
}
header h1::before{
  content:"";width:32px;height:32px;background:url(/dulus-bird.png) center/contain no-repeat;
  display:inline-block;vertical-align:middle
}
header .model{font-size:11px;color:var(--dim)}
header a,header button{
  background:var(--bg2);color:var(--dim);border:1px solid var(--dim2);padding:6px 12px;
  border-radius:var(--radius);cursor:pointer;font-family:var(--mono);font-size:11px;font-weight:700;
  letter-spacing:.1em;text-transform:uppercase;text-decoration:none;transition:background .2s,border-color .2s,color .2s
}
header a:hover,header button:hover{background:rgba(255,107,31,.1);border-color:var(--accent);color:var(--accent)}
#sidebarToggle{
  display:none;width:36px;height:36px;align-items:center;justify-content:center;
  background:transparent;border:1px solid var(--dim2);border-radius:var(--radius);
  color:var(--dim);cursor:pointer;transition:all .2s;padding:0
}
#sidebarToggle:hover{border-color:var(--accent);color:var(--accent)}

/* ===== Log ===== */
#log{flex:1;overflow-y:auto;padding:24px 40px;display:flex;flex-direction:column;gap:16px;position:relative;z-index:1}
.msg{max-width:780px;padding:12px 16px;border-radius:6px;white-space:pre-wrap;word-wrap:break-word;font-size:14px}
.user{align-self:flex-end;background:rgba(255,107,31,.1);border:1px solid rgba(255,107,31,.25)}
.assistant{align-self:flex-start;background:var(--bg3);border:1px solid var(--dim2)}
.meta{font-size:10px;color:var(--dim);margin-top:6px}
.err{color:#ff5a6e;border-color:rgba(255,90,110,.4)!important}

/* ===== Input ===== */
#inputArea{
  display:flex;gap:10px;padding:16px 40px;background:var(--bg2);border-top:1px solid var(--dim2);
  position:relative;z-index:100
}
textarea{
  flex:1;background:var(--bg3);color:var(--ink);border:1px solid var(--dim2);padding:12px;
  border-radius:var(--radius);font-family:var(--mono);font-size:14px;resize:none;height:64px;
  outline:none;transition:border-color .2s
}
textarea:focus{border-color:var(--accent)}
textarea::placeholder{color:var(--dim)}
button.send{
  background:var(--accent);color:#000;border:none;padding:0 24px;border-radius:var(--radius);
  font-family:var(--mono);font-size:13px;font-weight:700;letter-spacing:.1em;text-transform:uppercase;
  cursor:pointer;transition:background .2s
}
button.send:hover{background:var(--accent2)}
button.send:disabled{opacity:.4;cursor:not-allowed}

/* ===== Extras ===== */
.think{
  font-size:11px;color:var(--dim);margin-top:8px;padding:8px 12px;border-left:2px solid var(--dim2);
  background:rgba(0,0,0,.2);white-space:pre-wrap
}
.tool{
  font-size:11px;color:#a39ca8;margin-top:8px;padding:8px 12px;border-left:2px solid var(--accent);
  background:rgba(255,107,31,.04);white-space:pre-wrap
}
.tool-result{
  font-size:11px;color:var(--dim);margin-top:4px;padding:8px 12px;border-left:2px solid var(--dim2);
  background:rgba(0,0,0,.2);white-space:pre-wrap;max-height:200px;overflow-y:auto
}
.perm{
  font-size:12px;color:#ffd166;margin-top:8px;padding:12px;border:1px solid rgba(255,209,102,.25);
  background:rgba(255,209,102,.1);display:flex;gap:10px;align-items:center;flex-wrap:wrap
}
.perm button{background:var(--bg3);color:var(--ink);border:1px solid var(--dim2);padding:6px 14px;border-radius:3px;cursor:pointer;font-weight:700}
.perm button.approve{background:var(--accent);color:#000;border:none}

/* ===== Context Menu ===== */
#ctxMenu{
  position:fixed;background:var(--bg4);border:1px solid var(--dim2);border-radius:var(--radius);
  padding:4px;z-index:9999;box-shadow:0 4px 16px rgba(0,0,0,.5);display:none;min-width:140px
}
#ctxMenu .ctx-item{
  display:flex;align-items:center;gap:8px;padding:8px 12px;border-radius:3px;
  cursor:pointer;font-size:12px;color:var(--ink);transition:background .15s;border:none;background:transparent;
  width:100%;font-family:var(--mono)
}
#ctxMenu .ctx-item:hover{background:rgba(255,107,31,.15);color:var(--accent2)}
#ctxMenu .ctx-item svg{width:14px;height:14px;color:var(--dim);flex-shrink:0}
#ctxMenu .ctx-item:hover svg{color:var(--accent)}
#ctxMenu .ctx-separator{height:1px;background:var(--dim2);margin:4px 0}

/* ===== Toast ===== */
#toastContainer{
  position:fixed;top:16px;right:16px;z-index:10000;display:flex;flex-direction:column;gap:8px;pointer-events:none
}
.toast{
  background:var(--bg4);border:1px solid var(--dim2);border-radius:var(--radius);padding:12px 16px;
  font-size:12px;color:var(--ink);box-shadow:0 4px 16px rgba(0,0,0,.5);
  display:flex;align-items:center;gap:10px;min-width:240px;max-width:340px;
  animation:toastIn .25s ease;pointer-events:auto;position:relative;overflow:hidden
}
.toast::before{content:"";position:absolute;left:0;top:0;bottom:0;width:3px;background:var(--dim)}
.toast.success::before{background:var(--green)}
.toast.error::before{background:var(--red)}
.toast.info::before{background:var(--accent)}
@keyframes toastIn{from{opacity:0;transform:translateX(40px)}to{opacity:1;transform:translateX(0)}}
@keyframes toastOut{from{opacity:1;transform:translateX(0)}to{opacity:0;transform:translateX(40px)}}
.toast svg{width:16px;height:16px;flex-shrink:0}
.toast.success svg{color:var(--green)}
.toast.error svg{color:var(--red)}
.toast.info svg{color:var(--accent)}

/* ===== Mobile ===== */
@media(max-width:768px){
  #sidebar{position:fixed;left:0;top:0;bottom:0;z-index:500;transform:translateX(-100%);transition:transform .3s ease;box-shadow:none}
  #sidebar.open{transform:translateX(0);box-shadow:4px 0 24px rgba(0,0,0,.5)}
  #sidebarOverlay{display:none;position:fixed;inset:0;background:rgba(0,0,0,.5);z-index:400;backdrop-filter:blur(2px)}
  #sidebarOverlay.open{display:block}
  #sidebarToggle{display:flex}
  #log{padding:16px 20px}
  .msg{max-width:92%}
  #inputArea{padding:16px 20px}
  header{padding:0 16px;height:52px}
}
@media(max-width:600px){
  header{height:auto;min-height:52px;padding:8px 16px;flex-wrap:wrap}
  header h1{font-size:15px}
  header h1::before{width:26px;height:26px;font-size:14px}
  header a,header button{font-size:10px;padding:5px 8px}
}
</style><style id="dynamic-theme"></style></head><body>
<div class="grid-bg"></div>
<div id="sidebarOverlay"></div>
<div id="app">
<!-- ===== SIDEBAR ===== -->
<nav id="sidebar">
  <div class="sidebar-collapsed">
    <button class="sidebar-logo-btn" onclick="toggleSidebar()" title="Expand">&#9650;</button>
    <button class="sidebar-bottom-btn" onclick="newChat()" title="New Chat">
      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
    </button>
    <button class="sidebar-bottom-btn" onclick="refreshSessions()" title="Refresh">
      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="23 4 23 10 17 10"/><polyline points="1 20 1 14 7 14"/><path d="M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15"/></svg>
    </button>
    <button class="sidebar-bottom-btn" onclick="toggleSidebar()" title="Expand" style="margin-top:auto">
      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M13 5l7 7-7 7"/><path d="M5 5l7 7-7 7"/></svg>
    </button>
  </div>
  <div class="sidebar-expanded">
    <div class="sidebar-header">
      <div class="sidebar-logo-btn" style="cursor:default">&#9650;</div>
      <h2>DULUS</h2>
    </div>
    <div class="sidebar-search">
      <input type="text" id="searchInput" placeholder="Search chats..." oninput="filterSessions()">
    </div>
    <div id="sessionList"></div>
    <div class="sidebar-bottom">
      <button onclick="newChat()">
        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
        <span>New</span>
      </button>
      <button onclick="refreshSessions()">
        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="23 4 23 10 17 10"/><polyline points="1 20 1 14 7 14"/><path d="M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15"/></svg>
      </button>
      <button onclick="toggleSidebar()" title="Collapse">
        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M11 17l-5-5 5-5"/><path d="M18 17l-5-5 5-5"/></svg>
      </button>
    </div>
  </div>
</nav>
<!-- ===== MAIN ===== -->
<div id="main">
<header>
  <div class="header-left">
    <button id="sidebarToggle" onclick="toggleSidebar()">
      <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><line x1="3" y1="6" x2="21" y2="6"/><line x1="3" y1="12" x2="21" y2="12"/><line x1="3" y1="18" x2="21" y2="18"/></svg>
    </button>
    <h1>DULUS WEBCHAT</h1>
  </div>
  <select id="personaSelect" style="background:var(--bg3);color:var(--dim);border:1px solid var(--dim2);padding:4px 10px;border-radius:var(--radius);font-family:var(--mono);font-size:12px;outline:none;cursor:pointer;flex:1;max-width:250px;margin:0 15px;text-align:center"></select>
  <div>
    <a href="/dashboard">Task Manager</a>
    <button onclick="clearChat()">clear</button>
  </div>
</header>
<div id="log"></div>
<div id="inputArea">
  <textarea id="inp" placeholder="Mensaje a Dulus... (Enter envia, Shift+Enter nueva linea)" autofocus></textarea>
  <button class="send" id="sendBtn">SEND</button>
</div>
</div>
</div>

<!-- Context Menu -->
<div id="ctxMenu">
  <button class="ctx-item" onclick="ctxRename()">
    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17 3a2.828 2.828 0 1 1 4 4L7.5 20.5 2 22l1.5-5.5L17 3z"/></svg>
    Rename
  </button>
  <div class="ctx-separator"></div>
  <button class="ctx-item" onclick="ctxDelete()">
    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="3 6 5 6 21 6"/><path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/></svg>
    Delete
  </button>
</div>

<!-- Toast Container -->
<div id="toastContainer"></div>
<script>
// ===== THEME SYNC =====
(function(){
  function ensureThemeStyle(){
    var el = document.getElementById('dynamic-theme');
    if(!el){
      el = document.createElement('style');
      el.id = 'dynamic-theme';
      document.head.appendChild(el);
    }
    return el;
  }
  async function applyTheme(name){
    name = name || localStorage.getItem('dulus-theme') || 'dulus';
    try{
      var res = await fetch('/api/themes/' + encodeURIComponent(name) + '/css');
      var css = await res.text();
      if(css){
        ensureThemeStyle().textContent = css;
        localStorage.setItem('dulus-theme', name);
      }
    }catch(e){}
  }
  applyTheme();
})();

// ===== STATE =====
const ACTIVE_KEY = 'dulus_active_session';
const SIDEBAR_COLLAPSED_KEY = 'dulus_sidebar_collapsed';
const DEFAULT_SESSION_ID = 'default';

let sessions = [];
let activeSessionId = DEFAULT_SESSION_ID;
let ctxTargetId = null;
let isMobile = window.innerWidth < 768;
let renamingId = null;

// ===== TOAST =====
function showToast(message, type){
  var c = document.getElementById('toastContainer');
  var t = document.createElement('div');
  t.className = 'toast ' + (type || 'info');
  var icon = '';
  if(type === 'success'){
    icon = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"/><polyline points="22 4 12 14.01 9 11.01"/></svg>';
  }else if(type === 'error'){
    icon = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="15" y1="9" x2="9" y2="15"/><line x1="9" y1="9" x2="15" y2="15"/></svg>';
  }else{
    icon = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>';
  }
  t.innerHTML = icon + '<span>' + escapeHtml(message) + '</span>';
  c.appendChild(t);
  setTimeout(function(){ t.classList.add('exit'); setTimeout(function(){ t.remove(); }, 250); }, 3000);
}

// ===== UTILS =====
function escapeHtml(t){
  var d = document.createElement('div');
  d.textContent = t;
  return d.innerHTML;
}
function genId(){ return Date.now().toString(36) + Math.random().toString(36).slice(2, 6); }
function formatTime(ts){
  var d = new Date(ts);
  var now = new Date();
  if(d.toDateString() === now.toDateString()) return d.toLocaleTimeString([], {hour: '2-digit', minute: '2-digit'});
  var yesterday = new Date(); yesterday.setDate(yesterday.getDate() - 1);
  if(d.toDateString() === yesterday.toDateString()) return 'Yesterday';
  return d.toLocaleDateString([], {month: 'short', day: 'numeric'});
}

// ===== SESSION STORAGE =====
function loadSessions(){
  // Server is the source of truth; localStorage no longer caches session data
  fetch('/api/sessions')
    .then(function(r){ return r.json(); })
    .then(function(data){
      if(data && data.length){
        sessions = data.map(function(s){
          return {
            id: s.id,
            title: s.title,
            timestamp: s.saved_at ? new Date(s.saved_at).getTime() : Date.now(),
            messages: s.messages || []
          };
        });
        var savedActive = localStorage.getItem(ACTIVE_KEY);
        if(savedActive && sessions.some(function(s){ return s.id === savedActive; })){
          activeSessionId = savedActive;
        }else{
          activeSessionId = sessions[0].id;
        }
        renderSessions();
        selectSession(activeSessionId);
        return;
      }
      // Server empty — create a default session
      sessions = [{id: DEFAULT_SESSION_ID, title: 'Chat', timestamp: Date.now(), messages: []}];
      activeSessionId = DEFAULT_SESSION_ID;
      renderSessions();
      selectSession(activeSessionId);
    })
    .catch(function(e){
      // Network down — start with a blank default session
      sessions = [{id: DEFAULT_SESSION_ID, title: 'Chat', timestamp: Date.now(), messages: []}];
      activeSessionId = DEFAULT_SESSION_ID;
      renderSessions();
    });
}
function saveActive(){ localStorage.setItem(ACTIVE_KEY, activeSessionId); }
function getActiveSession(){
  return sessions.find(function(s){ return s.id === activeSessionId; }) || sessions[0];
}
function updateActiveMessages(msgs){
  var s = getActiveSession();
  if(!s) return;
  // Only bump the timestamp when NEW messages actually arrived. Otherwise
  // every F5 / 5s poll would re-stamp the sidebar entry to "now" even
  // though the conversation didn't change, making it impossible to tell
  // which chats had real activity. Compare counts AND last-message text
  // because /clear keeps the same count but flips content.
  var prev = s.messages || [];
  var changed = false;
  if(msgs.length !== prev.length) changed = true;
  else if(msgs.length > 0){
    var a = msgs[msgs.length - 1] || {};
    var b = prev[prev.length - 1] || {};
    var ac = typeof a.content === 'string' ? a.content : JSON.stringify(a.content || '');
    var bc = typeof b.content === 'string' ? b.content : JSON.stringify(b.content || '');
    if(a.role !== b.role || ac !== bc) changed = true;
  }
  s.messages = msgs;
  if(changed) s.timestamp = Date.now();
}
function updateSessionTitleFromMessages(){
  var s = getActiveSession();
  if(!s) return;
  var firstUser = s.messages.find(function(m){ return m.role === 'user'; });
  if(firstUser && s.title === 'Chat'){
    var txt = (typeof firstUser.content === 'string' ? firstUser.content : '').slice(0, 40);
    if(txt) s.title = txt;
    renderSessions();
  }
}

// ===== SIDEBAR UI =====
function renderSessions(){
  var list = document.getElementById('sessionList');
  var q = document.getElementById('searchInput').value.toLowerCase();
  var filtered = sessions.filter(function(s){ return !q || s.title.toLowerCase().indexOf(q) >= 0; });
  if(!filtered.length){
    list.innerHTML = '<div style="padding:20px;text-align:center;color:var(--dim);font-size:11px">No chats found</div>';
    return;
  }
  var html = '';
  for(var i = 0; i < filtered.length; i++){
    var s = filtered[i];
    var isActive = s.id === activeSessionId;
    var isRenaming = s.id === renamingId;
    if(isRenaming){
      html += '<div class="session-item active renaming" data-id="' + s.id + '">' +
        '<div class="session-icon">&#9650;</div>' +
        '<input class="session-rename-input" value="' + escapeHtml(s.title) + '" ' +
        'onkeydown="renameKey(event,\'' + s.id + '\')" onblur="finishRename(\'' + s.id + '\')" id="rename-' + s.id + '">' +
        '</div>';
      continue;
    }
    html += '<div class="session-item ' + (isActive ? 'active' : '') + '" data-id="' + s.id + '" ' +
      'onclick="selectSession(\'' + s.id + '\')" oncontextmenu="showCtx(event,\'' + s.id + '\')">' +
      '<div class="session-icon">&#9650;</div>' +
      '<div class="session-info">' +
        '<div class="session-title">' + escapeHtml(s.title) + '</div>' +
        '<div class="session-time">' + formatTime(s.timestamp) + '</div>' +
      '</div>' +
      '<div class="session-actions" onclick="event.stopPropagation()">' +
        '<button onclick="startRename(\'' + s.id + '\')" title="Rename">' +
          '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" width="13" height="13"><path d="M17 3a2.828 2.828 0 1 1 4 4L7.5 20.5 2 22l1.5-5.5L17 3z"/></svg>' +
        '</button>' +
        '<button onclick="deleteSession(\'' + s.id + '\')" title="Delete">' +
          '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" width="13" height="13"><polyline points="3 6 5 6 21 6"/><path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/></svg>' +
        '</button>' +
      '</div>' +
    '</div>';
  }
  list.innerHTML = html;
  if(renamingId){
    var inp = document.getElementById('rename-' + renamingId);
    if(inp){ inp.focus(); inp.select(); }
  }
}

function startRename(id){
  renamingId = id; renderSessions();
}
function finishRename(id){
  var inp = document.getElementById('rename-' + id);
  if(inp){
    var v = inp.value.trim();
    if(v){
      var s = sessions.find(function(x){ return x.id === id; });
      if(s){ s.title = v; }
    }
  }
  renamingId = null; renderSessions();
}
function renameKey(e, id){
  if(e.key === 'Enter'){ e.preventDefault(); finishRename(id); }
  else if(e.key === 'Escape'){ renamingId = null; renderSessions(); }
}
function filterSessions(){ renderSessions(); }

async function selectSession(id){
  activeSessionId = id; saveActive();
  renderSessions();
  var s = getActiveSession();
  if(s && s.messages){
    log.innerHTML = '';
    currentAssistant = null;
    currentText = '';
    for(var i = 0; i < s.messages.length; i++){
      var m = s.messages[i];
      if(m.role === 'user') add('user', m.content);
      else if(m.role === 'assistant'){
        var text = typeof m.content === 'string' ? m.content : '';
        if(Array.isArray(m.content)){
          var tc = m.content.find(function(c){ return c.type === 'text'; });
          if(tc) text = tc.text;
        }
        if(text) add('assistant', text);
      }
    }
  }
  closeMobileSidebar();
  // Sync server state with this session so the backend talks to the right conversation
  try{
    await fetch('/api/session/load', {
      method: 'POST',
      headers: {'Content-Type': 'application/json'},
      body: JSON.stringify({messages: s ? s.messages : []})
    });
  }catch(_){}
}

function newChat(){
  fetch('/clear', {method: 'POST'}).then(function(){
    var newS = {id: genId(), title: 'Chat', timestamp: Date.now(), messages: []};
    sessions.unshift(newS); activeSessionId = newS.id;
    saveActive();
    log.innerHTML = '';
    currentAssistant = null;
    currentText = '';
    renderSessions();
    closeMobileSidebar();
    showToast('New chat started', 'success');
    // Sync new session id with server so backend knows we switched
    fetch('/api/session/load', {
      method: 'POST',
      headers: {'Content-Type': 'application/json'},
      body: JSON.stringify({messages: [], session_id: activeSessionId})
    }).catch(function(){});
  });
}

function deleteSession(id){
  var s = sessions.find(function(x){ return x.id === id; });
  if(!s) return;
  if(!confirm('Delete "' + s.title + '"?')) return;
  fetch('/api/sessions/' + encodeURIComponent(id), {method: 'DELETE'}).catch(function(){});
  sessions = sessions.filter(function(x){ return x.id !== id; });
  if(sessions.length === 0){
    var ns = {id: genId(), title: 'Chat', timestamp: Date.now(), messages: []};
    sessions.push(ns); activeSessionId = ns.id;
  }else if(activeSessionId === id){
    activeSessionId = sessions[0].id;
  }
  saveActive();
  selectSession(activeSessionId);
  renderSessions();
  showToast('Chat deleted', 'info');
}

function refreshSessions(){
  syncWithServer(function(){
    showToast('Chats refreshed', 'success');
  });
}

// ===== CONTEXT MENU =====
function showCtx(e, id){
  e.preventDefault();
  ctxTargetId = id;
  var menu = document.getElementById('ctxMenu');
  menu.style.display = 'block';
  var x = e.clientX, y = e.clientY;
  if(x + 160 > window.innerWidth) x = window.innerWidth - 170;
  if(y + 80 > window.innerHeight) y = window.innerHeight - 90;
  menu.style.left = x + 'px';
  menu.style.top = y + 'px';
}
function hideCtx(){ document.getElementById('ctxMenu').style.display = 'none'; ctxTargetId = null; }
function ctxRename(){ if(ctxTargetId) startRename(ctxTargetId); hideCtx(); }
function ctxDelete(){ if(ctxTargetId) deleteSession(ctxTargetId); hideCtx(); }
document.addEventListener('click', function(e){
  if(!e.target.closest('#ctxMenu')) hideCtx();
});

// ===== SIDEBAR TOGGLE =====
function toggleSidebar(){
  if(window.innerWidth < 768){
    var sb = document.getElementById('sidebar');
    if(sb.classList.contains('open')) closeMobileSidebar();
    else openMobileSidebar();
  }else{
    var sb = document.getElementById('sidebar');
    sb.classList.toggle('collapsed');
    localStorage.setItem(SIDEBAR_COLLAPSED_KEY, sb.classList.contains('collapsed') ? '1' : '0');
  }
}
function initSidebar(){
  var collapsed = localStorage.getItem(SIDEBAR_COLLAPSED_KEY);
  if(collapsed === '1') document.getElementById('sidebar').classList.add('collapsed');
}

// ===== MOBILE SIDEBAR =====
function openMobileSidebar(){
  document.getElementById('sidebar').classList.add('open');
  document.getElementById('sidebarOverlay').classList.add('open');
}
function closeMobileSidebar(){
  if(window.innerWidth >= 768) return;
  document.getElementById('sidebar').classList.remove('open');
  document.getElementById('sidebarOverlay').classList.remove('open');
}
document.getElementById('sidebarOverlay').addEventListener('click', closeMobileSidebar);

// ===== CHAT FUNCTIONS =====
var log = document.getElementById('log');
var inp = document.getElementById('inp');
var btn = document.getElementById('sendBtn');
var currentAssistant = null;
var currentText = '';

function add(role, text, extra){
  var d = document.createElement('div');
  d.className = 'msg ' + role;
  d.textContent = text;
  if(extra){
    var m = document.createElement('div');
    m.className = 'meta';
    m.textContent = extra;
    d.appendChild(m);
  }
  log.appendChild(d);
  log.scrollTop = log.scrollHeight;
  return d;
}

function ensureAssistant(){
  if(!currentAssistant){
    currentAssistant = add('assistant', '');
  }
  return currentAssistant;
}

function appendText(text){
  ensureAssistant();
  currentText += text;
  currentAssistant.textContent = currentText;
  log.scrollTop = log.scrollHeight;
}

function appendThinking(text){
  ensureAssistant();
  var th = currentAssistant.querySelector('.think');
  if(!th){
    th = document.createElement('div');
    th.className = 'think';
    th.textContent = '[thinking]';
    currentAssistant.appendChild(th);
  }
  th.textContent += text;
  log.scrollTop = log.scrollHeight;
}

function startTool(name, inputs){
  ensureAssistant();
  var t = document.createElement('div');
  t.className = 'tool';
  t.textContent = '\ud83d\udd27 ' + name + '\n' + JSON.stringify(inputs, null, 2);
  currentAssistant.appendChild(t);
  log.scrollTop = log.scrollHeight;
}

function endTool(name, result, permitted){
  ensureAssistant();
  var r = document.createElement('div');
  r.className = 'tool-result';
  r.textContent = (permitted ? '\u2705' : '\u274c') + ' ' + result;
  currentAssistant.appendChild(r);
  log.scrollTop = log.scrollHeight;
}

function showPermission(id, desc){
  ensureAssistant();
  var p = document.createElement('div');
  p.className = 'perm';
  p.innerHTML = '<span>\u26d4 ' + desc + '</span>';
  var yes = document.createElement('button');
  yes.textContent = 'Approve';
  yes.className = 'approve';
  yes.onclick = function(){ sendPermission(id, true); p.remove(); };
  var no = document.createElement('button');
  no.textContent = 'Deny';
  no.onclick = function(){ sendPermission(id, false); p.remove(); };
  p.appendChild(yes);
  p.appendChild(no);
  currentAssistant.appendChild(p);
  log.scrollTop = log.scrollHeight;
}

async function sendPermission(id, granted){
  await fetch('/permission', {
    method: 'POST',
    headers: {'Content-Type': 'application/json'},
    body: JSON.stringify({id: id, granted: granted})
  });
}

async function sendMessage(){
  var t = inp.value.trim();
  if(!t) return;
  add('user', t);
  inp.value = '';
  btn.disabled = true;
  currentAssistant = null;
  currentText = '';
  try{
    var resp = await fetch('/chat', {
      method: 'POST',
      headers: {'Content-Type': 'application/json'},
      body: JSON.stringify({message: t})
    });
    var reader = resp.body.getReader();
    var decoder = new TextDecoder();
    var buf = '';
    while(true){
      var chunk = await reader.read();
      if(chunk.done) break;
      buf += decoder.decode(chunk.value, {stream: true});
      var lines = buf.split('\n');
      buf = lines.pop();
      for(var i = 0; i < lines.length; i++){
        var line = lines[i];
        if(!line.startsWith('data: ')) continue;
        var d;
        try{ d = JSON.parse(line.slice(6)); }catch(_){ continue; }
        if(d.type === 'text') appendText(d.text);
        else if(d.type === 'thinking') appendThinking(d.text);
        else if(d.type === 'tool_start') startTool(d.name, d.inputs);
        else if(d.type === 'tool_end') endTool(d.name, d.result, d.permitted);
        else if(d.type === 'permission') showPermission(d.id, d.description);
        else if(d.type === 'turn_done'){
          var meta = document.createElement('div');
          meta.className = 'meta';
          var txt = 'in:' + d.in + ' out:' + d.out;
          if(d.cache_read) txt += ' [cache hit: ' + d.cache_read + ']';
          if(d.cache_write) txt += ' [cache new: ' + d.cache_write + ']';
          meta.textContent = txt;
          ensureAssistant().appendChild(meta);
        }
        else if(d.type === 'error') appendText('\n[error] ' + d.message);
      }
    }
  }catch(err){
    add('assistant', '[network] ' + err, '').classList.add('err');
  }finally{
    btn.disabled = false;
    inp.focus();
    syncWithServer();
  }
}

async function clearChat(){
  await fetch('/clear', {method: 'POST'});
  log.innerHTML = '';
  currentAssistant = null;
  currentText = '';
  var s = getActiveSession();
  if(s){ s.messages = []; s.timestamp = Date.now(); }
  showToast('Chat cleared', 'info');
}

async function syncWithServer(cb){
  if(btn.disabled) return;
  try{
    var rh = await fetch('/api/chat/history');
    if(rh.ok){
      var ht = await rh.json();
      var s = getActiveSession();
      var localCount = s ? s.messages.length : 0;
      // Only overwrite local session if server has more messages (new turn completed)
      if(ht.messages.length > localCount){
        updateActiveMessages(ht.messages);
        updateSessionTitleFromMessages();
        var wasNearBottom = log.scrollTop + log.clientHeight >= log.scrollHeight - 50;
        log.innerHTML = '';
        currentAssistant = null;
        currentText = '';
        for(var i = 0; i < ht.messages.length; i++){
          var m = ht.messages[i];
          if(m.role === 'user') add('user', m.content);
          else if(m.role === 'assistant'){
            var text = typeof m.content === 'string' ? m.content : '';
            if(Array.isArray(m.content)){
              var tc = m.content.find(function(c){ return c.type === 'text'; });
              if(tc) text = tc.text;
            }
            if(text) add('assistant', text);
          }
        }
        if(wasNearBottom) log.scrollTop = log.scrollHeight;
        renderSessions();
      }
    }
    var rp = await fetch('/api/personas');
    if(rp.ok){
      var jp = await rp.json();
      var sel = document.getElementById('personaSelect');
      var activeKeys = Object.keys(jp.active || {});
      sel.innerHTML = jp.personas.map(function(p){
        var isSelected = activeKeys.indexOf(p.name) >= 0 ? 'selected' : '';
        return '<option value="' + p.name + '" ' + isSelected + '>' + p.name + ' (' + p.role + ')</option>';
      }).join('');
      sel.onchange = async function(e){
        await fetch('/api/personas/activate', {
          method: 'POST',
          headers: {'Content-Type': 'application/json'},
          body: JSON.stringify({id: e.target.value})
        });
      };
    }
  }catch(_){}
  // Persist current session to server disk
  fetch('/api/sessions/save', {
    method: 'POST',
    headers: {'Content-Type': 'application/json'},
    body: JSON.stringify({session_id: activeSessionId})
  }).catch(function(){});
  if(cb) cb();
}

async function loadHist(){ return syncWithServer(); }

inp.addEventListener('keydown', function(e){
  if(e.key === 'Enter' && !e.shiftKey){
    e.preventDefault();
    sendMessage();
  }
});
btn.addEventListener('click', sendMessage);

// ===== MOBILE =====
window.addEventListener('resize', function(){
  var nowMobile = window.innerWidth < 768;
  if(nowMobile !== isMobile){
    isMobile = nowMobile;
    if(!isMobile) closeMobileSidebar();
  }
});

// ===== INIT =====
loadSessions();
initSidebar();
renderSessions();
loadHist();
// Ensure server state matches the active session on startup
(function(){
  var s = getActiveSession();
  if(s){
    fetch('/api/session/load', {
      method: 'POST',
      headers: {'Content-Type': 'application/json'},
      body: JSON.stringify({messages: s.messages || []})
    }).catch(function(){});
  }
})();
setInterval(function(){ syncWithServer(); }, 5000);
</script>
</body></html>"""

    @app.route("/")
    def home() -> ResponseReturnValue:
        if WEBCHAT_UI_DIR.exists() and (WEBCHAT_UI_DIR / "index.html").exists():
            return send_from_directory(WEBCHAT_UI_DIR, "index.html")
        # Fallback to the legacy embedded chat page if webchat_ui is missing.
        return Response(CHAT_PAGE, mimetype="text/html")

    # Favicon — the Dulus palmchat (cigua palmera) logo. Lives at repo root
    # in dev, but in an installed wheel only docs/dulus-bird.png ships (it's
    # the asset GitHub Pages also serves). Try both.
    _here = Path(__file__).parent
    _DULUS_BIRD = next(
        (p for p in (_here / "dulus-bird.png", _here / "docs" / "dulus-bird.png") if p.exists()),
        _here / "dulus-bird.png",  # 404 fallback path
    )

    @app.route("/favicon.ico")
    @app.route("/dulus-bird.png")
    def dulus_bird() -> ResponseReturnValue:
        if _DULUS_BIRD.exists():
            return send_from_directory(_DULUS_BIRD.parent, _DULUS_BIRD.name,
                                       mimetype="image/png")
        return Response(status=404)

    # The Mini OS frontend (`/sandbox/`, served from the bundled sandbox/dist
    # tree) is not part of the public runtime, so the static routes and their
    # sandbox_bootstrap resolver are gone. The filesystem/exec API below is a
    # separate, still-supported WebChat surface: it operates on the project
    # root rather than on the removed asset bundle.

    # ── Workspace Filesystem API ──────────────────────────────────────────────
    import os as _os

    @app.route("/api/sandbox/fs/list", methods=["GET"])
    def sandbox_fs_list():
        """List directory contents. ?path= relative to project root."""
        rel = request.args.get("path", "/")
        base = Path(__file__).parent
        target = (base / rel.lstrip("/")).resolve()
        # Safety: must stay within project root
        try:
            target.relative_to(base)
        except ValueError:
            return jsonify(error="Access denied"), 403
        if not target.exists():
            return jsonify(error="Not found"), 404
        if target.is_file():
            return jsonify([{"name": target.name, "type": "file", "size": target.stat().st_size}])
        entries = []
        for item in sorted(target.iterdir(), key=lambda p: (p.is_file(), p.name.lower())):
            try:
                stat = item.stat()
                entries.append({
                    "name": item.name,
                    "type": "folder" if item.is_dir() else "file",
                    "size": stat.st_size if item.is_file() else 0,
                    "modified": stat.st_mtime,
                })
            except OSError:
                pass
        return jsonify(entries)

    @app.route("/api/sandbox/fs/read", methods=["GET"])
    def sandbox_fs_read():
        """Read a file. ?path= relative to project root."""
        rel = request.args.get("path", "")
        if not rel:
            return jsonify(error="path required"), 400
        base = Path(__file__).parent
        target = (base / rel.lstrip("/")).resolve()
        try:
            target.relative_to(base)
        except ValueError:
            return jsonify(error="Access denied"), 403
        if not target.exists() or not target.is_file():
            return jsonify(error="Not found"), 404
        try:
            content = target.read_text(encoding="utf-8", errors="replace")
            return jsonify({"path": rel, "content": content})
        except Exception as e:
            return jsonify(error=str(e)), 500

    @app.route("/api/sandbox/fs/write", methods=["POST"])
    def sandbox_fs_write():
        """Write a file. Body: {path, content}."""
        body = request.get_json(silent=True) or {}
        rel = body.get("path", "")
        content = body.get("content", "")
        if not rel:
            return jsonify(error="path required"), 400
        base = Path(__file__).parent
        target = (base / rel.lstrip("/")).resolve()
        try:
            target.relative_to(base)
        except ValueError:
            return jsonify(error="Access denied"), 403
        try:
            target.parent.mkdir(parents=True, exist_ok=True)
            target.write_text(content, encoding="utf-8")
            return jsonify(ok=True, path=rel)
        except Exception as e:
            return jsonify(error=str(e)), 500

    @app.route("/api/sandbox/exec", methods=["POST"])
    def sandbox_exec():
        """Execute a command string through the Dulus agent (streaming SSE)."""
        body = request.get_json(silent=True) or {}
        cmd = (body.get("command") or "").strip()
        if not cmd:
            return jsonify(error="command required"), 400
        # Run via agent mirror so it has full tool access
        def generate():
            q: queue.Queue = queue.Queue(maxsize=512)
            exc_holder: list[Any] = [None]
            def producer():
                try:
                    for ev in _run_agent_mirror(cmd):
                        result = _event_to_dict(ev)
                        if result is None:
                            continue
                        if isinstance(result, tuple):
                            payload, evt = result
                            # auto-approve in exec mode
                            perm_req = _PENDING_PERMISSIONS.get(payload["id"])
                            if perm_req:
                                perm_req[0].granted = True
                            evt.set()
                            continue
                        q.put(result)
                except Exception as e:
                    exc_holder[0] = e
                finally:
                    q.put(None)
            t = threading.Thread(target=producer, daemon=True)
            t.start()
            yield 'data: {"type":"start"}\n\n'
            while True:
                item = q.get()
                if item is None:
                    break
                yield f"data: {json.dumps(item)}\n\n"
            if exc_holder[0]:
                err = exc_holder[0]
                yield f'data: {json.dumps({"type":"error","message":str(err)})}\n\n'
            yield 'data: {"type":"done"}\n\n'
        return Response(stream_with_context(generate()), mimetype="text/event-stream")


    @app.route("/state")
    def state_endpoint() -> ResponseReturnValue:
        with _LOCK:
            hist = [dict(m) for m in (STATE.messages if STATE else [])]
            model = CONFIG.get("model", "?") if CONFIG else "?"
        return jsonify(model=model, history=hist)

    @app.route("/clear", methods=["POST"])
    def clear() -> ResponseReturnValue:
        with _LOCK:
            if STATE:
                STATE.messages.clear()
            if CONFIG:
                # Allow next turn to re-seed gold display copies
                CONFIG.pop("_gold_preloaded", None)
                CONFIG.pop("_session_id", None)
        return jsonify(ok=True)

    @app.route("/shutdown", methods=["POST"])
    def shutdown() -> ResponseReturnValue:
        return jsonify(ok=True)

    @app.route("/permission", methods=["POST"])
    def permission() -> ResponseReturnValue:
        body = request.get_json(silent=True) or {}
        pid = str(body.get("id") or "")
        granted = body.get("granted", False)
        with _LOCK:
            item = _PENDING_PERMISSIONS.get(pid)
        if item is None:
            return jsonify(error="not found"), 404
        req, evt = item
        req.granted = bool(granted)
        evt.set()
        return jsonify(ok=True)

    @app.route("/question", methods=["POST"])
    def question() -> ResponseReturnValue:
        """Answer a pending AskUserQuestion (mirrors the /permission flow)."""
        body = request.get_json(silent=True) or {}
        qid = str(body.get("id") or "")
        answer = (body.get("answer") or "").strip()
        with _LOCK:
            entry = _PENDING_QUESTIONS.pop(qid, None)
        if entry is None:
            return jsonify(error="not found"), 404
        try:
            entry["result"].append(answer or "(no answer)")
            entry["event"].set()
        except Exception as e:
            return jsonify(error=str(e)), 500
        return jsonify(ok=True)

    @app.route("/chat/stop", methods=["POST"])
    def chat_stop() -> ResponseReturnValue:
        body = request.get_json(silent=True) or {}
        run_id = (body.get("run_id") or "").strip()
        if not run_id:
            return jsonify(ok=False, error="missing run_id"), 400
        with _WEBCHAT_STOP_EVENTS_LOCK:
            stop_evt = _WEBCHAT_STOP_EVENTS.get(run_id)
        if stop_evt is None:
            return jsonify(ok=False, error="chat run not active"), 404
        stop_evt.set()

        # Release any interaction currently blocking the agent turn. The
        # WebChat is single-user today, so pending prompts belong to the active
        # run and can be safely declined when Stop is pressed.
        with _LOCK:
            for pid, (permission, evt) in list(_PENDING_PERMISSIONS.items()):
                permission.granted = False
                evt.set()
                _PENDING_PERMISSIONS.pop(pid, None)
            for qid, entry in list(_PENDING_QUESTIONS.items()):
                try:
                    entry["result"].append("(stopped by user)")
                    entry["event"].set()
                except Exception:
                    pass
                _PENDING_QUESTIONS.pop(qid, None)
        return jsonify(ok=True, run_id=run_id)

    @app.route("/chat", methods=["POST"])
    def chat() -> ResponseReturnValue:
        body = request.get_json(silent=True) or {}
        msg = (body.get("message") or "").strip()
        run_id = (body.get("run_id") or str(uuid.uuid4())).strip()
        if not msg:
            return jsonify(error="empty message"), 400

        # Slash commands: same behavior as the Telegram bridge —
        # run via REPL's _handle_slash_callback, capture stdout,
        # stream output back as text events.
        if msg.startswith("/") and len(msg) > 1:
            def generate_slash():
                yield 'data: {"type":"start"}\n\n'
                try:
                    output, assistant_reply = _run_slash_command(msg)
                    if output:
                        yield f"data: {json.dumps({'type':'text','text':output})}\n\n"
                    if assistant_reply:
                        sep = "\n\n" if output else ""
                        yield f"data: {json.dumps({'type':'text','text':sep + assistant_reply})}\n\n"
                except Exception as e:
                    yield f'data: {json.dumps({"type":"error","message":f"{type(e).__name__}: {e}"})}\n\n'
                yield 'data: {"type":"done"}\n\n'
            return Response(
                stream_with_context(generate_slash()),
                mimetype="text/event-stream",
            )

        def generate():
            q: queue.Queue = queue.Queue(maxsize=512)
            exc_holder: list[Any] = [None]
            stop_watcher = threading.Event()
            stop_evt = threading.Event()
            with _WEBCHAT_STOP_EVENTS_LOCK:
                previous = _WEBCHAT_STOP_EVENTS.get(run_id)
                if previous is not None:
                    previous.set()
                _WEBCHAT_STOP_EVENTS[run_id] = stop_evt

            def producer():
                try:
                    for ev in _run_agent_mirror(msg, cancel_check=stop_evt.is_set):
                        if stop_evt.is_set():
                            break
                        result = _event_to_dict(ev)
                        if result is None:
                            continue
                        if isinstance(result, tuple):
                            payload, evt = result
                            q.put(payload)
                            while not evt.wait(timeout=0.1):
                                if stop_evt.is_set():
                                    evt.set()
                                    break
                            _PENDING_PERMISSIONS.pop(payload.get("id"), None)
                            if stop_evt.is_set():
                                break
                            continue
                        q.put(result)
                except Exception as e:
                    exc_holder[0] = e
                finally:
                    stop_watcher.set()
                    if stop_evt.is_set():
                        q.put({"type": "stopped"})
                    with _WEBCHAT_STOP_EVENTS_LOCK:
                        if _WEBCHAT_STOP_EVENTS.get(run_id) is stop_evt:
                            _WEBCHAT_STOP_EVENTS.pop(run_id, None)
                    q.put(None)

            t = threading.Thread(target=producer, daemon=True)
            t.start()
            # Surface AskUserQuestion prompts to the UI (same UX as permissions)
            _start_question_watcher(q, stop_watcher)

            yield 'data: {"type":"start"}\n\n'

            while True:
                item = q.get()
                if item is None:
                    break
                yield f"data: {json.dumps(item)}\n\n"

            if exc_holder[0]:
                err = exc_holder[0]
                yield f'data: {json.dumps({"type":"error","message":f"{type(err).__name__}: {err}"})}\n\n'

            yield 'data: {"type":"done"}\n\n'

        return Response(
            stream_with_context(generate()),
            mimetype="text/event-stream",
        )

    # ── DULUS 2 UNIFIED ENDPOINTS ──

    @app.route("/api/events")
    def api_events():
        def generate():
            q = queue.Queue(maxsize=100)
            _add_sse_client(q)
            yield f"event: connected\ndata: {json.dumps({'message':'Dulus SSE active'})}\n\n"
            try:
                while True:
                    try:
                        msg = q.get(timeout=30)
                        yield msg
                    except queue.Empty:
                        yield ":\n\n"
            finally:
                _remove_sse_client(q)
        return Response(stream_with_context(generate()), mimetype="text/event-stream")

    @app.route("/api/health")
    def api_health():
        return jsonify({"status": "ok", "agent": "Dulus", "mode": "proactive", "version": "2026.04.26"})

    @app.route("/api/tasks", methods=["GET"])
    def get_api_tasks():
        tasks = task_list()
        return jsonify([t.to_dict() for t in tasks])

    @app.route("/api/context", methods=["GET"])
    def api_context():
        return jsonify(build_context())

    @app.route("/api/context/compact", methods=["GET"])
    def api_context_compact():
        return Response(get_compact_context(), mimetype="text/plain")

    @app.route("/api/chat/history", methods=["GET"])
    def api_chat_history():
        msgs = []
        if STATE and hasattr(STATE, "messages"):
            for m in STATE.messages:
                msgs.append({
                    "role": m.get("role", ""),
                    "content": m.get("content", ""),
                    "thinking": m.get("thinking", ""),
                    "tool_calls": m.get("tool_calls", []),
                    "name": m.get("name", ""),
                    "tool_call_id": m.get("tool_call_id", ""),
                })
        sid = CONFIG.get("_session_id", "default") if CONFIG else "default"
        return jsonify({"messages": msgs, "session_id": sid})

    @app.route("/api/session/load", methods=["POST"])
    def api_session_load():
        body = request.get_json(silent=True) or {}
        msgs = body.get("messages", [])
        sid = body.get("session_id")
        global _PENDING_HISTORY, _PENDING_SESSION_ID
        with _LOCK:
            active_sid = CONFIG.get("_session_id") if CONFIG else None
            if sid and active_sid and sid == active_sid:
                pass  # Do not overwrite live memory with stale disk/frontend data
            else:
                _PENDING_HISTORY = msgs
                _PENDING_SESSION_ID = sid
                if CONFIG and sid:
                    CONFIG["_session_id"] = sid
                if STATE:
                    STATE.messages.clear()
                    for m in msgs:
                        STATE.messages.append(m)
                if CONFIG:
                    # Allow next turn to re-seed gold display copies
                    CONFIG.pop("_gold_preloaded", None)
        return jsonify(ok=True)

    @app.route("/api/sessions", methods=["GET"])
    def api_sessions_list():
        return jsonify(scan_sessions())

    @app.route("/api/sessions/save", methods=["POST"])
    def api_sessions_save():
        body = request.get_json(silent=True) or {}
        sid = body.get("session_id") or "default"
        with _LOCK:
            if STATE and CONFIG:
                save_session(STATE, CONFIG, sid)
        return jsonify(ok=True)

    @app.route("/api/sessions/<sid>", methods=["DELETE"])
    def api_sessions_delete(sid):
        _delete_session_disk(sid)
        return jsonify(ok=True)

    @app.route("/api/smart-context", methods=["GET"])
    def api_smart_context():
        return jsonify(build_smart_context())

    @app.route("/api/smart-context/compact", methods=["POST"])
    def api_smart_context_compact():
        from backend.context import force_compaction
        return jsonify(force_compaction())

    @app.route("/api/quick-message", methods=["POST"])
    def api_quick_message():
        body = request.get_json(silent=True) or {}
        msg = (body.get("message") or "").strip()
        if not msg:
            return jsonify(error="empty message"), 400
        
        def run_blind():
            try:
                for event in _run_agent_mirror(msg):
                    from agent import PermissionRequest
                    if isinstance(event, PermissionRequest):
                        # Auto-approve silently for background quick messages
                        event.granted = True
            except Exception as e:
                import traceback
                traceback.print_exc()

        threading.Thread(target=run_blind, daemon=True).start()
        return jsonify(ok=True)

    @app.route("/api/agents", methods=["GET"])
    def api_agents():
        return jsonify(build_agent_info_list())

    @app.route("/api/personas", methods=["GET"])
    def api_get_personas():
        return jsonify({"personas": get_all_personas(), "active": get_active_persona()})

    @app.route("/api/personas/active", methods=["GET"])
    def api_personas_active():
        return jsonify(get_active_persona())

    @app.route("/api/personas/<pid>", methods=["GET"])
    def api_get_persona_id(pid):
        p = get_persona(pid)
        if p: return jsonify(p)
        return jsonify(error="Not found"), 404

    @app.route("/api/personas", methods=["POST"])
    def api_create_persona():
        data = request.get_json(silent=True) or {}
        r = create_persona(data)
        broadcast_event("persona_created", r)
        return jsonify(r), 201

    @app.route("/api/tasks", methods=["POST"])
    def api_create_task():
        data = request.get_json(silent=True) or {}
        t = task_create(
            subject=data.get("subject", "New Task"),
            description=data.get("description", data.get("metadata", {}).get("description", "")),
            metadata=data.get("metadata", {}),
        )
        result = t.to_dict()
        broadcast_event("task_created", result)
        return jsonify(result), 201

    @app.route("/api/tasks/<tid>", methods=["POST"])
    def api_update_task(tid):
        data = request.get_json(silent=True) or {}
        t, fields = task_update(
            task_id=tid,
            subject=data.get("subject"),
            description=data.get("description"),
            status=data.get("status"),
            owner=data.get("owner"),
            metadata=data.get("metadata"),
        )
        if t:
            result = t.to_dict()
            broadcast_event("task_updated", result)
            return jsonify(result)
        return jsonify(error="Not found"), 404

    @app.route("/api/plugins", methods=["GET"])
    def api_get_plugins():
        import os
        user_plugins_dir = Path(os.path.expanduser("~")) / ".dulus" / "plugins"
        plugins = []
        if user_plugins_dir.exists():
            for d in sorted(user_plugins_dir.iterdir()):
                if d.is_dir() and not d.name.startswith(".") and not d.name.startswith("__"):
                    plugins.append({
                        "name": d.name,
                        "status": "enabled",
                        "source": "user",
                        "path": str(d),
                    })
        # Also include any from dulus2's hot-reload system
        try:
            load_all_plugins()
            for p in get_plugin_info():
                if not any(ep["name"] == p["name"] for ep in plugins):
                    plugins.append(p)
        except Exception:
            pass
        return jsonify({"plugins": plugins, "count": len(plugins)})

    @app.route("/api/plugins/status", methods=["GET"])
    def api_plugins_status():
        return jsonify(watcher_status())

    @app.route("/api/plugins/reload", methods=["POST"])
    def api_plugins_reload():
        data = request.get_json(silent=True) or {}
        name = data.get("name")
        if name:
            from backend.plugins import PLUGINS_DIR
            r = reload_plugin(PLUGINS_DIR / f"{name}.py")
            dr = {"name": r.get("name", name), "version": r.get("version", "?"), "status": r.get("status", "?")}
            broadcast_event("plugin_reloaded", dr)
            return jsonify(dr)
        else:
            load_all_plugins()
            inf = get_plugin_info()
            broadcast_event("plugins_reloaded", {"count": len(inf)})
            return jsonify({"plugins": inf})

    # ── Personas activate ──
    @app.route("/api/personas/activate", methods=["POST"])
    def api_personas_activate():
        data = request.get_json(silent=True) or {}
        pid = data.get("id")
        if not pid:
            return jsonify(error="Missing persona id"), 400
        result = set_active_persona(pid)
        if result:
            broadcast_event("persona_activated", result)
            return jsonify({"activated": True, "persona": result})
        return jsonify(error="Persona not found"), 404

    # ── Marketplace ──
    @app.route("/api/marketplace", methods=["GET"])
    def api_marketplace():
        q = request.args.get("q", "")
        tag = request.args.get("tag", "")
        return jsonify({"plugins": search_plugins(q, tag)})

    @app.route("/api/marketplace/stats", methods=["GET"])
    def api_marketplace_stats():
        return jsonify(marketplace_stats())

    @app.route("/api/marketplace/install", methods=["POST"])
    def api_marketplace_install():
        data = request.get_json(silent=True) or {}
        plugin_id = data.get("id")
        if not plugin_id:
            return jsonify(error="Missing plugin id"), 400
        result = install_plugin(plugin_id)
        if result:
            broadcast_event("marketplace_install", result)
            return jsonify({"installed": True, "plugin": result})
        return jsonify(error="Plugin not found"), 404

    @app.route("/api/marketplace/uninstall", methods=["POST"])
    def api_marketplace_uninstall():
        data = request.get_json(silent=True) or {}
        plugin_id = data.get("id")
        if not plugin_id:
            return jsonify(error="Missing plugin id"), 400
        result = uninstall_plugin(plugin_id)
        if result:
            broadcast_event("marketplace_uninstall", result)
            return jsonify({"uninstalled": True, "plugin": result})
        return jsonify(error="Plugin not found"), 404

    # ── MemPalace ──
    @app.route("/api/mempalace", methods=["GET"])
    def api_mempalace():
        try:
            from backend.mempalace_bridge import load_cache, get_mempalace_compact_text
            data = load_cache()
            data["compact_text"] = get_mempalace_compact_text()
            return jsonify(data)
        except Exception as e:
            return jsonify(error=f"MemPalace error: {e}"), 500

    # ── Memory file list (disk-direct, mirrors /memory CLI) ──
    @app.route("/api/memory/files", methods=["GET"])
    def api_memory_files():
        try:
            from memory.store import load_index
            scope = request.args.get("scope", "all")
            entries = load_index(scope)
            return jsonify([
                {
                    "name": e.name,
                    "description": e.description,
                    "type": e.type,
                    "scope": e.scope,
                    "hall": e.hall,
                    "created": e.created,
                    "confidence": e.confidence,
                    "gold": e.gold,
                    "file_path": e.file_path,
                    "content": e.content,
                }
                for e in entries
            ])
        except Exception as exc:
            return jsonify(error=f"Memory files error: {exc}"), 500

    # ── Themes ──
    @app.route("/api/themes", methods=["GET"])
    def api_themes():
        try:
            from backend.themes import THEMES
            theme_list = {name: f"{t['accent']} accent, {t['bg']} bg" for name, t in THEMES.items()}
            return jsonify({"themes": theme_list})
        except Exception:
            return jsonify({"themes": {}})

    @app.route("/api/themes/<theme_name>/css", methods=["GET"])
    def api_theme_css(theme_name):
        try:
            from backend.themes import THEMES
            t = THEMES.get(theme_name)
            if not t:
                return Response("", mimetype="text/css")
            css = ":root{\n"
            css += f"  --bg:{t['bg']};\n"
            css += f"  --bg2:{t['card']};\n"
            css += f"  --bg3:{t.get('code_bg', t['card'])};\n"
            css += f"  --ink:{t['text']};\n"
            css += f"  --dim:{t['dim']};\n"
            css += f"  --dim2:{t['border']};\n"
            css += f"  --accent:{t['accent']};\n"
            css += f"  --accent2:{t.get('accent_hover', t['accent'])};\n"
            css += f"  --green:{t.get('success', '#4caf50')};\n"
            css += f"  --red:{t.get('error', '#ff6b6b')};\n"
            css += f"  --yellow:{t.get('warning', '#FFC107')};\n"
            css += f"  --blue:{t['accent']};\n"
            css += "}\n"
            return Response(css, mimetype="text/css")
        except Exception:
            return Response("", mimetype="text/css")

    # ── Skills ──
    @app.route("/api/skills", methods=["GET"])
    def api_skills():
        try:
            from skill.loader import load_skills
            skills = load_skills()
            result = [
                {
                    "id": s.name,
                    "name": s.name,
                    "description": s.description,
                    "category": s.source.capitalize() if s.source else "Utility",
                    "triggers": s.triggers,
                    "argument_hint": s.argument_hint,
                    "source": s.source,
                    "user_invocable": s.user_invocable,
                }
                for s in skills
                if s.user_invocable
            ]
            return jsonify(result)
        except Exception as e:
            return jsonify({"error": str(e)}), 500

    @app.route("/api/skills/invoke", methods=["POST"])
    def api_skills_invoke():
        data = request.get_json(silent=True) or {}
        skill_name = data.get("name", "").strip()
        args = data.get("arguments", {})
        args_str = data.get("args", "")
        if not skill_name:
            return jsonify({"error": "Missing skill name"}), 400
        try:
            from skill.loader import load_skills, find_skill
            from skill.tools import _skill_tool

            skill = None
            for s in load_skills():
                if s.name == skill_name:
                    skill = s
                    break
            if skill is None:
                skill = find_skill(skill_name)
            if skill is None:
                return jsonify({"error": f"Skill '{skill_name}' not found"}), 404

            if isinstance(args, dict) and args:
                parts = [str(v) for v in args.values()]
                args_str = " ".join(parts)

            if CONFIG is None:
                return jsonify({"error": "Server not initialized"}), 500
            result = _skill_tool({"name": skill_name, "args": args_str}, dict(CONFIG))
            return jsonify({"success": True, "result": result, "skill": skill_name})
        except Exception as e:
            return jsonify({"error": f"Skill execution error: {e}"}), 500

    # ── Dashboard static serving ──
    @app.route("/dashboard")
    @app.route("/dashboard/")
    def dashboard_page():
        target = DASHBOARD_DIR / "index.html"
        if target.exists():
            return Response(target.read_bytes(), mimetype="text/html")
        return "Dashboard not found", 404

    @app.route("/dashboard/<path:filepath>")
    def dashboard_static(filepath):
        target = DASHBOARD_DIR / filepath
        if target.exists() and target.is_file():
            ctype = "text/html"
            if filepath.endswith(".css"): ctype = "text/css"
            elif filepath.endswith(".js"): ctype = "application/javascript"
            elif filepath.endswith(".json"): ctype = "application/json"
            elif filepath.endswith(".png"): ctype = "image/png"
            elif filepath.endswith(".svg"): ctype = "image/svg+xml"
            return Response(target.read_bytes(), mimetype=ctype)
        return "Not found", 404

    # ── New WebChat UI static assets ──
    # Registered last so it only acts as a fallback for files that live in
    # webchat_ui (style.css, app.js, etc.) without shadowing API routes.
    @app.route("/<path:filename>")
    def webchat_ui_static(filename):
        if not WEBCHAT_UI_DIR.exists():
            return Response(status=404)
        target = (WEBCHAT_UI_DIR / filename).resolve()
        try:
            target.relative_to(WEBCHAT_UI_DIR.resolve())
        except ValueError:
            return Response(status=403)
        if target.exists() and target.is_file():
            return send_from_directory(WEBCHAT_UI_DIR, filename)
        return Response(status=404)

    return app


def start(state: AgentState, config: dict, port: int = 5000, open_browser: bool = False) -> bool:
    global STATE, CONFIG, _SERVER_THREAD, _SERVER_PORT, _WERKZEUG_SERVER
    if _SERVER_THREAD and _SERVER_THREAD.is_alive():
        return False
    STATE = state
    CONFIG = config
    _SERVER_PORT = port
    app = create_app()
    if open_browser:
        threading.Timer(1.0, lambda: webbrowser.open(f"http://127.0.0.1:{port}/")).start()

    from werkzeug.serving import make_server

    # Default to loopback-only — exposing to the LAN by accident is a real
    # safety footgun (anyone on the wifi can poke the agent). Opt-in via
    # config["webchat_lan"] = true (or /webchat lan on).
    bind_host = "0.0.0.0" if config.get("webchat_lan") else "127.0.0.1"

    # Auth follows the bind: leaving loopback turns the token requirement on
    # (unless DULUS_WEBCHAT_AUTH says otherwise). Print an auto-generated
    # token once so an exposed server is still usable.
    global _WEBCHAT_TOKEN, _TOKEN_AUTOGEN, _LAN_EXPOSED
    _LAN_EXPOSED = bind_host != "127.0.0.1"
    _WEBCHAT_TOKEN, _TOKEN_AUTOGEN = _resolve_token()
    if _auth_active():
        if _TOKEN_AUTOGEN:
            print(f"[webchat] auth on ({bind_host}) — token: {_WEBCHAT_TOKEN}", flush=True)
            print("[webchat] set DULUS_WEBCHAT_TOKEN to pin it across restarts.", flush=True)
        else:
            print(f"[webchat] auth on ({bind_host}) — using DULUS_WEBCHAT_TOKEN.", flush=True)

    _WERKZEUG_SERVER = make_server(bind_host, port, app, threaded=True)
    _SERVER_THREAD = threading.Thread(target=_WERKZEUG_SERVER.serve_forever, daemon=True)
    _SERVER_THREAD.start()
    return True


def stop() -> None:
    global _SERVER_THREAD, _WERKZEUG_SERVER
    srv = _WERKZEUG_SERVER
    if srv is not None:
        srv.shutdown()
    _SERVER_THREAD = None
    _WERKZEUG_SERVER = None


def is_running() -> bool:
    return _SERVER_THREAD is not None and _SERVER_THREAD.is_alive()