# -*- coding: utf-8 -*-
"""
dashboard.py - AgentsMeeting management dashboard backend
=========================================================
Flask app on :5803. Monitors agents across platforms via:
  - SSH + ejabberdctl connected_users (cross-platform, authoritative)
  - xmpp_bot HTTP API :5802 (/health, /muc - fallback)
  - Local process/port checks (Windows only)

Auto-recovery: restarts local Windows agents after 3 consecutive offline checks.
"""
import os, sys, re, json, time, socket, subprocess, logging, urllib.request, sqlite3, shutil, threading
from pathlib import Path
from datetime import datetime, timedelta
from flask import Flask, jsonify, request, send_from_directory

# ---- Paths (platform-agnostic: auto-detect from script location) ----
_SCRIPT_DIR = Path(__file__).resolve().parent                    # gateway/scripts/
_GATEWAY_DIR = _SCRIPT_DIR.parent                                # gateway/
_PROJECT_DIR = _GATEWAY_DIR.parent                               # AgentsMeeting/
TEMPLATES_DIR = _SCRIPT_DIR / "templates"
CONFIG_DIR = _PROJECT_DIR / "config"
LOGS_DIR = _GATEWAY_DIR / "logs"
TEMP_DIR = _GATEWAY_DIR / "temp"
XMPP_BRIDGE_URL = os.environ.get("XMPP_BRIDGE_URL", "http://192.168.1.16:5802")
EJABBERD_HOST = os.environ.get("EJABBERD_HOST", "192.168.1.246")

# On Linux (mohe), dashboard runs from systemd with different paths. Support explicit override.
_PROJECT_OVERRIDE = os.environ.get("AGENTSMEETING_ROOT")
if _PROJECT_OVERRIDE:
    _PROJECT_DIR = Path(_PROJECT_OVERRIDE)
    _GATEWAY_DIR = _PROJECT_DIR / "gateway"
    TEMPLATES_DIR = _GATEWAY_DIR / "scripts" / "templates"
    CONFIG_DIR = _PROJECT_DIR / "config"
    LOGS_DIR = _GATEWAY_DIR / "logs"
    TEMP_DIR = _GATEWAY_DIR / "temp"

# Auto-recovery script name map (used by /api/agents)
SCRIPT_NAMES = {
    "xmpp_bot": "xmpp_bot.py",
    "wechat_bridge": "wechat_agent.py",
    "api_proxy": "api_proxy.py",
    "health_check": "health_check_xxm.py",
    "mohe_watcher": "mohe_watcher.py",
    "watchdog": "xmpp_watchdog.py",
}

sys.path.insert(0, str(_GATEWAY_DIR / "scripts"))
from proc_guard import guard

app = Flask(__name__, template_folder=str(TEMPLATES_DIR))

# ---- Logging ----
LOG_FILE = LOGS_DIR / "dashboard.log"
LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
logging.basicConfig(
    filename=str(LOG_FILE),
    level=logging.INFO,
    format="%(asctime)s [dashboard] %(message)s",
)
log = logging.getLogger("dashboard")

# ---- Constants ----
AGENTS_YAML = CONFIG_DIR / "agents.yaml"
PYTHON = os.environ.get("PYTHON", sys.executable)
SCRIPTS_DIR = _GATEWAY_DIR / "scripts"

# Linux agents on local 246 — use systemctl
LOCAL_LINUX_HOSTS = ("192.168.1.246", "127.0.0.1", "localhost")


def _is_local_linux(agent):
    """Check if agent is on the same Linux machine (manageable via systemctl)."""
    return agent.get("platform") == "linux" and agent.get("host", "") in LOCAL_LINUX_HOSTS


def _agent_bot_service(agent):
    """Derive systemd service name from agent JID localpart (e.g. mohe → xmpp-mohe)."""
    jid = agent.get("jid", "")
    localpart = jid.split("@")[0] if "@" in jid else ""
    return f"xmpp-{localpart}" if localpart else ""


# Auto-recovery: restart after this many consecutive offline checks
AUTO_RECOVER_THRESHOLD = 3
_offline_counter: dict[str, int] = {}


# ============================================================
#  Config
# ============================================================

def load_agents_config():
    if AGENTS_YAML.exists():
        import yaml
        with open(AGENTS_YAML, "r", encoding="utf-8") as f:
            return yaml.safe_load(f).get("agents", [])
    return _default_agents()


def _default_agents():
    return [
        {
            "id": "agent-001", "name": "R&D Assistant", "display_name": "xxm",
            "jid": "xxm@yoin.fun", "platform": "windows", "host": "192.168.1.16",
            "bot_type": "xmpp", "provider": "volcengine",
            "services": [{"type": "xmpp_bot", "port": 5802}],
        },
        {
            "id": "agent-002", "name": "Automation Manager", "display_name": "mohe",
            "jid": "mohe@yoin.fun", "platform": "linux", "host": "192.168.1.246",
            "bot_type": "hermes", "provider": "ocg-new",
            "services": [{"type": "hermes_gateway", "port": 8642}, {"type": "xmpp_bot"}],
        },
        {
            "id": "agent-003", "name": "Local Inference", "display_name": "xiaoguo",
            "jid": "xiaoguo@yoin.fun", "platform": "mac", "host": "192.168.1.122",
            "bot_type": "xmpp", "provider": "ocg-old",
            "services": [{"type": "xmpp_bot"}, {"type": "omlx_server", "port": 18003}],
        },
        {
            "id": "agent-004", "name": "Position Analyst", "display_name": "zhiwei",
            "jid": "zhiwei@yoin.fun", "platform": "linux", "host": "192.168.1.246",
            "bot_type": "hermes", "provider": "ocg-old",
            "services": [{"type": "hermes_gateway", "port": 8643}, {"type": "xmpp_bot"}],
        },
    ]


# ============================================================
#  Cross-platform monitoring (XMPP + SSH)
# ============================================================

def _xmpp_health():
    """Query xmpp_bot /health for XMPP connection and ejabberd status."""
    try:
        req = urllib.request.Request(f"{XMPP_BRIDGE_URL}/health")
        with urllib.request.urlopen(req, timeout=5) as resp:
            return json.loads(resp.read())
    except Exception as e:
        return {"ok": False, "error": str(e), "xmpp_connected": False, "ejabberd_alive": False}


