1378 lines
57 KiB
Python
1378 lines
57 KiB
Python
# -*- 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, 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)", "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
|
||
svc1 = {"name": "xmpp_bot", "port": 5802, "health": _health_status("http://127.0.0.1:5802/health"),
|
||
"watchdog": True, "pid_lock": True, "type": "core", "depends_on": ["ejabberd"]}
|
||
services.append(svc1)
|
||
# article_processor
|
||
svc2 = {"name": "article_processor", "port": 5810, "health": _health_status("http://127.0.0.1:5810/health"),
|
||
"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: 检查 systemd timer（如已部署）或 crontab
|
||
for name in expected_tasks:
|
||
try:
|
||
r = subprocess.run(["systemctl", "list-timers", "--all", "--no-pager"],
|
||
capture_output=True, text=True, timeout=5)
|
||
if name in r.stdout:
|
||
result["tasks"].append({"name": name, "status": "timer_ok"})
|
||
else:
|
||
# 查 crontab
|
||
r2 = subprocess.run(["crontab", "-l"], capture_output=True, text=True, timeout=5)
|
||
if name in r2.stdout:
|
||
result["tasks"].append({"name": name, "status": "cron_ok"})
|
||
else:
|
||
result["tasks"].append({"name": name, "status": "not_deployed"})
|
||
except:
|
||
result["tasks"].append({"name": name, "status": "not_deployed", "note": "无systemd/cron"})
|
||
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)})
|
||
|
||
|
||
# ════════════════════════════════════════════════════════════
|
||
# F — 期望状态 vs 实际状态
|
||
# ════════════════════════════════════════════════════════════
|
||
@app.route("/api/expected")
|
||
def api_expected():
|
||
"""期望状态矩阵：应该运行的 vs 实际运行的"""
|
||
expected = [
|
||
{"name": "xmpp_bot", "port": 5802, "expected": "running", "critical": True},
|
||
{"name": "article_processor", "port": 5810, "expected": "running", "critical": True},
|
||
{"name": "dashboard", "port": 5803, "expected": "running", "critical": True},
|
||
{"name": "watchdog", "expected": "running", "critical": True},
|
||
{"name": "agents-health-check", "expected": "scheduled (5min)", "critical": False},
|
||
{"name": "agents-daily-health", "expected": "scheduled (daily 08:00)", "critical": False},
|
||
{"name": "agents-todo-executor", "expected": "scheduled (10min)", "critical": False},
|
||
]
|
||
actual = {}
|
||
for e in expected:
|
||
name = e["name"]
|
||
port = e.get("port")
|
||
if port:
|
||
actual[name] = "running" if port_open(port) else "stopped"
|
||
elif name == "watchdog":
|
||
if sys.platform == "win32":
|
||
try:
|
||
r = subprocess.run(
|
||
["tasklist", "/FI", "IMAGENAME eq python.exe", "/NH"],
|
||
capture_output=True, text=True, timeout=5,
|
||
creationflags=subprocess.CREATE_NO_WINDOW,
|
||
)
|
||
actual[name] = "running" if "python" in r.stdout else "stopped"
|
||
except:
|
||
actual[name] = "unknown"
|
||
else:
|
||
try:
|
||
r = subprocess.run(
|
||
["pgrep", "-f", "xmpp_watchdog|health_check"],
|
||
capture_output=True, text=True, timeout=5)
|
||
actual[name] = "running" if r.stdout.strip() else "stopped"
|
||
except:
|
||
# pgrep not available
|
||
r = subprocess.run(
|
||
["ps", "aux"], capture_output=True, text=True, timeout=5)
|
||
has = "watchdog" in r.stdout or "health_check" in r.stdout
|
||
actual[name] = "running" if has else "stopped"
|
||
elif "scheduled" in e["expected"]:
|
||
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 = "Ready" in r.stdout or "\u5c31\u7eea" in r.stdout
|
||
actual[name] = "scheduled" if ready else "missing"
|
||
except:
|
||
actual[name] = "error"
|
||
else:
|
||
# Linux: 检查 systemd timer 或 crontab
|
||
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"
|
||
return jsonify({"expected": expected, "actual": actual})
|
||
|
||
|
||
def port_open(port):
|
||
"""Check if a port is listening. Works on both Linux and Windows."""
|
||
try:
|
||
import socket
|
||
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||
s.settimeout(2)
|
||
result = s.connect_ex(("127.0.0.1", 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()
|