Files
douyi_guaji_main/gui/web_gui.py
T

1924 lines
76 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import json
import os
import re
import shutil
import subprocess
import sys
import threading
import time
from http import HTTPStatus
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from typing import Optional
from urllib.parse import parse_qs, urlparse
import path_config
BASE_DIR = path_config.PROJECT_ROOT
CONFIG_PATH = path_config.get_config_path()
WEBUI_DIR = path_config.get_webui_dir()
# ANSI转义序列清理正则表达式
_ANSI_ESCAPE_RE = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
def strip_ansi_escape_codes(text: str) -> str:
"""移除字符串中的ANSI转义序列(颜色代码等)。"""
if not isinstance(text, str):
return str(text)
return _ANSI_ESCAPE_RE.sub("", text)
def find_adb_executable() -> str:
adb = shutil.which("adb")
if adb:
return adb
localapp = os.environ.get("LOCALAPPDATA") or ""
candidates = []
if localapp:
candidates.append(os.path.join(localapp, "platform-tools", "adb.exe"))
userprofile = os.environ.get("USERPROFILE") or ""
if userprofile:
candidates.append(
os.path.join(userprofile, "AppData", "Local", "platform-tools", "adb.exe")
)
for p in candidates:
if os.path.exists(p):
return p
return ""
def list_adb_devices(adb_exe: str) -> list[str]:
try:
if not adb_exe:
return []
proc = subprocess.run(
[adb_exe, "devices", "-l"],
capture_output=True,
text=True,
encoding="utf-8",
errors="replace",
)
except FileNotFoundError:
return []
text = (proc.stdout or "") + "\n" + (proc.stderr or "")
pattern = r"(\b(?:[0-9]{1,3}(?:\.[0-9]{1,3}){3}(?::[0-9]+)?|[A-Za-z0-9]{8,})\b)\s*device\b"
return re.findall(pattern, text)
def read_config() -> dict:
if not os.path.exists(CONFIG_PATH):
return {}
with open(CONFIG_PATH, "r", encoding="utf-8") as f:
return json.load(f)
def write_config(cfg: dict) -> None:
with open(CONFIG_PATH, "w", encoding="utf-8") as f:
json.dump(cfg, f, ensure_ascii=False, indent=4)
f.write("\n")
class ProcRunner:
def __init__(self) -> None:
self._proc: Optional[subprocess.Popen] = None
self._lock = threading.Lock()
self._log: list[str] = []
self._log_capacity: int = (
10000 # 0=不限制(可能占用大量内存),增加到10000避免日志被过早截断
)
self._log_file_enabled: bool = True
self._log_file_path: str = path_config.get_log_file_path()
self._start_ts: Optional[float] = None
self._last_log_ts: Optional[float] = None
self._exit_code: Optional[int] = None
self._pid: Optional[int] = None
# 运行统计(基于 stdout 日志解析)
self._counters: dict[str, int] = {}
self._fudai_last: dict[str, object] = {
"content": "",
"countdown": "",
"participants": None,
"copies": None,
"prize_value_yuan": None,
"updated_ts": None,
}
# 事件流(用于趋势/分布/Top 统计),保留最近 N 条
self._events: list[dict] = []
self._events_cap: int = 5000
# 中奖记录(用于展示“福袋中奖内容”),保留最近 N 条
self._wins: list[dict] = []
self._wins_cap: int = 200
def _reload_log_settings(self) -> None:
"""从 config.json 读取日志设置:统一文件路径 + Web GUI 内存缓存上限。"""
try:
cfg = read_config()
except Exception:
cfg = {}
try:
self._log_file_enabled = bool(cfg.get("log_unified_enabled", True))
except Exception:
self._log_file_enabled = True
path = str(cfg.get("log_unified_path") or "logs/unified.log")
if not os.path.isabs(path):
path = os.path.join(path_config.PROJECT_ROOT, path)
self._log_file_path = path
try:
cap = int(cfg.get("webgui_log_capacity", 10000))
except Exception:
cap = 10000
self._log_capacity = cap
def _append_to_unified_file(self, line: str) -> None:
if not self._log_file_enabled:
return
try:
os.makedirs(os.path.dirname(self._log_file_path), exist_ok=True)
except Exception as e:
# 目录创建失败,可能是权限问题,但继续尝试写入(可能目录已存在)
pass
try:
# 使用 utf-8-sig:文件首次创建时会写入 BOM,避免 Windows PowerShell 误按 ANSI 读取导致中文乱码
with open(
self._log_file_path, "a", encoding="utf-8-sig", errors="replace"
) as f:
f.write(line + "\n")
f.flush() # 确保立即写入磁盘,避免缓冲区延迟导致日志丢失
except PermissionError as e:
# 权限错误,只输出一次警告避免刷屏
if not hasattr(self, "_log_permission_warned"):
print(f"[WEB_GUI] 警告:日志文件写入权限错误: {self._log_file_path}")
print(f"[WEB_GUI] 错误详情: {e}")
self._log_permission_warned = True
except Exception as e:
# 其他文件写失败不应影响主流程,但记录第一次错误以便调试
if not hasattr(self, "_log_write_error_warned"):
print(f"[WEB_GUI] 警告:日志文件写入失败: {self._log_file_path}")
print(f"[WEB_GUI] 错误详情: {e}")
self._log_write_error_warned = True
def _inc(self, key: str, n: int = 1) -> None:
self._counters[key] = int(self._counters.get(key, 0)) + int(n)
def _record_event(self, typ: str, meta: Optional[dict] = None) -> None:
ev = {
"ts": time.time(),
"type": str(typ),
"meta": meta or {},
}
self._events.append(ev)
if len(self._events) > self._events_cap:
self._events = self._events[-self._events_cap :]
def _record_win(self) -> None:
item = {
"ts": time.time(),
**self._snapshot_fudai(),
}
self._wins.append(item)
if len(self._wins) > self._wins_cap:
self._wins = self._wins[-self._wins_cap :]
@staticmethod # type: ignore[misc]
def _parse_countdown_seconds(text: str) -> Optional[int]:
t = str(text or "").strip()
if not t:
return None
# 优先解析 hh:mm:ss / mm:ss
if ":" in t:
parts = [p for p in t.split(":") if p != ""]
try:
nums = [int(p) for p in parts]
except Exception:
nums = []
if len(nums) == 2:
mm, ss = nums
return max(0, mm * 60 + ss)
if len(nums) == 3:
hh, mm, ss = nums
return max(0, hh * 3600 + mm * 60 + ss)
# 解析中文:xx小时xx分xx秒
total = 0
m = re.search(r"(\d+)\s*小时", t)
if m:
total += int(m.group(1)) * 3600
m = re.search(r"(\d+)\s*分", t)
if m:
total += int(m.group(1)) * 60
m = re.search(r"(\d+)\s*秒", t)
if m:
total += int(m.group(1))
if total > 0:
return total
# 兜底:纯数字当秒
if re.fullmatch(r"\d+", t):
try:
return int(t)
except Exception:
return None
return None
@staticmethod # type: ignore[misc]
def _bucket(value: float, edges: list[float]) -> str:
# edges 例如 [0,10,50,100] => 0-10,10-50,50-100,100+
if not edges:
return "all"
for i in range(len(edges) - 1):
a = edges[i]
b = edges[i + 1]
if value >= a and value < b:
return f"{a:g}-{b:g}"
return f"{edges[-1]:g}+"
@staticmethod # type: ignore[misc]
def _inc_map(m: dict, k: str, n: int = 1) -> None:
m[k] = int(m.get(k, 0)) + int(n)
def _snapshot_fudai(self) -> dict:
return {
"content": self._fudai_last.get("content") or "",
"countdown": self._fudai_last.get("countdown") or "",
"participants": self._fudai_last.get("participants"),
"copies": self._fudai_last.get("copies"),
"prize_value_yuan": self._fudai_last.get("prize_value_yuan"),
}
def _update_stats_from_line(self, line: str) -> None:
s = (line or "").strip()
if not s:
return
# --- 统一日志格式解析:提取traceId和MDC信息 ---
# 格式:时间戳(毫秒) - [级别] - [线程名] - [模块名:函数名:行号] - [traceId:xxx] - 消息 | MDC: 上下文信息
trace_id_match = re.search(r"\[traceId:([^\]]+)\]", s)
if trace_id_match:
trace_id = trace_id_match.group(1)
# 存储当前traceId(用于统计和显示)
if not hasattr(self, "_current_trace_id"):
self._current_trace_id = trace_id
elif trace_id != "N/A":
self._current_trace_id = trace_id
# 提取MDC信息
mdc_match = re.search(r"MDC:\s*([^|]+)", s)
if mdc_match:
mdc_str = mdc_match.group(1).strip()
# 解析MDC键值对
mdc_pairs = re.findall(r"(\w+)=([^,\s]+)", mdc_str)
for key, value in mdc_pairs:
# 存储MDC信息(可用于统计)
if not hasattr(self, "_mdc_context"):
self._mdc_context = {}
self._mdc_context[key] = value
# --- 福袋:抽取"最近一次"识别到的信息 ---
# 支持多种格式:旧格式"福袋内容:"和新格式"字段_内容="或"内容="
content_extracted = False
if "福袋内容:" in s:
self._fudai_last["content"] = (
s.split("福袋内容:", 1)[1].strip().split()[0]
) # 只取第一个词,避免包含后续字段
self._fudai_last["updated_ts"] = time.time()
content_extracted = True
else:
# 新格式:字段_内容= 或 内容=
m = re.search(r"(?:字段_)?内容[=:]\s*([^\s]+)", s)
if m:
self._fudai_last["content"] = m.group(1).strip()
self._fudai_last["updated_ts"] = time.time()
content_extracted = True
if content_extracted:
self._inc("fudai_seen")
self._record_event("fudai_seen", self._snapshot_fudai())
# 参与人数:支持多种格式
m = re.search(r"(?:字段_)?参与人数[=:]?\s*(\d+)", s)
if not m:
m = re.search(r"参与人数:\s*(\d+)", s)
if m:
self._fudai_last["participants"] = int(m.group(1))
self._fudai_last["updated_ts"] = time.time()
# 福袋份数:支持多种格式
m = re.search(r"(?:字段_)?份数[=:]?\s*(\d+)", s)
if not m:
m = re.search(r"福袋份数:\s*(\d+)", s)
if m:
self._fudai_last["copies"] = int(m.group(1))
self._fudai_last["updated_ts"] = time.time()
# 倒计时:支持多种格式
if "倒计时时间:" in s:
self._fudai_last["countdown"] = (
s.split("倒计时时间:", 1)[1].strip().split()[0]
)
self._fudai_last["updated_ts"] = time.time()
else:
m = re.search(r"(?:字段_)?倒计时[=:]?\s*([^\s]+)", s)
if m:
self._fudai_last["countdown"] = m.group(1).strip()
self._fudai_last["updated_ts"] = time.time()
# 奖品价值:支持多种格式
m = re.search(
r"(?:字段_)?(?:价值|价值元|奖品价值)[=:]?\s*([0-9]+(?:\.[0-9]+)?)", s
)
if not m:
m = re.search(r"奖品价值:\s*([0-9]+(?:\.[0-9]+)?)\s*元", s)
if m:
try:
self._fudai_last["prize_value_yuan"] = float(m.group(1))
self._fudai_last["updated_ts"] = time.time()
except Exception:
pass
# --- 福袋:关键流程计数 ---
if "点击打开福袋详情" in s or ("[流程]" in s and "检测到福袋图标并点击" in s):
self._inc("fudai_open_detail")
self._record_event("fudai_open_detail", self._snapshot_fudai())
# 兼容新结构化中文日志: [参与] 动作=点击参与
if "点击参与抽奖" in s or (
"[参与]" in s and ("动作=点击参与" in s or "动作=参与" in s)
):
self._inc("fudai_click_attend")
self._record_event("fudai_click_attend", self._snapshot_fudai())
# 参与成功/已参与:兼容旧文本 & 新结构化字段
if (
"已经参与,等待开奖" in s
or "已经参与,等待看播时间凑齐开奖" in s
or "已参与成功(或看播中)" in s
or (
"[参与]" in s
and ("结果=已参与" in s or "结果=看播中" in s or "结果=参与成功" in s)
)
or ("[参与]" in s and "已参与" in s and "等待开奖" in s)
or ("预约回退后直接参与" in s and "参与成功" in s)
):
self._inc("fudai_attend_ok")
self._record_event("fudai_attend_ok", self._snapshot_fudai())
if "参与抽奖失败" in s or ("[参与]" in s and "结果=失败" in s):
self._inc("fudai_attend_fail")
self._record_event("fudai_attend_fail", self._snapshot_fudai())
# --- 福袋:跳过/过滤原因 ---
if "参与人数" in s and "< 阈值" in s and "不参与" in s:
self._inc("fudai_skip_participants_low")
# 提取实际参与人数和阈值
meta = self._snapshot_fudai()
m = re.search(r"参与人数[=:]?\s*(\d+)", s)
if m:
try:
meta["participants"] = int(m.group(1))
except Exception:
pass
m = re.search(r"阈值[=:]?\s*(\d+)", s)
if m:
try:
meta["threshold"] = int(m.group(1))
except Exception:
pass
self._record_event("fudai_skip", {"reason": "participants_low", **meta})
if "参与人数" in s and "> 阈值" in s and "不参与" in s:
self._inc("fudai_skip_participants_high")
# 提取实际参与人数和阈值
meta = self._snapshot_fudai()
m = re.search(r"参与人数[=:]?\s*(\d+)", s)
if m:
try:
meta["participants"] = int(m.group(1))
except Exception:
pass
m = re.search(r"阈值[=:]?\s*(\d+)", s)
if m:
try:
meta["threshold"] = int(m.group(1))
except Exception:
pass
self._record_event("fudai_skip", {"reason": "participants_high", **meta})
if "奖品价值" in s and "< 阈值" in s and "不参与" in s:
self._inc("fudai_skip_value_low")
# 提取实际价值和阈值
meta = self._snapshot_fudai()
m = re.search(r"(?:奖品)?价值[=:]?\s*([0-9]+(?:\.[0-9]+)?)", s)
if m:
try:
meta["prize_value_yuan"] = float(m.group(1))
except Exception:
pass
m = re.search(r"阈值[=:]?\s*([0-9]+(?:\.[0-9]+)?)", s)
if m:
try:
meta["threshold"] = float(m.group(1))
except Exception:
pass
self._record_event("fudai_skip", {"reason": "value_low", **meta})
if "福袋内容不理想" in s or ("[筛选]" in s and "内容" in s and "黑名单" in s):
self._inc("fudai_skip_content")
self._record_event(
"fudai_skip", {"reason": "content", **self._snapshot_fudai()}
)
if "抽奖倒计时时间小于" in s and "不参与" in s:
self._inc("fudai_skip_countdown_short")
# 提取倒计时秒数
meta = self._snapshot_fudai()
m = re.search(r"(\d+)\s*秒", s)
if m:
try:
meta["countdown_seconds"] = int(m.group(1))
except Exception:
pass
self._record_event("fudai_skip", {"reason": "countdown_short", **meta})
if "抽奖倒计时时间大于" in s and "暂不参与" in s:
self._inc("fudai_skip_countdown_long")
# 提取倒计时秒数
meta = self._snapshot_fudai()
m = re.search(r"(\d+)\s*秒", s)
if m:
try:
meta["countdown_seconds"] = int(m.group(1))
except Exception:
pass
self._record_event("fudai_skip", {"reason": "countdown_long", **meta})
# 看播门槛:默认不参与(新结构化日志)
if (
"需要看播时长:默认不参与" in s
or "需要开始观看/看播门槛:默认不参与" in s
or ("[参与]" in s and "结果=看播门槛" in s)
):
self._inc("fudai_skip_watch_required")
self._record_event(
"fudai_skip", {"reason": "watch_required", **self._snapshot_fudai()}
)
if "打开福袋异常" in s or ("[流程]" in s and "打开福袋异常" in s):
self._inc("fudai_open_error")
self._record_event("fudai_open_error", self._snapshot_fudai())
if "超过10次点击福袋无法打开详情" in s:
self._inc("fudai_open_error_too_many")
self._record_event("fudai_open_error_too_many", self._snapshot_fudai())
# 倒计时大于阈值但价值达到高价值阈值,记录预约
if (
"[流程]" in s and "倒计时大于阈值,但价值达到高价值阈值,记录预约" in s
) or ("[参与]" in s and "倒计时大于阈值,但价值达到高价值阈值,记录预约" in s):
self._inc("fudai_reserved_high_value")
# 提取价值和倒计时信息
meta = self._snapshot_fudai()
m = re.search(r"(?:价值|价值元)[=:]?\s*([0-9]+(?:\.[0-9]+)?)", s)
if m:
try:
meta["prize_value_yuan"] = float(m.group(1))
except Exception:
pass
m = re.search(r"(?:剩余|倒计时)[=:]?\s*(\d+)\s*秒", s)
if m:
try:
meta["remain_seconds"] = int(m.group(1))
except Exception:
pass
self._record_event("fudai_reserved_high_value", meta)
# --- 错误和异常统计(与 gui_core.py 保持一致) ---
if "[错误]" in s or "[异常]" in s or "错误=" in s or "异常=" in s:
self._inc("error_total")
error_type = "unknown"
if "UnboundLocalError" in s:
error_type = "UnboundLocalError"
self._inc("error_unbound_local")
elif "AttributeError" in s:
error_type = "AttributeError"
self._inc("error_attribute")
elif "KeyError" in s:
error_type = "KeyError"
self._inc("error_key")
elif "ValueError" in s:
error_type = "ValueError"
self._inc("error_value")
elif "TypeError" in s:
error_type = "TypeError"
self._inc("error_type")
elif "TimeoutError" in s or "超时" in s:
error_type = "TimeoutError"
self._inc("error_timeout")
elif "ConnectionError" in s or ("连接" in s and "失败" in s):
error_type = "ConnectionError"
self._inc("error_connection")
elif "OCR" in s and ("失败" in s or "错误" in s):
error_type = "OCR_Error"
self._inc("error_ocr")
elif "截图" in s and ("失败" in s or "错误" in s):
error_type = "Screenshot_Error"
self._inc("error_screenshot")
elif "识别" in s and ("失败" in s or "错误" in s):
error_type = "Detection_Error"
self._inc("error_detection")
self._record_event("error", {"error_type": error_type})
if "阶段诊断" in s and ("失败" in s or "错误" in s or "异常" in s):
self._inc("error_stage_diagnosis")
self._record_event("error_stage_diagnosis", {})
if "读取福袋详情" in s and ("失败" in s or "错误" in s or "异常" in s):
self._inc("error_read_detail")
self._record_event("error_read_detail", {})
if "load_config" in s and ("失败" in s or "错误" in s or "异常" in s):
self._inc("error_config_load")
self._record_event("error_config_load", {})
if ("预约队列状态文件" in s or "reservations.json" in s) and (
"失败" in s or "错误" in s
):
self._inc("error_state_file")
self._record_event("error_state_file", {})
if "直播间检测" in s and ("失败" in s or "错误" in s):
self._inc("error_live_room_detect")
self._record_event("error_live_room_detect", {})
if "查找福袋" in s and ("失败" in s or "错误" in s or "未找到" in s):
self._inc("error_fudai_find")
self._record_event("error_fudai_find", {})
# --- 粉丝团门槛 ---
if "需要加入粉丝团才能参与" in s or ("[参与]" in s and "结果=需要粉丝团" in s):
self._inc("fansclub_required")
self._record_event("fansclub_required", self._snapshot_fudai())
if "未启用自动加入粉丝团" in s:
self._inc("fansclub_manual_needed")
self._record_event("fansclub_manual_needed", self._snapshot_fudai())
if "粉丝团门槛仍未解决" in s or ("[参与]" in s and "粉丝团门槛仍未解决" in s):
self._inc("fansclub_unresolved")
self._record_event("fansclub_unresolved", self._snapshot_fudai())
# --- 预约队列/回退校验 ---
if (
"[预约]" in s and "回退校验通过" in s
) or "回退校验通过:已回到目标直播间" in s:
self._inc("reservation_back_verify_ok")
self._record_event("reservation_back_verify_ok", {})
if ("[预约]" in s and "回退校验失败" in s) or "回退校验失败" in s:
self._inc("reservation_back_verify_fail")
self._record_event("reservation_back_verify_fail", {})
if (
"[预约]" in s and "预约队列已满,丢弃最低价值" in s
) or "预约队列已满,丢弃最低价值" in s:
self._inc("reservation_drop_low_value")
self._record_event("reservation_drop_low_value", {})
if ("[预约]" in s and "清空预约队列" in s) or "清空预约队列" in s:
self._inc("reservation_clear")
self._record_event("reservation_clear", {})
# --- 预约记录相关(与 gui_core.py 保持一致) ---
if (
"[预约]" in s and "已记录高价值福袋" in s
) or "record_high_value_reservation:已记录高价值福袋" in s:
self._inc("reservation_recorded")
# 提取预约价值:支持多种格式
value = None
m = re.search(r"(?:字段_)?(?:价值|价值元|value)[=:]?\s*(\d+(?:\.\d+)?)", s)
if not m:
m = re.search(r"value[=:]?\s*(\d+(?:\.\d+)?)", s)
if m:
try:
value = float(m.group(1))
except Exception:
pass
# 提取开奖时间
future_ts = None
m = re.search(r"(?:字段_)?(?:开奖时间|future|future_ts)[=:]?\s*(\d+)", s)
if m:
try:
future_ts = int(m.group(1))
except Exception:
pass
# 提取直播间名称
room_title = None
m = re.search(
r"(?:字段_)?(?:直播间|直播间名|room_title)[=:]?\s*([^\s]+)", s
)
if m:
room_title = m.group(1).strip()
meta = self._snapshot_fudai()
if value is not None:
meta["prize_value_yuan"] = value
if future_ts is not None:
meta["future_ts"] = future_ts
if room_title:
meta["room_title"] = room_title
self._record_event("reservation_recorded", meta)
if (
"[预约]" in s and "进入预约参与窗口" in s
) or "进入预约参与窗口,准备回退到目标直播间" in s:
self._inc("reservation_window_entered")
self._record_event("reservation_window_entered", {})
if (
("[预约]" in s and "已回退到目标直播间" in s)
or "已回退到目标直播间" in s
or ("[预约]" in s and "已回退到最早开奖的预约直播间" in s)
):
self._inc("reservation_back_success")
# 提取回退信息
meta = {}
m = re.search(r"(?:字段_)?(?:需回退次数|back_times)[=:]?\s*(\d+)", s)
if m:
try:
meta["back_times"] = int(m.group(1))
except Exception:
pass
self._record_event("reservation_back_success", meta)
if ("[预约]" in s and "时间窗口未到" in s) or "时间窗口未到,跳过回退" in s:
self._inc("reservation_window_not_reached")
self._record_event("reservation_window_not_reached", {})
if (
"[预约]" in s and "已明显错过开奖时间" in s
) or "已明显错过开奖时间,清理过期预约" in s:
self._inc("reservation_expired")
self._record_event("reservation_expired", {})
if (
"[预约]" in s and "预约队列为空" in s
) or "process_reservation_attend_window:预约队列为空" in s:
self._inc("reservation_queue_empty")
if ("[预约]" in s and "锁定期未结束" in s) or "锁定期未结束" in s:
self._inc("reservation_locked")
self._record_event("reservation_locked", {})
if "[预约]" in s and "已回退到第一个直播间" in s:
self._inc("reservation_back_to_first")
self._record_event("reservation_back_to_first", {})
if "[预约]" in s and "run_once_basic:检查预约回退触发条件" in s:
self._inc("reservation_check_triggered")
if (
("[预约]" in s and "队列已满" in s)
or "handle_queue_full_wait_at_earliest" in s
or ("[预约]" in s and "队列已满,回退到最早开奖的预约直播间" in s)
):
self._inc("reservation_queue_full_wait")
self._record_event("reservation_queue_full_wait", {})
# 回退后直接参与
if ("[预约]" in s and "预约回退后直接参与" in s) or "预约回退后直接参与" in s:
self._inc("reservation_back_direct_attend")
self._record_event("reservation_back_direct_attend", {})
# 队列满回退后设置参与标志
if "[预约]" in s and "队列满回退后,直接设置参与标志" in s:
self._inc("reservation_queue_full_back_attend")
self._record_event("reservation_queue_full_back_attend", {})
# 通过相似度匹配识别重复预约
if "[预约]" in s and "通过相似度匹配识别为重复预约" in s:
self._inc("reservation_duplicate_detected")
self._record_event("reservation_duplicate_detected", {})
# --- 开奖结果 ---
if "没有抽中" in s and "关闭弹窗" in s:
self._inc("fudai_result_no_win")
self._record_event("fudai_result_no_win", self._snapshot_fudai())
if (
"恭喜中奖了" in s
or "检测到中奖结果" in s
or ("[开奖结果]" in s and "中奖" in s)
):
self._inc("fudai_result_win")
# 提取中奖信息
meta = self._snapshot_fudai()
m = re.search(r"(?:奖品|商品)[=:]?\s*([^\s]+)", s)
if m:
meta["prize"] = m.group(1).strip()
self._record_event("fudai_result_win", meta)
self._record_win()
if "福袋商品下单成功" in s or ("[开奖结果]" in s and "下单成功" in s):
self._inc("fudai_order_success")
self._record_event("fudai_order_success", self._snapshot_fudai())
# 等待开奖(只在设置等待开奖标志时计数,避免重复计数)
# 注意:不要匹配"已经参与,等待开奖",因为那已经在参与成功时计数了
if ("[参与]" in s and "参与成功,设置等待开奖标志" in s) or (
"[参与]" in s and "设置等待开奖标志" in s
):
self._inc("fudai_waiting_lottery")
# 提取剩余秒数
meta = self._snapshot_fudai()
m = re.search(r"(?:剩余|倒计时|remain_seconds)[=:]?\s*(\d+)", s)
if m:
try:
meta["remain_seconds"] = int(m.group(1))
except Exception:
pass
self._record_event("fudai_waiting_lottery", meta)
# --- 直播间切换(按原因粗分) ---
if "上划切换直播间" in s or ("[操作]" in s and "上滑切换直播间" in s):
self._inc("switch_room")
meta_reason = "unknown"
if "无福袋" in s:
self._inc("switch_room_no_fudai")
meta_reason = "no_fudai"
elif "参与人数" in s:
self._inc("switch_room_participants")
meta_reason = "participants"
elif "奖品价值" in s:
self._inc("switch_room_value")
meta_reason = "value"
elif "内容不理想" in s:
self._inc("switch_room_content")
meta_reason = "content"
elif "倒计时" in s:
self._inc("switch_room_countdown")
meta_reason = "countdown"
elif "参与抽奖失败" in s:
self._inc("switch_room_attend_fail")
meta_reason = "attend_fail"
elif "记录预约后" in s:
self._inc("switch_room_after_reservation")
meta_reason = "after_reservation"
elif "锁定期内" in s:
self._inc("switch_room_locked")
meta_reason = "locked"
self._record_event(
"switch_room", {"reason": meta_reason, **self._snapshot_fudai()}
)
# --- 阶段诊断统计 ---
if "[阶段诊断]" in s or "阶段诊断" in s:
if "阶段诊断完成" in s:
self._inc("stage_diagnosis_complete")
# 提取阶段和耗时
meta = {}
m = re.search(r"阶段[=:]?\s*(\w+)", s)
if m:
meta["stage"] = m.group(1)
m = re.search(r"耗时[=:]?\s*([0-9]+(?:\.[0-9]+)?)\s*秒", s)
if m:
try:
meta["elapsed_seconds"] = float(m.group(1))
except Exception:
pass
m = re.search(r"分数[=:]?\s*([0-9]+(?:\.[0-9]+)?)", s)
if m:
try:
meta["score"] = float(m.group(1))
except Exception:
pass
self._record_event("stage_diagnosis_complete", meta)
elif "阶段诊断失败" in s or "阶段诊断错误" in s:
self._inc("stage_diagnosis_failed")
self._record_event("stage_diagnosis_failed", {})
# --- OCR识别统计 ---
if "[福袋]" in s and "OCR识别" in s:
self._inc("ocr_attempt")
if "识别成功" in s or "识别完成" in s:
self._inc("ocr_success")
elif "识别失败" in s or "识别错误" in s:
self._inc("ocr_failed")
# --- 性能统计 ---
m = re.search(r"耗时[=:]?\s*([0-9]+(?:\.[0-9]+)?)\s*秒", s)
if m:
try:
elapsed = float(m.group(1))
# 记录耗时较长的操作
if elapsed > 5.0:
self._inc("slow_operation")
self._record_event(
"slow_operation",
{"elapsed_seconds": elapsed, "operation": s[:100]},
)
except Exception:
pass
# --- 详情识别统计 ---
if ("[福袋详情]" in s and "识别" in s) or "识别福袋详情" in s:
self._inc("fudai_detail_read_attempt")
if (
"识别成功" in s
or "识别完成" in s
or "read_fudai_detail_once完成(成功)" in s
):
self._inc("fudai_detail_read_success")
# 提取任务数量
meta = {}
m = re.search(r"(?:任务数量|task_count)[=:]?\s*(\d+)", s)
if m:
try:
meta["task_count"] = int(m.group(1))
except Exception:
pass
self._record_event("fudai_detail_read_success", meta)
elif "识别失败" in s or "识别错误" in s:
self._inc("fudai_detail_read_failed")
self._record_event("fudai_detail_read_failed", {})
# --- 福袋查找统计 ---
if "[福袋查找]" in s or "查找福袋" in s:
if "检测完成" in s and "命中" in s:
self._inc("fudai_find_success")
elif "检测完成" in s and "未找到" in s:
self._inc("fudai_find_not_found")
elif "等待超时" in s:
self._inc("fudai_find_timeout")
# --- 回退操作统计 ---
if ("[预约]" in s and "回退" in s) or "回退到" in s:
if "回退完成" in s or "回退成功" in s:
self._inc("reservation_back_operation")
# 提取回退次数
meta = {}
m = re.search(r"(?:回退|back_times)[=:]?\s*(\d+)", s)
if m:
try:
meta["back_times"] = int(m.group(1))
except Exception:
pass
self._record_event("reservation_back_operation", meta)
# --- 性能:进入直播间到识别福袋耗时 ---
m = re.search(
r"进入直播间到识别福袋耗时:\s*([0-9]+(?:\.[0-9]+)?)\s*秒(?:\s*进入原因=(.*))?",
s,
)
if m:
try:
secs = float(m.group(1))
except Exception:
secs = None
reason = str(m.group(2) or "")
# 记录为事件,便于后续做分布/趋势分析
self._record_event(
"enter_to_fudai_seen",
{"secs": secs, "enter_reason": reason, **self._snapshot_fudai()},
)
# 同时做一个计数器
try:
self._inc("enter_to_fudai_seen")
except Exception:
pass
def is_running(self) -> bool:
with self._lock:
return self._proc is not None and self._proc.poll() is None
def get_reservations(self) -> dict:
"""获取当前预约队列信息(来自子进程写入的 douyin/core/state/reservations.json)。"""
if hasattr(path_config, "get_reservations_path"):
try:
path = path_config.get_reservations_path()
except Exception:
path = os.path.join(
(
path_config.PROJECT_ROOT
if hasattr(path_config, "PROJECT_ROOT")
else os.getcwd()
),
"douyin",
"state",
"reservations.json",
)
else:
path = os.path.join(os.getcwd(), "douyin", "state", "reservations.json")
try:
if os.path.exists(path):
with open(path, "r", encoding="utf-8") as f:
data = json.load(f)
if isinstance(data, dict):
return data
except Exception:
return {
"reservations": [],
"room_pos": 0,
"updated_ts": 0.0,
"reason": "state_read_or_parse_failed",
}
return {
"reservations": [],
"room_pos": 0,
"updated_ts": 0.0,
"reason": "no_state_file",
}
def get_high_value_rooms(self) -> dict:
"""获取永久记录的高价值直播间列表(来自 state/high_value_rooms.json)。"""
path = path_config.get_high_value_rooms_path()
try:
if os.path.exists(path):
with open(path, "r", encoding="utf-8") as f:
data = json.load(f)
if isinstance(data, dict):
return data
if isinstance(data, list):
return {
"updated_ts": 0.0,
"reason": "legacy_list",
"total": len(data),
"rooms": data,
}
except Exception:
return {
"updated_ts": 0.0,
"reason": "state_read_or_parse_failed",
"total": 0,
"rooms": [],
}
return {"updated_ts": 0.0, "reason": "no_state_file", "total": 0, "rooms": []}
def stop(self) -> None:
with self._lock:
p = self._proc
if p is None or p.poll() is not None:
return
self._append_log("[网页] 停止:终止进程")
try:
p.terminate()
p.wait(timeout=5)
except Exception:
try:
p.kill()
except Exception:
pass
# 清理进程引用,避免后续 stop/状态查询混淆
with self._lock:
try:
self._proc = None
self._pid = None
except Exception:
pass
self._append_log("[网页] 停止:已尝试终止并清理进程引用")
def _append_log(self, line: str) -> None:
# 清理ANSI转义序列,避免在Web界面显示异常字符
line = strip_ansi_escape_codes(line)
# 先写入统一文件:不受内存容量影响
self._append_to_unified_file(line)
with self._lock:
self._log.append(line)
self._last_log_ts = time.time()
# 在持锁状态内更新统计,避免并发读写 counters
try:
self._update_stats_from_line(line)
except Exception:
pass
cap = int(self._log_capacity or 0)
if cap > 0 and len(self._log) > cap:
self._log = self._log[-cap:]
def get_stats(self, include_events: bool = False) -> dict:
with self._lock:
running = self._proc is not None and self._proc.poll() is None
pid = self._pid
start_ts = self._start_ts
last_log_ts = self._last_log_ts
exit_code = self._exit_code
log_len = len(self._log)
counters = dict(self._counters)
fudai_last = dict(self._fudai_last)
events = list(self._events)
wins = list(self._wins)
now = time.time()
uptime = 0
if start_ts and start_ts > 0:
uptime = int(max(0, now - start_ts))
# ===== 统计聚合(趋势/分布/Top) =====
now = time.time()
window_seconds = 2 * 3600
bin_seconds = 5 * 60
bins = int(window_seconds // bin_seconds)
ts0 = int(now - window_seconds)
def _bin_idx(ts: float) -> int:
i = int((ts - ts0) // bin_seconds)
if i < 0:
return -1
if i >= bins:
return -1
return i
series = {
"fudai_open_detail": [0] * bins,
"fudai_attend_ok": [0] * bins,
"fudai_attend_fail": [0] * bins,
"fudai_result_win": [0] * bins,
"fudai_result_no_win": [0] * bins,
"fudai_skip": [0] * bins,
"switch_room": [0] * bins,
}
skip_reason = {}
switch_reason = {}
value_buckets = {}
participants_buckets = {}
countdown_buckets = {}
content_top = {}
# 桶边界
value_edges = [0, 10, 50, 100, 200, 500]
participants_edges = [0, 100, 500, 1000, 5000, 10000]
countdown_edges = [0, 30, 60, 5 * 60, 15 * 60, 60 * 60]
for ev in events:
ts = float(ev.get("ts") or 0)
typ = str(ev.get("type") or "")
meta = ev.get("meta") if isinstance(ev.get("meta"), dict) else {}
bi = _bin_idx(ts)
if bi >= 0:
if typ in series:
series[typ][bi] += 1
if typ == "fudai_skip":
series["fudai_skip"][bi] += 1
if typ == "switch_room":
series["switch_room"][bi] += 1
# 分布/Top
if meta is not None:
if typ == "fudai_skip":
r = str(meta.get("reason") or "unknown")
self._inc_map(skip_reason, r, 1)
if typ == "switch_room":
r = str(meta.get("reason") or "unknown")
self._inc_map(switch_reason, r, 1)
content = str(meta.get("content") or "").strip()
if content:
# 只取前 60 字符作为展示 key,避免超长撑爆
key = (content[:60] + "…") if len(content) > 60 else content
self._inc_map(content_top, key, 1)
v = meta.get("prize_value_yuan")
if isinstance(v, (int, float)):
b = self._bucket(float(v), [float(x) for x in value_edges])
self._inc_map(value_buckets, b, 1)
p = meta.get("participants")
if isinstance(p, int):
b = self._bucket(float(p), [float(e) for e in participants_edges])
self._inc_map(participants_buckets, b, 1)
cd = meta.get("countdown")
if isinstance(cd, str) and cd.strip():
sec = self._parse_countdown_seconds(cd)
if isinstance(sec, int):
b = self._bucket(
float(sec), [float(e) for e in countdown_edges]
)
self._inc_map(countdown_buckets, b, 1)
def _top_k(m: dict, k: int = 10) -> list[dict]:
items = [{"key": kk, "count": int(vv)} for kk, vv in m.items()]
items.sort(key=lambda x: x["count"], reverse=True)
return items[:k]
timeline = {
"start_ts": ts0,
"bin_seconds": bin_seconds,
"bins": bins,
"series": series,
}
agg = {
"skip_reason": skip_reason,
"switch_reason": switch_reason,
"value_buckets": value_buckets,
"participants_buckets": participants_buckets,
"countdown_buckets": countdown_buckets,
"content_top": _top_k(content_top, 12),
"timeline": timeline,
}
# 获取当前traceId和MDC上下文
current_trace_id = getattr(self, "_current_trace_id", None)
mdc_context = dict(getattr(self, "_mdc_context", {}))
payload = {
"running": bool(running),
"pid": pid,
"start_ts": start_ts,
"last_log_ts": last_log_ts,
"exit_code": exit_code,
"uptime_seconds": uptime,
"log_len": log_len,
"log_capacity": int(self._log_capacity or 0),
"log_file": self._log_file_path if self._log_file_enabled else "",
"counters": counters,
"fudai_last": fudai_last,
"agg": agg,
# 仅返回最近 20 条,避免过大
"wins": wins[-20:],
# 统一日志系统信息
"trace_id": current_trace_id,
"mdc_context": mdc_context,
}
if include_events:
# 仅返回最近 200 条,防止数据过大
tail = events[-200:]
payload["events"] = tail
return payload
def get_logs_since(self, idx: int) -> tuple[int, list[str]]:
with self._lock:
if idx < 0:
idx = 0
log_len = len(self._log)
# 如果索引越界或等于日志长度(说明日志可能被截断了),返回所有日志
# 让前端能够检测到并重置索引
if idx >= log_len:
idx = 0
lines = self._log[idx:]
return log_len, lines
def start_test_yanghao(self, device_id: str, seconds: int) -> None:
if self.is_running():
raise RuntimeError("already running")
seconds = int(seconds or 0)
if seconds <= 0:
seconds = 60
run_cli_path = path_config.get_run_cli_path()
if not os.path.exists(run_cli_path):
raise FileNotFoundError(
f"run_cli.py not found.\n"
f"Expected path: {run_cli_path}\n"
f"Please ensure run_cli.py is in the project root directory."
)
cmd = [
sys.executable,
run_cli_path,
"--test-yanghao-flow",
"--test-yanghao-flow-seconds",
str(seconds),
]
if device_id:
cmd += ["--device-id", device_id]
self._start_process(cmd)
def start_test_comment(self, device_id: str, text: str) -> None:
if self.is_running():
raise RuntimeError("already running")
text = str(text or "").strip()
run_cli_path = path_config.get_run_cli_path()
if not os.path.exists(run_cli_path):
raise FileNotFoundError(
f"run_cli.py not found.\n"
f"Expected path: {run_cli_path}\n"
f"Please ensure run_cli.py is in the project root directory."
)
cmd = [
sys.executable,
run_cli_path,
"--test-comment",
]
if text:
cmd += ["--test-comment-text", text]
if device_id:
cmd += ["--device-id", device_id]
self._start_process(cmd)
def start_main_run(self, params: dict) -> None:
if self.is_running():
raise RuntimeError("already running")
cfg = {}
try:
cfg = read_config() or {}
except Exception:
cfg = {}
def _pick(key: str, default):
if (
isinstance(params, dict)
and key in params
and params.get(key) is not None
):
return params.get(key)
if isinstance(cfg, dict) and key in cfg and cfg.get(key) is not None:
return cfg.get(key)
return default
device_id = str(_pick("device_id", "") or "").strip()
y_pianyi = int(_pick("y_pianyi", 0) or 0)
needswitch = bool(_pick("needswitch", False))
reset_after_swipes_enabled = bool(_pick("reset_after_swipes_enabled", False))
wait_minutes = int(_pick("wait_minutes", 5) or 5)
# 启动时自动截图
if device_id:
try:
from Underlying_Operations import underlying_operations
ops = underlying_operations()
self._append_log(f"[启动] 自动截图: device={device_id}")
result = ops.get_screenshot(device_id, use_service=False)
if result:
self._append_log("[启动] 截图成功,已保存到 pic/screenshot.png")
else:
self._append_log("[启动] 截图失败")
except Exception as e:
self._append_log(f"[启动] 截图异常: {e}")
# 这些运行参数与 run_cli.py --help 对齐
min_prize_value_yuan = float(_pick("min_prize_value_yuan", 0) or 0)
min_participants = int(_pick("min_participants", 0) or 0)
max_participants = int(_pick("max_participants", 0) or 0)
skip_if_countdown_lt_seconds = int(
_pick("skip_if_countdown_lt_seconds", 15) or 15
)
try:
reset_after_swipes = int(_pick("reset_after_swipes", 10) or 10)
except Exception:
reset_after_swipes = 10
if reset_after_swipes < 1:
reset_after_swipes = 1
auto_join_fansclub = bool(_pick("auto_join_fansclub", False))
fansclub_fail_action = (
str(_pick("fansclub_fail_action", "") or "").strip().lower()
)
run_cli_path = path_config.get_run_cli_path()
if not os.path.exists(run_cli_path):
raise FileNotFoundError(
f"run_cli.py not found.\n"
f"Expected path: {run_cli_path}\n"
f"Please ensure run_cli.py is in the project root directory."
)
cmd = [
sys.executable,
run_cli_path,
"--y-pianyi",
str(y_pianyi),
"--wait-minutes",
str(wait_minutes),
"--min-prize-value-yuan",
str(min_prize_value_yuan),
"--skip-if-countdown-lt-seconds",
str(skip_if_countdown_lt_seconds),
]
if device_id:
cmd += ["--device-id", device_id]
if needswitch:
cmd.append("--needswitch")
if reset_after_swipes_enabled:
cmd.append("--reset-after-swipes-enabled")
cmd += ["--reset-after-swipes", str(reset_after_swipes)]
else:
cmd.append("--reset-after-swipes-disabled")
if min_participants > 0:
cmd += ["--min-participants", str(min_participants)]
if max_participants > 0:
cmd += ["--max-participants", str(max_participants)]
if auto_join_fansclub:
cmd.append("--auto-join-fansclub")
if fansclub_fail_action:
cmd += ["--fansclub-fail-action", fansclub_fail_action]
# 高价值直播间回访运行时开关(由 GUI 在启动时覆盖)
high_value_room_revisit_enabled = bool(
_pick("high_value_room_revisit_enabled", True)
)
high_value_room_revisit_only_current_run = bool(
_pick("high_value_room_revisit_only_current_run", False)
)
if high_value_room_revisit_enabled:
cmd.append("--high-value-room-revisit-enabled")
else:
cmd.append("--high-value-room-revisit-disabled")
if high_value_room_revisit_only_current_run:
cmd.append("--high-value-room-revisit-only-current-run")
# 预约回退校验开关(由 Run 面板控制)
reservation_back_verify_enabled = bool(
_pick("reservation_back_verify_enabled", True)
)
if reservation_back_verify_enabled:
cmd.append("--reservation-back-verify-enabled")
else:
cmd.append("--reservation-back-verify-disabled")
# 回退回滑快速延迟(可由 Run 面板设置):仅在未启用回退校验时生效
try:
rbd = float(_pick("reservation_back_swipe_delay", 0) or 0)
except Exception:
rbd = 0.0
if rbd > 0:
cmd += ["--reservation-back-swipe-delay", str(rbd)]
# 预约抢占最小价值(GUI 启动时可覆盖)
try:
rpmin = float(_pick("reservation_preempt_min_value", 0) or 0)
except Exception:
rpmin = 0.0
if rpmin > 0:
cmd += ["--reservation-preempt-min-value", str(rpmin)]
# 找福袋最大尝试次数(GUI 启动时可覆盖)
try:
fudai_find_max_attempts = int(_pick("fudai_find_max_attempts", 0) or 0)
except Exception:
fudai_find_max_attempts = 0
if fudai_find_max_attempts > 0:
cmd += ["--fudai-find-max-attempts", str(fudai_find_max_attempts)]
# OCR模式1开关(命令行优先)
enable_ocr_mode1 = bool(_pick("enable_ocr_mode1", False))
if enable_ocr_mode1:
cmd.append("--enable-ocr-mode1")
else:
cmd.append("--disable-ocr-mode1")
# 福袋模板匹配开关(命令行优先)
fudai_template_match_enabled = bool(
_pick("fudai_template_match_enabled", False)
)
if fudai_template_match_enabled:
cmd.append("--fudai-template-enabled")
else:
cmd.append("--fudai-template-disabled")
# 福袋模板匹配阈值(命令行优先)
try:
fudai_template_match_threshold = float(
_pick("fudai_template_match_threshold", 0.7) or 0.7
)
if 0.0 <= fudai_template_match_threshold <= 1.0:
cmd += [
"--fudai-template-threshold",
str(fudai_template_match_threshold),
]
except Exception:
pass
self._start_process(cmd)
def _start_process(self, cmd: list[str]) -> None:
# 每次启动前刷新一次日志设置
self._reload_log_settings()
env = os.environ.copy()
env.setdefault("PYTHONIOENCODING", "utf-8")
env.setdefault("PYTHONUNBUFFERED", "1")
# 尽量减少第三方库的英文噪声日志(不影响主逻辑)
env.setdefault("DISABLE_MODEL_SOURCE_CHECK", "True")
env.setdefault("PYTHONWARNINGS", "ignore")
# 若启用统一日志文件:由 Web GUI 负责落盘,子进程不再 Tee 到文件,避免重复写入
if self._log_file_enabled:
env["NO_TEE_STDOUT"] = "1"
adb_exe = find_adb_executable()
if adb_exe:
adb_dir = os.path.dirname(adb_exe)
env["PATH"] = adb_dir + os.pathsep + env.get("PATH", "")
env["ADB_EXECUTABLE"] = adb_exe
p = subprocess.Popen(
cmd,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
text=True,
encoding="utf-8",
errors="replace",
env=env,
cwd=path_config.PROJECT_ROOT,
bufsize=1, # 行缓冲模式,确保实时输出
)
# 立即记录进程信息并初始化状态
with self._lock:
self._proc = p
self._pid = p.pid
self._start_ts = time.time()
self._exit_code = None
self._last_log_ts = time.time()
# 清空旧日志,确保新启动的进程只显示新日志
self._log = []
self._counters = {}
self._fudai_last = {
"content": "",
"countdown": "",
"participants": None,
"copies": None,
"prize_value_yuan": None,
"updated_ts": None,
}
self._events = []
self._wins = []
self._append_log(f"[网页] 启动:{' '.join(cmd)}")
self._append_log(f"[网页] 子进程 PID={p.pid} 已创建,准备启动读取线程")
def _reader() -> None:
self._append_log(f"[网页] 读取线程启动,监视 PID={p.pid}")
out = p.stdout
if out is None:
self._append_log(f"[网页] 读取线程:stdout 为 None,无法读取子进程输出")
try:
rc = p.wait()
except Exception:
rc = None
self._append_log(f"[网页] 进程退出(无输出):退出码={rc}")
with self._lock:
self._exit_code = rc
return
try:
# 使用迭代器读取,Python会自动处理缓冲
# 配合PYTHONUNBUFFERED=1和line_buffering=True,应该能实时获取输出
# iter(out.readline, '') 会在readline返回空字符串(EOF)时自动停止
for line in iter(out.readline, ""):
try:
cleaned_line = line.rstrip("\n\r")
if cleaned_line: # 忽略空行
self._append_log(cleaned_line)
except Exception:
# 避免单条日志处理异常中断读取循环
pass
except BrokenPipeError:
# 进程已关闭stdout
self._append_log(f"[网页] 读取线程:子进程stdout已关闭")
except Exception as e:
self._append_log(f"[网页] 读取线程异常:{e}")
try:
rc = p.wait(timeout=1)
except subprocess.TimeoutExpired:
rc = None
self._append_log(f"[网页] 等待进程退出超时,强制终止")
try:
p.kill()
rc = p.wait(timeout=5)
except Exception:
pass
except Exception:
rc = None
self._append_log(f"[网页] 进程退出:退出码={rc}")
with self._lock:
self._exit_code = rc
threading.Thread(target=_reader, daemon=True).start()
RUNNER = ProcRunner()
class Handler(BaseHTTPRequestHandler):
def _send_json(self, obj, status: int = 200) -> None:
data = json.dumps(obj, ensure_ascii=False).encode("utf-8")
self.send_response(status)
self.send_header("Content-Type", "application/json; charset=utf-8")
self.send_header("Cache-Control", "no-store")
self.send_header("Content-Length", str(len(data)))
self.end_headers()
self.wfile.write(data)
def _read_json(self) -> dict:
n = int(self.headers.get("Content-Length") or 0)
raw = self.rfile.read(n) if n > 0 else b"{}"
try:
return json.loads(raw.decode("utf-8"))
except Exception:
return {}
def _serve_static(self, rel_path: str) -> None:
rel_path = rel_path.lstrip("/")
if not rel_path:
rel_path = "index.html"
safe = os.path.normpath(rel_path).replace("\\", "/")
# 安全检查:防止路径遍历攻击
if safe.startswith("../") or safe.startswith("..\\") or ".." in safe:
self.send_error(HTTPStatus.FORBIDDEN)
return
full = os.path.join(WEBUI_DIR, safe)
# 额外安全检查:确保文件在 WEBUI_DIR 目录内
try:
full_real = os.path.realpath(full)
webui_real = os.path.realpath(WEBUI_DIR)
if (
not full_real.startswith(webui_real + os.sep)
and full_real != webui_real
):
self.send_error(HTTPStatus.FORBIDDEN)
return
except Exception:
self.send_error(HTTPStatus.FORBIDDEN)
return
if not os.path.isfile(full):
self.send_error(HTTPStatus.NOT_FOUND)
return
ext = os.path.splitext(full)[1].lower()
ctype = {
".html": "text/html; charset=utf-8",
".css": "text/css; charset=utf-8",
".js": "application/javascript; charset=utf-8",
".png": "image/png",
".jpg": "image/jpeg",
".jpeg": "image/jpeg",
".svg": "image/svg+xml; charset=utf-8",
}.get(ext, "application/octet-stream")
try:
with open(full, "rb") as f:
data = f.read()
# 对于静态资源,使用适当的缓存策略
cache_control = (
"no-store" if ext in (".html", ".js") else "public, max-age=3600"
)
self.send_response(HTTPStatus.OK)
self.send_header("Content-Type", ctype)
self.send_header("Content-Length", str(len(data)))
self.send_header("Cache-Control", cache_control)
# 添加 ETag 支持(简单实现:基于文件大小和修改时间)
try:
stat = os.stat(full)
etag = f'"{stat.st_size}-{int(stat.st_mtime)}"'
self.send_header("ETag", etag)
# 检查 If-None-Match 头,支持 304 Not Modified
if_none_match = self.headers.get("If-None-Match", "")
if if_none_match == etag:
self.send_response(HTTPStatus.NOT_MODIFIED)
self.end_headers()
return
except Exception:
pass
self.end_headers()
self.wfile.write(data)
except FileNotFoundError:
self.send_error(HTTPStatus.NOT_FOUND)
except Exception as e:
print(f"[WEB_GUI] Error serving static file {rel_path}: {e}")
self.send_error(HTTPStatus.INTERNAL_SERVER_ERROR)
def do_GET(self):
u = urlparse(self.path)
if u.path.startswith("/api/"):
api_path = u.path.rstrip("/")
if u.path == "/api/devices":
adb = find_adb_executable()
return self._send_json({"adb": adb, "devices": list_adb_devices(adb)})
if u.path == "/api/config":
cfg = read_config()
return self._send_json(cfg)
if u.path == "/api/stats":
qs = parse_qs(u.query)
detail = str((qs.get("detail") or [""])[0] or "").strip().lower() in (
"1",
"true",
"yes",
)
return self._send_json(RUNNER.get_stats(include_events=detail))
if api_path in ("/api/reservations", "/api/reservation"):
# 返回当前预约队列信息
return self._send_json(RUNNER.get_reservations())
if api_path in (
"/api/high-value-rooms",
"/api/high_value_rooms",
"/api/high_value_room",
"/api/high-value-room",
):
return self._send_json(RUNNER.get_high_value_rooms())
if u.path == "/api/logs":
qs = parse_qs(u.query)
since = 0
try:
since = int((qs.get("since") or [0])[0])
except (ValueError, TypeError, IndexError):
since = 0
try:
next_idx, lines = RUNNER.get_logs_since(since)
return self._send_json(
{
"next": next_idx,
"lines": lines,
"running": RUNNER.is_running(),
}
)
except Exception as e:
# 记录错误但不中断请求,返回空日志
import traceback
print(
f"[WEB_GUI] get_logs_since error: {e}\n{traceback.format_exc()}"
)
return self._send_json(
{"next": 0, "lines": [], "running": RUNNER.is_running()}
)
if u.path == "/api/logfile-tail":
# 返回统一日志文件的尾部若干行,便于在内存日志不同步时调试
qs = parse_qs(u.query)
try:
n = int((qs.get("lines") or [100])[0])
except Exception:
n = 100
path = (
RUNNER._log_file_path
if hasattr(RUNNER, "_log_file_path")
else path_config.get_log_file_path()
)
out_lines = []
try:
if os.path.exists(path):
# 读取尾部若干行(简单实现:读全文件或最后 64KB)
size = os.path.getsize(path)
read_bytes = min(size, 65536)
with open(path, "rb") as f:
if read_bytes < size:
f.seek(-read_bytes, os.SEEK_END)
data = f.read().decode("utf-8", errors="replace")
parts = data.splitlines()
out_lines = parts[-n:]
except Exception:
out_lines = ["<failed to read logfile>"]
return self._send_json({"ok": True, "path": path, "lines": out_lines})
if u.path == "/api/actions":
# 返回精简行为日志(logs/actions.log)的尾部若干行,便于在 Web GUI 中单独查看点击/识别耗时
qs = parse_qs(u.query)
try:
n = int((qs.get("lines") or [200])[0])
except Exception:
n = 200
# 使用统一的路径配置(优先使用 path_config 中的配置,失败时回退到项目内置路径)
if hasattr(path_config, "get_actions_log_path"):
try:
path = path_config.get_actions_log_path()
except Exception:
path = os.path.join(
(
path_config.PROJECT_ROOT
if hasattr(path_config, "PROJECT_ROOT")
else os.getcwd()
),
"logs",
"actions.log",
)
else:
path = os.path.join(os.getcwd(), "logs", "actions.log")
out_lines: list[str] = []
try:
if os.path.exists(path):
size = os.path.getsize(path)
read_bytes = min(size, 65536)
with open(path, "rb") as f:
if read_bytes < size:
f.seek(-read_bytes, os.SEEK_END)
data = f.read().decode("utf-8", errors="replace")
parts = data.splitlines()
out_lines = parts[-n:]
except Exception:
out_lines = ["<failed to read actions.log>"]
return self._send_json({"ok": True, "path": path, "lines": out_lines})
self.send_error(HTTPStatus.NOT_FOUND)
return
if u.path.startswith("/pic/"):
# 只允许读取 pic 目录下的文件(便于前端预览 latest.png)
rel = u.path.lstrip("/")
safe = os.path.normpath(rel).replace("\\", "/")
if not safe.startswith("pic/"):
self.send_error(HTTPStatus.FORBIDDEN)
return
full = os.path.join(path_config.PROJECT_ROOT, safe)
if not os.path.isfile(full):
self.send_error(HTTPStatus.NOT_FOUND)
return
ext = os.path.splitext(full)[1].lower()
ctype = {
".png": "image/png",
".jpg": "image/jpeg",
".jpeg": "image/jpeg",
}.get(ext, "application/octet-stream")
with open(full, "rb") as f:
data = f.read()
self.send_response(HTTPStatus.OK)
self.send_header("Content-Type", ctype)
self.send_header("Content-Length", str(len(data)))
self.send_header("Cache-Control", "no-store")
self.end_headers()
self.wfile.write(data)
return
self._serve_static(u.path)
def do_POST(self):
u = urlparse(self.path)
if u.path == "/api/config":
body = self._read_json()
cfg = read_config()
update = (
body.get("config") if isinstance(body.get("config"), dict) else body
)
int_keys = {
"min_participants",
"max_participants",
"skip_if_countdown_lt_seconds",
"skip_if_countdown_gt_seconds",
"reset_after_swipes",
"fudai_find_max_attempts",
"fudai_quiet_start_hour",
"fudai_quiet_end_hour",
"high_value_fudai_join_ahead_seconds",
"high_value_fudai_max_swipe_back",
"high_value_fudai_max_reservations",
"yanghao_like_icon_x",
"yanghao_like_icon_y",
"yanghao_fav_icon_x",
"yanghao_fav_icon_y",
"yanghao_like_roi_offset_x",
"yanghao_like_roi_offset_y",
"yanghao_fav_roi_offset_x",
"yanghao_fav_roi_offset_y",
"yanghao_icon_roi_size",
"yanghao_comment_btn_x",
"yanghao_comment_btn_y",
"yanghao_comment_input_x",
"yanghao_comment_input_y",
"yanghao_comment_send_x",
"yanghao_comment_send_y",
"yanghao_comment_close_x",
"yanghao_comment_close_y",
"yanghao_after_dwell_swipe_distance_px",
"yanghao_recommend_duration_seconds",
"yanghao_recommend_interval_seconds",
}
float_keys = {
"min_prize_value_yuan",
"yanghao_like_prob",
"yanghao_fav_prob",
"yanghao_comment_prob",
"yanghao_icon_match_threshold",
"fudai_template_match_threshold",
"lucky_draw_red_ratio_threshold",
"live_room_match_threshold",
"stage_diag_max_time",
"stage_diag_max_step_time",
"fudai_icon_retry_delay_seconds",
"fudai_icon_max_wait_seconds",
"reservation_back_swipe_delay",
"reservation_preempt_min_value",
"high_value_fudai_threshold_yuan",
}
bool_keys = {
"auto_join_fansclub",
"reset_after_swipes_enabled",
"yanghao_enable_actions",
"yanghao_enabled",
"yanghao_step_screenshot",
"enable_ocr_mode1",
"fudai_template_match_enabled",
"fudai_quiet_hours_enabled",
"high_value_fudai_enabled",
"fudai_disable_content_recognition",
"high_value_room_revisit_enabled",
"high_value_room_revisit_only_current_run",
"reservation_back_verify_enabled",
}
list_str_keys = {
"contains_want",
"contains_not_want",
"yanghao_comment_texts",
"yanghao_like_keywords",
"yanghao_fav_keywords",
}
deny_keys = {
"yanghao_use_recommend_flow",
"yanghao_text_recommend",
"yanghao_text_live",
"yanghao_text_enter_live",
"yanghao_fallback_close_x",
"yanghao_fallback_close_y",
"yanghao_fallback_recommend_x",
"yanghao_fallback_recommend_y",
"yanghao_fallback_live_x",
"yanghao_fallback_live_y",
"yanghao_fallback_enter_live_x",
"yanghao_fallback_enter_live_y",
}
def set_nested_value(obj, key, value):
"""设置嵌套配置值,支持如 'debug_captures.auto_cleanup' 这样的键"""
if "." in key:
parts = key.split(".")
current = obj
for part in parts[:-1]:
if part not in current or not isinstance(current[part], dict):
current[part] = {}
current = current[part]
current[parts[-1]] = value
else:
obj[key] = value
for k, v in (update or {}).items():
if k in deny_keys:
continue
if k in int_keys:
try:
set_nested_value(cfg, k, int(v))
except Exception:
continue
elif k in float_keys:
try:
set_nested_value(cfg, k, float(v))
except Exception:
continue
elif k in bool_keys:
set_nested_value(cfg, k, bool(v))
elif k in list_str_keys:
if isinstance(v, list):
set_nested_value(cfg, k, [str(x) for x in v if str(x).strip()])
else:
set_nested_value(
cfg,
k,
[
str(x).strip()
for x in str(v).splitlines()
if str(x).strip()
],
)
else:
set_nested_value(cfg, k, v)
write_config(cfg)
return self._send_json({"ok": True})
if u.path == "/api/start-run":
if RUNNER.is_running():
return self._send_json({"ok": False, "error": "running"}, status=409)
body = self._read_json()
try:
RUNNER.start_main_run(body or {})
except Exception as e:
return self._send_json({"ok": False, "error": str(e)}, status=500)
return self._send_json({"ok": True})
# (已移除) /api/test-yanghao 与 /api/test-comment 接口已删除
if u.path == "/api/stop":
RUNNER.stop()
return self._send_json({"ok": True})
if u.path == "/api/screenshot":
# 手动截图接口
body = self._read_json()
device_id = str(body.get("device_id") or "").strip()
try:
from Underlying_Operations import underlying_operations
ops = underlying_operations()
result = ops.get_screenshot(device_id, use_service=False)
if result:
return self._send_json({"ok": True, "message": "截图成功"})
else:
return self._send_json(
{"ok": False, "error": "截图失败"}, status=500
)
except Exception as e:
return self._send_json({"ok": False, "error": str(e)}, status=500)
self.send_error(HTTPStatus.NOT_FOUND)
def log_message(self, format, *args): # type: ignore[override]
# 覆盖基类方法以抑制日志输出
# 参数名从 fmt 改为 format 以匹配基类签名
return
def main() -> int:
host = "127.0.0.1"
# 支持 PORT / WEB_GUI_PORT 两种环境变量,默认 8000
env_port = os.environ.get("PORT") or os.environ.get("WEB_GUI_PORT") or "8000"
try:
port = int(env_port)
except Exception:
port = 8000
if port < 1 or port > 65535:
port = 8000
print(f"[WEBGUI] 启动端口={port}(可设置环境变量 PORT 覆盖)")
try:
httpd = ThreadingHTTPServer((host, port), Handler)
except OSError as e:
print(f"[WEBGUI] 端口 {port} 启动失败:{e}")
print(
"[WEBGUI] 处理建议:1) 关闭占用该端口的进程 2) 改为其他端口,例如前置设置 PORT=8001"
)
raise
print(f"Web GUI: http://{host}:{port}")
print("- 可在页面里设置养号时长/间隔并保存到 config.json")
try:
httpd.serve_forever()
except KeyboardInterrupt:
print("[WEBGUI] 收到中断,退出")
return 0
if __name__ == "__main__":
try:
from version import print_version_banner
print_version_banner("web_gui")
except Exception:
pass
raise SystemExit(main())