def _ejabberd_online_jids():
    """Query ejabberdctl connected_users.
    On Linux (local): direct docker exec.
    On Windows (remote): SSH to EJABBERD_HOST.
    Returns set of bare JIDs currently connected to ejabberd."""
    try:
        if sys.platform == "win32":
            # Windows: SSH to Linux server
            ssh_cmd = ["ssh", "-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=5",
                       "-o", "BatchMode=yes", f"hmo@{EJABBERD_HOST}",
                       "docker exec ejabberd ejabberdctl connected_users"]
            result = subprocess.run(ssh_cmd, capture_output=True, text=True, timeout=15)
        else:
            # Linux: direct docker exec
            result = subprocess.run(
                ["docker", "exec", "ejabberd", "ejabberdctl", "connected_users"],
                capture_output=True, text=True, timeout=10)
        if result.returncode != 0:
            log.debug(f"ejabberdctl failed (exit={result.returncode}): {result.stderr[:100]}")
            return set()
        jids = set()
        for line in result.stdout.strip().split("\n"):
            line = line.strip()
            if line and "@" in line:
                jids.add(line.split("/")[0])
        return jids
    except Exception as e:
        log.debug(f"ejabberd query failed: {e}")
        return set()


def _muc_participants():
    """Fallback: query xmpp_bot /muc for room participants.
    Currently unreliable due to MUC join timeout (R01)."""
    try:
        req = urllib.request.Request(f"{XMPP_BRIDGE_URL}/muc")
        with urllib.request.urlopen(req, timeout=5) as resp:
            data = json.loads(resp.read())
    except Exception:
        return set()
    participants = set()
    for room_data in data.get("rooms", {}).values():
        for p in room_data.get("participants", []):
            jid = p.get("jid", "")
            if jid:
                participants.add(jid)
            nick = p.get("nick", "")
            if nick and "@" in nick:
                participants.add(nick)
    return participants


# ============================================================
#  Local process detection (Windows only)
# ============================================================

def _get_local_processes():
    processes = []
    try:
        result = subprocess.run(["ps", "aux"], capture_output=True, text=True, timeout=5)
        for line in result.stdout.split("\n"):
            if "xmpp_bot" in line or "wechat_agent" in line or "dashboard" in line:
                parts = line.split()
                if len(parts) >= 11:
                    processes.append({"pid": int(parts[1]), "cmdline": " ".join(parts[10:])})
    except Exception as e:
        log.error(f"Process scan failed: {e}")
    return processes


# ============================================================
#  Log helpers
# ============================================================

def _tail_logs(max_lines=50):
    all_lines = []
    log_files = sorted(LOGS_DIR.glob("*.log"), key=lambda p: p.stat().st_mtime, reverse=True)
    for lf in log_files:
        try:
            with open(lf, "r", encoding="utf-8", errors="replace") as f:
                f.seek(0, os.SEEK_END)
                size = f.tell()
                read_size = min(size, max_lines * 500)
                if read_size > 0:
                    f.seek(max(0, size - read_size))
                    for line in f.read().strip().split("\n"):
                        if line.strip():
                            all_lines.append(f"[{lf.name}] {line}")
        except Exception:
            pass
    return all_lines[-max_lines:] if len(all_lines) > max_lines else all_lines


def _count_recent_messages(minutes=5):
    log_path = LOGS_DIR / "xmpp_bot.log"
    if not log_path.exists():
        return 0
    try:
        with open(log_path, "r", encoding="utf-8", errors="replace") as f:
            lines = f.readlines()
        cutoff = datetime.now() - timedelta(minutes=minutes)
        count = 0
        pattern = re.compile(r"(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})")
        for line in reversed(lines):
            m = pattern.search(line)
            if m:
                try:
                    if datetime.strptime(m.group(1), "%Y-%m-%d %H:%M:%S") < cutoff:
                        break
                    count += 1
                except ValueError:
                    pass
        return count
    except Exception:
        return 0


# ============================================================
#  Routes
# ============================================================

@app.route("/")
def index():
    return send_from_directory(str(TEMPLATES_DIR), "dashboard.html")


@app.route("/api/agents")
def api_agents():
    agents_config = load_agents_config()
    local_procs = _get_local_processes()
    message_count = _count_recent_messages(5)

    # Primary: SSH ejabberdctl for cross-platform presence
    online_jids = _ejabberd_online_jids()
    if not online_jids:
        online_jids = _muc_participants()  # fallback

    result = []
    for agent in agents_config:
        agent_id = agent["id"]
        jid = agent.get("jid", "")
        platform = agent.get("platform", "")
        host = agent.get("host", "")

        # --- Presence ---
        ejabberd_query_ok = online_jids is not None and len(online_jids) > 0
        xmpp_in_ejabberd = jid in online_jids if online_jids else None

        # --- Local process (Windows only) ---
        local_pid = None
        xmpp_connected = False
        if platform == "windows" and host in ("192.168.1.16", "127.0.0.1", "localhost"):
            for proc in local_procs:
                if "xmpp_bot.py" in proc.get("cmdline", ""):
                    local_pid = proc["pid"]
                    break
            health = _xmpp_health()
            xmpp_connected = health.get("xmpp_connected", False)

        # --- Status reason ---
        status_reason = ""
        if xmpp_in_ejabberd is None and not online_jids:
            status_reason = "ejabberd SSH 查询失败，MUC 降级检测也无结果"
        elif xmpp_in_ejabberd is False:
            status_reason = "XMPP JID 未登录 ejabberd"
        elif xmpp_in_ejabberd is None:
            status_reason = "无法检测 XMPP 状态"
        elif xmpp_in_ejabberd is True:
            status_reason = "OK"
        if platform == "windows" and host in ("192.168.1.16", "127.0.0.1", "localhost"):
            if status_reason == "OK":
                status_reason = "OK"
            elif xmpp_connected:
                status_reason = "Bot 运行中，但 XMPP 未登录 ejabberd"
            elif local_pid:
                status_reason = "Bot 进程存在但 XMPP 连接断开"
            else:
                status_reason = "Bot 进程不存在"

        # --- Service status ---
        services = []
        for svc in agent.get("services", []):
            svc_type = svc.get("type", "")
            svc_port = svc.get("port")

            if svc_type == "xmpp_bot":
                if platform == "windows" and local_pid:
                    svc_status = "running" if xmpp_connected else "degraded"
                    svc_pid = local_pid
                elif xmpp_in_ejabberd is True:
                    svc_status = "running"
                    svc_pid = None
                elif xmpp_in_ejabberd is False:
                    svc_status = "stopped"
                    svc_pid = None
                else:
                    svc_status = "unknown"
                    svc_pid = None
            elif svc_type in ("hermes_gateway", "omlx_server"):
                svc_status = "unknown"
                svc_pid = None
            else:
                svc_status = "stopped"
                svc_pid = None
                for proc in local_procs:
                    script_name = SCRIPT_NAMES.get(svc_type, "")
                    if script_name and script_name in proc.get("cmdline", ""):
                        svc_status = "running"
                        svc_pid = proc["pid"]
                        break

            services.append({
                "type": svc_type,
                "port": svc_port,
                "status": svc_status,
                "pid": svc_pid,
            })

        # --- Overall status ---
        if xmpp_in_ejabberd is True:
            status = "online"
        elif xmpp_in_ejabberd is False:
            status = "offline"
        elif platform == "windows" and host in ("192.168.1.16", "127.0.0.1", "localhost"):
            if xmpp_connected:
                status = "online"
            elif local_pid:
                status = "degraded"
            else:
                status = "offline"
        else:
            status = "unknown"

        # --- Auto-recovery ---
        if status == "offline" and (platform == "windows" or (platform == "linux" and host in LOCAL_LINUX_HOSTS)):
            _offline_counter[agent_id] = _offline_counter.get(agent_id, 0) + 1
            if _offline_counter[agent_id] >= AUTO_RECOVER_THRESHOLD:
                log.warning(f"Auto-recovery: restarting {agent_id}")
                _try_auto_recover(agent)
        else:
            _offline_counter[agent_id] = 0

        result.append({
            "id": agent_id,
            "name": agent.get("name", ""),
            "display_name": agent.get("display_name", ""),
            "jid": jid,
            "platform": platform,
            "host": host,
            "status": status,
            "status_reason": status_reason,
            "xmpp_connected": xmpp_connected,
            "pid": local_pid,
            "last_message": None,
            "message_count_5min": message_count,
            "errors": 0,
            "offline_checks": _offline_counter.get(agent_id, 0),
            "restartable": (platform == "windows" and host in ("192.168.1.16", "127.0.0.1", "localhost")) or
                          (platform == "linux" and host in LOCAL_LINUX_HOSTS),
            "services": services,
        })

    return jsonify(result)


def _try_auto_recover(agent):
    agent_id = agent["id"]
    platform = agent.get("platform", "")
    host = agent.get("host", "")

    # Linux local → systemctl start
    if platform == "linux" and host in LOCAL_LINUX_HOSTS:
        svc = _agent_bot_service(agent)
        if not svc:
            return
        try:
            subprocess.run(["sudo", "systemctl", "start", svc], capture_output=True, timeout=15)
            log.info(f"Auto-restarted {svc} for {agent_id}")
        except Exception as e:
            log.error(f"Auto-restart failed for {svc}: {e}")
        return

    # Windows local → subprocess
    if platform != "windows" or host not in ("192.168.1.16", "127.0.0.1", "localhost"):
        return
    for svc in agent.get("services", []):
        script_name = SCRIPT_NAMES.get(svc.get("type", ""))
        if not script_name:
            continue
        script_path = SCRIPTS_DIR / script_name
        if not script_path.exists():
            continue
        try:
            subprocess.Popen(
                [PYTHON, str(script_path)],
                cwd=str(SCRIPTS_DIR),
                creationflags=subprocess.CREATE_NO_WINDOW,
            )
            log.info(f"Auto-restarted {script_name} for {agent_id}")
        except Exception as e:
            log.error(f"Auto-restart failed: {e}")


@app.route("/api/ejabberd")
def api_ejabberd():
    health = _xmpp_health()
    online_jids = _ejabberd_online_jids()
    return jsonify({
        "alive": len(online_jids) > 0,
        "xmpp_bot_connected": health.get("xmpp_connected", False),
        "online_jids": sorted(list(online_jids)) if online_jids else [],
        "bot_jid": health.get("bot_jid", ""),
    })


@app.route("/api/agents/<agent_id>/logs")
def api_agent_logs(agent_id):
    lines = request.args.get("lines", 50, type=int)
    return jsonify({"lines": _tail_logs(lines)})


@app.route("/api/agents/<agent_id>/start", methods=["POST"])
def api_agent_start(agent_id):
    agents_config = load_agents_config()
    agent = next((a for a in agents_config if a["id"] == agent_id), None)
    if not agent:
        return jsonify({"ok": False, "error": "Agent not found"}), 404

    # Linux local → systemctl start
    if _is_local_linux(agent):
        svc = _agent_bot_service(agent)
        if not svc:
            return jsonify({"ok": False, "error": "Cannot derive service name"}), 400
        try:
            r = subprocess.run(["sudo", "systemctl", "start", svc], capture_output=True, timeout=15)
            if r.returncode == 0:
                _offline_counter[agent_id] = 0
                log.info(f"Started {svc} for {agent_id}")
                return jsonify({"ok": True, "service": svc})
            else:
                err = r.stderr.decode().strip()
                return jsonify({"ok": False, "error": err}), 500
        except Exception as e:
            return jsonify({"ok": False, "error": str(e)}), 500

    # Windows local → subprocess
    if agent.get("platform") != "windows":
        return jsonify({"ok": False, "error": "Remote restart not supported yet"}), 400
    started = []
    for svc in agent.get("services", []):
        script_name = SCRIPT_NAMES.get(svc.get("type", ""))
        if not script_name:
            continue
        script_path = SCRIPTS_DIR / script_name
        if not script_path.exists():
            continue
        try:
            subprocess.Popen(
                [PYTHON, str(script_path)],
                cwd=str(SCRIPTS_DIR),
                creationflags=subprocess.CREATE_NO_WINDOW,
            )
            started.append(script_name)
            log.info(f"Started {script_name} for {agent_id}")
        except Exception as e:
            log.error(f"Failed to start {script_name}: {e}")
    _offline_counter[agent_id] = 0
    return jsonify({"ok": True, "started": started})


@app.route("/api/agents/<agent_id>/stop", methods=["POST"])
def api_agent_stop(agent_id):
    agents_config = load_agents_config()
    agent = next((a for a in agents_config if a["id"] == agent_id), None)
    if not agent:
        return jsonify({"ok": False, "error": "Agent not found"}), 404

    # Linux local → systemctl stop
    if _is_local_linux(agent):
        svc = _agent_bot_service(agent)
        if not svc:
            return jsonify({"ok": False, "error": "Cannot derive service name"}), 400
        try:
            r = subprocess.run(["sudo", "systemctl", "stop", svc], capture_output=True, timeout=15)
            if r.returncode == 0:
                log.info(f"Stopped {svc} for {agent_id}")
                return jsonify({"ok": True, "service": svc})
            else:
                err = r.stderr.decode().strip()
                return jsonify({"ok": False, "error": err}), 500
        except Exception as e:
            return jsonify({"ok": False, "error": str(e)}), 500

    # Windows local → taskkill
    if agent.get("platform") != "windows":
        return jsonify({"ok": False, "error": "Remote stop not supported yet"}), 400
    processes = _get_local_processes()
    stopped = []
    for svc in agent.get("services", []):
        script_name = SCRIPT_NAMES.get(svc.get("type", ""))
        if not script_name:
            continue
        for proc in processes:
            if script_name in proc.get("cmdline", ""):
                pid = proc["pid"]
                try:
                    subprocess.run(["taskkill", "/f", "/pid", str(pid)], capture_output=True)
                    stopped.append({"script": script_name, "pid": pid})
                except Exception as e:
                    log.error(f"Failed to stop {script_name}: {e}")
    return jsonify({"ok": True, "stopped": stopped})


@app.route("/api/agents/<agent_id>/restart", methods=["POST"])
def api_agent_restart(agent_id):
    api_agent_stop(agent_id)
    time.sleep(2)
    return api_agent_start(agent_id)


PLATFORM_SERVICES = [
    {"id": "wechat_bridge", "name": "莫荷微信 (Linux :3001)", "type": "ChannelBridge",
     "desc": "246 Docker wechatbot-webhook → 微信收发 + webhook 触发 → Hermes Gateway",
     "host": "192.168.1.246", "port": 3001},
    {"id": "article_processor", "name": "文章抓取服务 (5810)", "type": "wechat-fetch",
     "desc": "fetches wechat article content + OCR (DrissionPage)",
     "host": "192.168.1.16", "health_url": "http://192.168.1.16:5810/health"},
]

@app.route("/api/platform")
def api_platform():
    """Return platform services status by querying health endpoints."""
    import urllib.request as _ur
    result = []
    for ps in PLATFORM_SERVICES:
        status = "stopped"
        health_data = None
        health_url = ps.get("health_url", "")
        if health_url:
            try:
                req = _ur.Request(health_url)
                with _ur.urlopen(req, timeout=3) as resp:
                    body = resp.read()
                    status = "running"
                    try:
                        health_data = json.loads(body)
                    except Exception:
                        pass
            except Exception:
                status = "stopped"
        elif "port" in ps:
            import socket
            try:
                s = socket.socket()
                s.settimeout(2)
                s.connect((ps.get("host", "127.0.0.1"), ps["port"]))
                s.close()
                status = "running"
            except Exception:
                status = "stopped"
        entry = {
            "id": ps["id"],
            "name": ps["name"],
            "type": ps["type"],
            "desc": ps["desc"],
            "status": status,
        }
        if health_data:
            entry["health_data"] = health_data
        result.append(entry)
    return jsonify(result)


@app.route("/api/service/5810/logs")
def api_article_processor_logs():
    """Proxy logs from article-processor service on Windows."""
    try:
        req = urllib.request.Request("http://192.168.1.16:5810/logs?lines=200")
        with urllib.request.urlopen(req, timeout=5) as resp:
            data = json.loads(resp.read())
        lines = data.get("lines", [])
        response = jsonify({"lines": lines})
        response.headers["Access-Control-Allow-Origin"] = "*"
        return response
    except Exception as e:
        response = jsonify({"lines": ["<error: {}>".format(str(e))], "error": True})
        response.headers["Access-Control-Allow-Origin"] = "*"
        return response


@app.route("/api/kanban")
def api_kanban():
    """Return kanban tasks from shared Hermes kanban.db."""
    kanban_db = Path(os.path.expanduser("~/.hermes/kanban.db"))
    if not kanban_db.exists():
        return jsonify({"tasks": [], "db_exists": False})
    try:
        db = sqlite3.connect(str(kanban_db))
        rows = db.execute(
            "SELECT id, title, body, status, assignee, created_by, created_at FROM tasks ORDER BY created_at DESC"
        ).fetchall()
        db.close()
        tasks = []
        for r in rows:
            tasks.append({
                "id": r[0], "title": r[1], "body": r[2], "status": r[3],
                "assignee": r[4], "created_by": r[5], "created_at": r[6]
            })
        return jsonify({"tasks": tasks, "db_exists": True, "count": len(tasks)})
    except Exception as e:
        return jsonify({"error": str(e), "db_exists": True})


# ════════════════════════════════════════════════════════════
#  A — 源码管理可视化
# ════════════════════════════════════════════════════════════
@app.route("/api/git")
def api_git():
    """最近 git 提交历史 + 分支状态（从 .git 直接读取，不依赖 git 命令）"""
    try:
        # 先用 _PROJECT_DIR（已处理 AGENTSMEETING_ROOT 覆盖），不行再探测常见路径
        candidates = [str(_PROJECT_DIR)]
        if _PROJECT_OVERRIDE:
            candidates.append(str(_PROJECT_DIR))
        # 246 生产环境常见路径
        if sys.platform != "win32":
            candidates.extend([
                "/home/hmo/projects/AgentsMeeting",
                os.path.expanduser("~/projects/AgentsMeeting"),
            ])
        git_dir = None
        for c in candidates:
            if os.path.exists(os.path.join(c, ".git")):
                git_dir = c
                break
        if not git_dir:
            return jsonify({"ok": True, "log": [], "dirty": False, "note": "未找到.git目录,请设置AGENTSMEETING_ROOT"})
        dot_git = os.path.join(git_dir, ".git")
        log_lines = []
        # 优先用 git log 命令（真实提交信息），降级到解析 reflog
        tried_git = False
        # Linux nohup 环境 PATH 可能不含 /usr/bin，必须用绝对路径
        GIT_CANDIDATES = [
            os.environ.get("GIT_CMD", ""),
            shutil.which("git") or "",
            "/usr/bin/git", "/usr/local/bin/git",
        ]
        git_bin = ""
        for c in GIT_CANDIDATES:
            if c and os.path.exists(c):
                git_bin = c
                break
        if git_bin:
            try:
                r = subprocess.run(
                    [git_bin, "log", "--format=%h|%ad|%s", "--date=format:%m-%d %H:%M", "--no-decorate"],
                    cwd=git_dir, capture_output=True, text=True, timeout=10)
                if r.returncode == 0 and r.stdout.strip():
                    tried_git = True
                    for line in r.stdout.strip().split("\n"):
                        line = line.strip()
                        if line:
                            parts = line.split("|", 2)
                            if len(parts) == 3:
                                log_lines.append(f"{parts[0]} {parts[1]} {parts[2]}")
                            else:
                                log_lines.append(line)
            except:
                pass
        if not tried_git:
            reflog = os.path.join(dot_git, "logs", "HEAD")
            if os.path.exists(reflog):
                with open(reflog, "r", encoding="utf-8", errors="replace") as f:
                    lines = f.readlines()
                for line in reversed(lines):
                    line = line.strip()
                    if not line:
                        continue
                    parts = line.split("\t")
                    msg = parts[-1] if len(parts) > 1 else line
                    hash_part = line.split()[1][:7] if len(line.split()) > 1 else "?"
                    # 从 reflog 提取时间戳: 第3+4字段 = unix时间 + 时区
                    ts = ""
                    try:
                        cols = line.split()
                        if len(cols) >= 5:
                            ts = datetime.fromtimestamp(int(cols[3])).strftime("%m-%d %H:%M") + " "
                    except:
                        pass
                    log_lines.append(f"{ts}{hash_part} {msg}")
        # 检查是否有未提交的改动
        dirty = False
        head_file = os.path.join(dot_git, "HEAD")
        index_file = os.path.join(dot_git, "index")
        if os.path.exists(head_file) and os.path.exists(index_file):
            try:
                dirty = os.path.getmtime(index_file) > os.path.getmtime(head_file)
            except:
                pass
        # 分支名
        branch = "master"
        try:
            with open(head_file, "r") as f:
                ref = f.read().strip()
            if ref.startswith("ref: refs/heads/"):
                branch = ref[16:]
        except:
            pass
        return jsonify({"ok": True, "log": log_lines, "dirty": dirty, "branch": branch, "source": git_dir, "method": ("git_log" if tried_git else "reflog")})
    except Exception as e:
        return jsonify({"ok": False, "error": str(e), "log": [], "dirty": False})


# ════════════════════════════════════════════════════════════
#  B — 服务架构可视化
# ════════════════════════════════════════════════════════════
@app.route("/api/services")
def api_services():
    """服务功能树 + watchdog 覆盖矩阵"""
    try:
        services = []
        # xmpp_bot (跨平台：通过 XMPP_BRIDGE_URL 检测 Windows .16)
        xmpp_url = f"{XMPP_BRIDGE_URL}/health"
        svc1 = {"name": "xmpp_bot", "port": 5802, "health": _health_status(xmpp_url),
                "watchdog": True, "pid_lock": True, "type": "core", "depends_on": ["ejabberd"]}
        services.append(svc1)
        # article_processor (跨平台：通过 PLATFORM_SERVICES 中的 health_url)
        ap_url = "http://192.168.1.16:5810/health"
        svc2 = {"name": "article_processor", "port": 5810, "health": _health_status(ap_url),
                "watchdog": True, "pid_lock": False, "type": "bridge", "depends_on": []}
        services.append(svc2)
        # dashboard (本地)
        svc3 = {"name": "dashboard", "port": 5803, "health": _health_status("http://127.0.0.1:5803/api/health"),
                "watchdog": False, "pid_lock": True, "type": "mgmt", "depends_on": ["xmpp_bot"]}
        services.append(svc3)
        # ejabberd
        online = _ejabberd_online_jids()
        services.append({"name": "ejabberd", "port": 5222, "health": {"ok": len(online) > 0},
                         "watchdog": True, "pid_lock": False, "type": "infra", "depends_on": []})
        # remote gateways (R01 monitoring)
        g1 = {"name": "gateway_mohe", "port": 8642, "health": _health_status("http://192.168.1.246:8642/v1/health"),
              "watchdog": False, "pid_lock": False, "type": "gateway", "depends_on": ["ejabberd"]}
        services.append(g1)
        g2 = {"name": "gateway_zhiwei", "port": 8643, "health": _health_status("http://192.168.1.246:8643/v1/health"),
              "watchdog": False, "pid_lock": False, "type": "gateway", "depends_on": ["ejabberd"]}
        services.append(g2)
        # 统计
        watched = sum(1 for s in services if s.get("watchdog"))
        return jsonify({"ok": True, "services": services, "watched": watched, "total": len(services)})
    except Exception as e:
        return jsonify({"ok": False, "error": str(e)})


def _health_status(url, timeout=3):
    try:
        r = urllib.request.urlopen(url, timeout=timeout)
        return {"ok": r.status == 200, "status": r.status, "detail": "ok"}
    except urllib.error.HTTPError as e:
        return {"ok": False, "status": e.code, "detail": f"HTTP {e.code}"}
    except Exception as e:
        return {"ok": False, "status": 0, "detail": str(e)[:50]}


# ════════════════════════════════════════════════════════════
#  C — 监控结果可视化
# ════════════════════════════════════════════════════════════
@app.route("/api/monitor")
def api_monitor():
    """Tier1/Tier2 最近检查结果 + 定时任务状态"""
    result = {"ok": True, "tier1": None, "tier2": None, "tasks": [], "platform": sys.platform}
    # Tier1 最新报告
    t1_file = TEMP_DIR / "last_health_check.json"
    if t1_file.exists():
        try:
            with open(str(t1_file)) as f:
                result["tier1"] = json.load(f)
        except:
            pass
    else:
        result["tier1"] = {"status": "no_data", "note": f"{t1_file} 不存在", "summary": {"ok": 0, "total": 0}}
    # Tier2 最新报告
    t2_file = TEMP_DIR / "last_daily_health.json"
    if t2_file.exists():
        try:
            with open(str(t2_file)) as f:
                result["tier2"] = json.load(f)
        except:
            pass
    else:
        result["tier2"] = {"status": "no_data", "note": f"{t2_file} 不存在", "summary": {"ok": 0, "total": 0}}
    # 定时任务状态
    expected_tasks = ["agents-health-check", "agents-daily-health", "agents-todo-executor"]
    if sys.platform == "win32":
        for name in expected_tasks:
            try:
                r = subprocess.run(["schtasks", "/Query", "/TN", name, "/FO", "CSV", "/NH"],
                                   capture_output=True, text=True, timeout=5,
                                   creationflags=subprocess.CREATE_NO_WINDOW)
                status = "ok" if ("Ready" in r.stdout or "\u5c31\u7eea" in r.stdout) else ("missing" if name not in r.stdout else "other")
            except:
                status = "error"
            result["tasks"].append({"name": name, "status": status})
    else:
        # Linux: SSH 到 Windows 查 schtasks（输出可能是 GBK）
        win_host = os.environ.get("WINDOWS_HOST", "192.168.1.16")
        for name in expected_tasks:
            try:
                r = subprocess.run(
                    ["ssh", "-o", "StrictHostKeyChecking=no", "-o", "ConnectTimeout=5",
                     "-o", "BatchMode=yes", f"hmo@{win_host}",
                     f"schtasks /Query /TN {name} /FO CSV /NH"],
                    capture_output=True, timeout=10
                )
                # 先看去重定向码：非0 = 任务不存在
                if r.returncode != 0:
                    result["tasks"].append({"name": name, "status": "not_deployed"})
                    continue
                # 尝试解码输出（Windows schtasks 默认 GBK，也试试 UTF-8）
                out = ""
                for enc in ["utf-8", "gbk", "gb2312", "cp936"]:
                    try:
                        out = r.stdout.decode(enc)
                        break
                    except UnicodeDecodeError:
                        continue
                if name in out:
                    if "就绪" in out or "Ready" in out or "Running" in out:
                        result["tasks"].append({"name": name, "status": "schtasks_ok"})
                    else:
                        result["tasks"].append({"name": name, "status": "schtasks_unknown", "raw": out.strip()})
                else:
                    result["tasks"].append({"name": name, "status": "not_deployed"})
            except Exception as e:
                result["tasks"].append({"name": name, "status": "not_deployed", "note": f"SSH到Windows失败: {str(e)[:60]}"})
    return jsonify(result)


# ════════════════════════════════════════════════════════════
#  E — 元成长回路可视化
# ════════════════════════════════════════════════════════════
@app.route("/api/metagrowth")
def api_metagrowth():
    """元成长回路（Phase 3 规划中）"""
    try:
        # 统计已完成的修复次数
        todo_file = TEMP_DIR / "health_todos.jsonl"
        total_fixes = 0
        completed_fixes = 0
        if todo_file.exists():
            with open(str(todo_file), encoding="utf-8-sig") as f:
                for line in f:
                    line = line.strip()
                    if line:
                        total_fixes += 1
                        try:
                            entry = json.loads(line)
                        except json.JSONDecodeError:
                            continue
                        if entry.get("status") == "completed":
                            completed_fixes += 1
        # 统计 git 提交次数（从 reflog 行数计算，跟 api_git 同样路径探测逻辑）
        commit_count = 0
        git_candidates = [str(_PROJECT_DIR)]
        if sys.platform != "win32":
            git_candidates.extend(["/home/hmo/projects/AgentsMeeting",
                                   os.path.expanduser("~/projects/AgentsMeeting")])
        for c in git_candidates:
            rfl = os.path.join(c, ".git", "logs", "HEAD")
            if os.path.exists(rfl):
                try:
                    with open(rfl, "r", encoding="utf-8", errors="replace") as f:
                        commit_count = sum(1 for line in f if line.strip())
                except:
                    pass
                break
        return jsonify({
            "ok": True,
            "status": "planned",  # Phase 3
            "total_fixes": total_fixes,
            "completed_fixes": completed_fixes,
            "commit_count": commit_count,
            "meta_growth_enabled": False,
            "description": "E 元成长回路是 Phase 3 范围。启用后将自动分析修复模式并扩展检查规则。",
        })
    except Exception as e:
        return jsonify({"ok": False, "error": str(e)})


# ════════════════════════════════════════════════════════════
#  D — 自修复流水线可视化
# ════════════════════════════════════════════════════════════
@app.route("/api/todos")
def api_todos():
    """TODO 执行记录 + escalation 日志"""
    todos = []
    todo_file = TEMP_DIR / "health_todos.jsonl"
    if todo_file.exists():
        try:
            with open(str(todo_file)) as f:
                for line in f:
                    line = line.strip()
                    if line:
                        todos.append(json.loads(line))
        except:
            pass
    # executor 日志最新行
    executor_log = LOGS_DIR / "todo_executor.log"
    executor_tail = ""
    if executor_log.exists():
        try:
            lines = open(str(executor_log)).read().strip().split("\n")
            executor_tail = "\n".join(lines[-5:])
        except:
            pass
    return jsonify({"todos": todos, "executor_log_tail": executor_tail, "count": len(todos)})


@app.route("/api/autoheal")
def api_autoheal():
    """最近一次自动修复记录（auto_heal.py 写入的摘要）。"""
    sf = TEMP_DIR / "last_auto_heal.json"
    if sf.exists():
        try:
            with open(str(sf)) as f:
                return jsonify(json.load(f))
        except:
            pass
    return jsonify({"time": None, "dry_run": False, "total_expected": 0, "anomalies_found": 0, "actions_taken": []})


# ════════════════════════════════════════════════════════════
#  F — 期望状态 vs 实际状态
# ════════════════════════════════════════════════════════════
@app.route("/api/expected")
def api_expected():
    """动态期望矩阵：从 agents.yaml + PLATFORM_SERVICES 生成，跨平台区分检测"""
    expected = []
    # 1. 从 agents.yaml 生成各 Agent 服务的期望
    agents = load_agents_config()
    for agent in agents:
        display = agent.get("display_name", agent["name"])
        host = agent.get("host", "127.0.0.1")
        bot_type = agent.get("bot_type", "xmpp")
        for svc in agent.get("services", []):
            svc_type = svc["type"]
            # hermes 协议 agent 不跑独立 xmpp_bot，跳过
            if bot_type == "hermes" and svc_type == "xmpp_bot":
                continue
            port = svc.get("port")
            # key 供前端 M 映射表查找唯一标签（实例级，不按类型折叠）
            key = f"{agent['id']}:{svc_type}"
            spec = svc_type  # spec 模块名，供 ?§ 按钮链接 specs/{module}.json
            entry = {"name": f"{display}({host}):{svc_type}", "key": key, "spec": spec, "host": host, "expected": "running", "critical": True}
            if port:
                entry["port"] = port
                entry["check"] = "tcp"
            elif svc_type == "xmpp_bot":
                entry["check"] = "xmpp"  # xmpp bot without port means ejabberd-connected
                entry["jid"] = agent.get("jid", "")
            else:
                entry["check"] = "agent_online"
            expected.append(entry)

    # 2. 从 PLATFORM_SERVICES 生成平台服务的期望
    for ps in PLATFORM_SERVICES:
        entry = {"name": f"{ps['name']} ({ps['id']})", "key": ps["id"], "spec": ps["id"], "host": ps.get("host", "127.0.0.1"), "expected": "running", "critical": True}
        if ps.get("health_url"):
            entry["health_url"] = ps["health_url"]
            entry["check"] = "health_url"
        elif ps.get("port"):
            entry["port"] = ps["port"]
            entry["check"] = "tcp"
        else:
            continue
        expected.append(entry)

    # 3. 固定定时任务期望
    expected.append({"name": "agents-health-check", "check": "scheduled", "expected": "scheduled", "critical": False})
    expected.append({"name": "agents-daily-health", "check": "scheduled", "expected": "scheduled", "critical": False})

    # ── 实际状态检测 ──
    actual = {}
    for e in expected:
        name = e["name"]
        host = e.get("host", "127.0.0.1")
        check = e.get("check", "unknown")

        if check == "scheduled":
            task_name = name
            if sys.platform == "win32":
                try:
                    r = subprocess.run(["schtasks", "/Query", "/TN", task_name, "/FO", "CSV", "/NH"],
                                       capture_output=True, text=True, timeout=5, creationflags=subprocess.CREATE_NO_WINDOW)
                    ready = "Ready" in r.stdout or "\u5c31\u7eea" in r.stdout
                    actual[name] = "scheduled" if ready else "missing"
                except:
                    actual[name] = "error"
            else:
                try:
                    r = subprocess.run(["systemctl", "list-timers", "--all", "--no-pager"],
                                       capture_output=True, text=True, timeout=5)
                    if task_name in r.stdout:
                        actual[name] = "timer_ok"
                    else:
                        r2 = subprocess.run(["crontab", "-l"], capture_output=True, text=True, timeout=5)
                        actual[name] = "cron_ok" if task_name in r2.stdout else "not_deployed"
                except:
                    actual[name] = "not_deployed"

        elif check == "health_url":
            actual[name] = "running" if _health_status(e["health_url"])["ok"] else "stopped"

        elif check == "tcp":
            # 判断目标是否是本机
            is_local = _is_local_host(host)
            if is_local:
                actual[name] = "running" if port_open(e["port"], host) else "stopped"
            else:
                # 远程服务：状态由 /api/platform 精确检测，这里标记为远程引用
                actual[name] = "remote (见平台Tab)"

        elif check == "xmpp":
            # 无端口号的 xmpp_bot：通过 ejabberdctl 查 JID 是否在线
            jid = e.get("jid", "")
            if jid:
                online = _ejabberd_online_jids()
                actual[name] = "online" if jid in online else "offline"
            else:
                actual[name] = "unknown"
        elif check == "agent_online":
            actual[name] = "unknown"
        else:
            actual[name] = "unknown"

    return jsonify({"expected": expected, "actual": actual})


def _is_local_host(host):
    """判断目标主机是否是本机（Dashboard 运行所在的机器）。"""
    if host in ("127.0.0.1", "localhost", "::1"):
        return True
    # 246 是 Dashboard 的生产部署机器（同时运行 ejabberd）
    if host == EJABBERD_HOST:
        return True
    try:
        # 解析本机 hostname → IP，与 host 对比
        local_name = socket.gethostname()
        if host == local_name:
            return True
        local_ip = socket.gethostbyname(local_name)
        if host == local_ip:
            return True
    except:
        pass
    return False


def port_open(port, host="127.0.0.1"):
    """Check if a port is listening on a specific host."""
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.settimeout(2)
        result = s.connect_ex((host, port))
        s.close()
        return result == 0
    except:
        return False


# EasyTier/RDP API key for xmpp_bot on Windows
_BRIDGE_KEY = "xxm_bridge_8f3a2c"

def _bridge_post(path, payload, timeout=15):
    """POST to xmpp_bot HTTP bridge on Windows."""
    req = urllib.request.Request(
        f"{XMPP_BRIDGE_URL}{path}",
        data=json.dumps(payload).encode(),
        headers={"Content-Type": "application/json", "X-Api-Key": _BRIDGE_KEY},
        method="POST")
    resp = urllib.request.urlopen(req, timeout=timeout)
    return json.loads(resp.read())


# ════════════════════════════════════════════════════════════
#  EasyTier VPN + RDP 远程桌面控制
# ════════════════════════════════════════════════════════════
@app.route("/api/easytier")
def api_easytier_status():
    """EasyTier VPN 状态 — proxy to xmpp_bot on Windows."""
    try:
        windows_running = False
        status_246 = "unknown"
        try:
            data = _bridge_post("/easytier", {"action": "status"}, timeout=5)
            windows_running = data.get("running", False)
            status_246 = "running" if data.get("running") else "stopped"
        except:
            pass
        return jsonify({
            "ok": True,
            "status": {"windows": "running" if windows_running else "stopped", "246": status_246},
            "virtual_ips": {"windows": "10.144.144.3", "246": "10.144.144.1"},
            "windows_running": windows_running,
        })
    except Exception as e:
        return jsonify({"ok": False, "error": str(e)})


@app.route("/api/easytier/toggle", methods=["POST"])
def api_easytier_toggle():
    """EasyTier VPN 开关 — proxy to xmpp_bot on Windows."""
    try:
        body = json.loads(request.data)
        action = body.get("action", "")
        if action not in ("start", "stop"):
            return jsonify({"ok": False, "error": "action must be start|stop"})
        data = _bridge_post("/easytier", {"action": action}, timeout=15)
        return jsonify({"ok": data.get("ok", False), "message": data.get("message", "")})
    except Exception as e:
        return jsonify({"ok": False, "error": str(e)})


@app.route("/api/rdp")
def api_rdp_status():
    """RDP 远程桌面状态 — proxy to xmpp_bot on Windows."""
    try:
        rdp_enabled = False
        tunnel_running = False
        try:
            data = _bridge_post("/rdp", {"action": "status"}, timeout=5)
            rdp_enabled = data.get("rdp_enabled", False)
            tunnel_running = data.get("tunnel_running", False)
        except:
            pass
        return jsonify({
            "ok": True,
            "rdp_enabled": rdp_enabled,
            "tunnel_running": tunnel_running,
            "rdp_port": 3389,
            "tunnel_port": 8080,
            "public_endpoint": "47.115.32.206:8080",
        })
    except Exception as e:
        return jsonify({"ok": False, "error": str(e)})


@app.route("/api/rdp/toggle", methods=["POST"])
def api_rdp_toggle():
    """RDP 远程桌面开关 — proxy to xmpp_bot on Windows."""
    try:
        body = json.loads(request.data)
        action = body.get("action", "")
        if action not in ("start", "stop"):
            return jsonify({"ok": False, "error": "action must be start|stop"})
        data = _bridge_post("/rdp", {"action": action}, timeout=15)
        return jsonify({"ok": data.get("ok", False), "message": data.get("message", "")})
    except Exception as e:
        return jsonify({"ok": False, "error": str(e)})


# ════════════════════════════════════════════════════════════
#  OpenCode Go Usage Monitor — 4个账号用量配额监控 (246 本地采集)
#  See gateway/scripts/specs/usage_monitor.json
# ════════════════════════════════════════════════════════════
_USAGE_STATS_FILE = TEMP_DIR / "usage_stats.json"
_USAGE_COLLECTOR_SCRIPT = _SCRIPT_DIR / "usage_collector.py"
_usage_collector_running = False

@app.route("/api/usage")
def api_usage():
    """直读本地 usage_stats.json（秒级响应，不依赖 Windows bot）"""
    if not _USAGE_STATS_FILE.exists():
        return jsonify({"ok": False, "error": "no data yet (collect never ran)",
                        "last_refresh_iso": None, "accounts": []})
    try:
        with open(str(_USAGE_STATS_FILE), "r", encoding="utf-8") as f:
            return jsonify(json.load(f))
    except Exception as e:
        return jsonify({"ok": False, "error": f"read failed: {e}", "accounts": []})


@app.route("/api/usage/refresh", methods=["POST"])
def api_usage_refresh():
    """触发本地采集（异步 subprocess，立即返回）"""
    global _usage_collector_running
    if _usage_collector_running:
        return jsonify({"ok": True, "message": "collection already in-flight"})
    _usage_collector_running = True

    def _runner():
        global _usage_collector_running
        try:
            log.info("usage: starting local collector subprocess")
            proc = subprocess.run(
                [sys.executable, str(_USAGE_COLLECTOR_SCRIPT)],
                capture_output=True, text=True, timeout=120)
            log.info(f"usage: collector done (rc={proc.returncode}, "
                      f"stdout={len(proc.stdout)}, stderr={len(proc.stderr)})")
            if proc.returncode != 0 and proc.stderr:
                log.warning(f"usage_collector stderr:\n{proc.stderr[-1000:]}")
        except Exception as e:
            log.error(f"usage: collector crash: {e}")
        finally:
            _usage_collector_running = False

    t = threading.Thread(target=_runner, name="usage_collector", daemon=True)
    t.start()
    return jsonify({"ok": True, "message": "collection triggered (~10s), poll /api/usage shortly"})


# ── Auto-collect timer (every 5 min, keeps cookies alive) ──
_USAGE_AUTO_INTERVAL = 300

def _start_usage_auto_timer():
    """后台线程：每 5 分钟自动采集 + cookie 保活。246 自足，不依赖 Windows。"""
    def _loop():
        time.sleep(15)  # initial delay: let dashboard stabilize
        while True:
            try:
                global _usage_collector_running
                if not _usage_collector_running:
                    _usage_collector_running = True
                    proc = subprocess.run(
                        [sys.executable, str(_USAGE_COLLECTOR_SCRIPT)],
                        capture_output=True, text=True, timeout=120)
                    log.info(f"usage auto-timer: rc={proc.returncode}")
                    if proc.returncode != 0 and proc.stderr:
                        log.warning(f"usage auto-timer stderr:\n{proc.stderr[-800:]}")
                    _usage_collector_running = False
            except Exception as e:
                log.error(f"usage auto-timer error: {e}")
                _usage_collector_running = False
            time.sleep(_USAGE_AUTO_INTERVAL)

    t = threading.Thread(target=_loop, name="usage_auto_timer", daemon=True)
    t.start()
    log.info(f"usage auto-timer started (interval={_USAGE_AUTO_INTERVAL}s)")


# ════════════════════════════════════════════════════════════
#  Module Spec — 功能模块 co-located 文档
# ════════════════════════════════════════════════════════════
_SPECS_DIR = _SCRIPT_DIR / "specs"

@app.route("/api/module-spec/<module>")
def api_module_spec(module):
    """返回指定模块的 co-located spec JSON（人看 + AI 看）"""
    spec_file = _SPECS_DIR / f"{module}.json"
    if not spec_file.exists():
        return jsonify({"ok": False, "error": f"spec not found: {module}"})
    try:
        with open(spec_file, "r", encoding="utf-8") as f:
            return jsonify(json.load(f))
    except Exception as e:
        return jsonify({"ok": False, "error": str(e)})


@app.route("/api/module-specs")
def api_module_specs():
    """列出所有可用的 module spec"""
    specs = []
    if _SPECS_DIR.exists():
        for p in sorted(_SPECS_DIR.glob("*.json")):
            try:
                with open(p, "r", encoding="utf-8") as f:
                    data = json.load(f)
                    specs.append({
                        "module": data.get("module", p.stem),
                        "purpose": data.get("purpose", ""),
                        "version": data.get("version", ""),
                    })
            except:
                pass
    return jsonify({"ok": True, "specs": specs})


# ════════════════════════════════════════════════════════════
#  Spec 文档展示
# ════════════════════════════════════════════════════════════
@app.route("/api/spec")
def api_spec():
    """返回开发规范文档内容"""
    # Try multiple possible locations
    candidates = [
        # Git-tracked copy in project docs/ (priority)
        os.path.join(_PROJECT_DIR, "docs", "dev-spec.md"),
        os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))), "projects", "AgentsMeeting", "docs", "dev-spec.md"),
        # Legacy .memory/ locations (gitignored, no history)
        os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))), ".memory", "dev-spec.md"),
        os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), ".memory", "dev-spec.md"),
        os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..", "..", ".memory", "dev-spec.md"),
        os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))), ".memory", "dev-spec.md"),
        os.path.expanduser("~/.memory/dev-spec.md"),
    ]
    spec_path = None
    for c in candidates:
        p = os.path.normpath(c)
        if os.path.exists(p):
            spec_path = p
            break
    if not spec_path:
        return jsonify({"ok": False, "error": "dev-spec.md not found", "content": ""})
    try:
        with open(spec_path, "r", encoding="utf-8") as f:
            content = f.read()
        return jsonify({"ok": True, "content": content, "path": spec_path})
    except Exception as e:
        return jsonify({"ok": False, "error": str(e), "content": ""})


@app.route("/api/spec/history")
def api_spec_history():
    """返回 dev-spec.md 的 git 历史版本"""
    return _git_history_for(".memory/dev-spec.md")


@app.route("/api/prd/history")
def api_prd_history():
    """返回 PRD.md 的 git 历史版本"""
    return _git_history_for("docs/PRD.md")


def _git_history_for(filepath):
    """Helper: run git log for a file and return formatted history"""
    project_root = _PROJECT_DIR
    # For dev-spec.md, also check docs/ variant which is git-tracked
    if filepath == ".memory/dev-spec.md":
        filepath = "docs/dev-spec.md"
    try:
        cmd = ["git", "log", "--format=%h %ai %s", "--", filepath]
        result = subprocess.run(
            cmd,
            cwd=project_root,
            capture_output=True,
            text=True,
            timeout=15,
        )
        if result.returncode == 0 and result.stdout.strip():
            lines = result.stdout.strip().split("\n")
            return jsonify({"ok": True, "log": lines, "count": len(lines)})
        else:
            return jsonify({"ok": True, "log": [], "count": 0})
    except Exception as e:
        return jsonify({"ok": True, "log": [], "count": 0, "error": str(e)})


@app.route("/api/prd")
def api_prd():
    """返回产品需求文档 (PRD) 内容"""
    candidates = [
        os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "docs", "PRD.md"),
        os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "docs", "PRD.md"),
        # venv deployment: ~/projects/AgentsMeeting/docs/PRD.md
        os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))), "projects", "AgentsMeeting", "docs", "PRD.md"),
        os.path.expanduser("~/projects/AgentsMeeting/docs/PRD.md"),
    ]
    prd_path = None
    for c in candidates:
        p = os.path.normpath(c)
        if os.path.exists(p):
            prd_path = p
            break
    if not prd_path:
        return jsonify({"ok": False, "error": "PRD.md not found", "content": ""})
    try:
        with open(prd_path, "r", encoding="utf-8") as f:
            content = f.read()
        return jsonify({"ok": True, "content": content, "path": prd_path})
    except Exception as e:
        return jsonify({"ok": False, "error": str(e), "content": ""})


# ════════════════════════════════════════════════════════════
#  K — 自动测试接口
# ════════════════════════════════════════════════════════════
@app.route("/api/tests")
def api_tests():
    """运行自动测试并返回结果"""
    try:
        from tests_api import run_tests
        return jsonify(run_tests())
    except Exception as e:
        return jsonify({"ok": False, "error": str(e)})


@app.route("/api/platform")
@app.route("/api/health")
def api_health():
    xmpp = _xmpp_health()
    return jsonify({
        "ok": True,
        "time": datetime.now().isoformat(),
        "xmpp_bot_alive": xmpp.get("xmpp_connected", False),
        "ejabberd_alive": xmpp.get("ejabberd_alive", False),
    })


# ============================================================
#  Main
# ============================================================

def main():
    lock = guard("dashboard")
    if not lock.ok:
        log.error(lock.message)
        print(f"[dashboard] {lock.message}")
        sys.exit(1)
    port = int(os.environ.get("DASHBOARD_PORT", 5803))
    log.info(f"Dashboard starting on :{port}")
    print(f"[dashboard] Starting on http://127.0.0.1:{port}")
    _start_usage_auto_timer()
    app.run(host="0.0.0.0", port=port, debug=False, use_reloader=False, threaded=True)


if __name__ == "__main__":
    main()
