953 lines
36 KiB
Python
953 lines
36 KiB
Python
import json
|
|
import os
|
|
import re
|
|
import secrets
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import threading
|
|
import time
|
|
import atexit
|
|
from http import HTTPStatus
|
|
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
|
from typing import Optional
|
|
from urllib.parse import parse_qs, urlparse
|
|
|
|
# Add project root to Python path
|
|
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
|
if project_root not in sys.path:
|
|
sys.path.insert(0, project_root)
|
|
|
|
if __name__ == "__main__":
|
|
from douyin.updater.bootstrap import run_startup_update_check_early
|
|
|
|
run_startup_update_check_early(app_name="web_gui")
|
|
|
|
from douyin.core import path_config
|
|
from douyin.license.license_manager import require_online_license_or_exit, start_online_license_monitor
|
|
|
|
# 从子包 re-export 顶层 helper(保持兼容)
|
|
from gui.web_gui_pkg import (
|
|
_LOGGER,
|
|
_wg_log,
|
|
strip_ansi_escape_codes,
|
|
find_adb_executable,
|
|
list_adb_devices,
|
|
resolve_adb_device,
|
|
read_config,
|
|
write_config,
|
|
get_nested_value,
|
|
_bucket,
|
|
_inc_map,
|
|
_parse_countdown_seconds,
|
|
)
|
|
from gui.web_gui_pkg.request_parsing import read_json, send_json
|
|
from gui.web_gui_pkg.static_handler import serve_static
|
|
from gui.web_gui_pkg.net_config import get_web_gui_host, get_web_gui_port
|
|
from gui.web_gui_pkg.routes import handle_get, handle_post
|
|
from gui.web_gui_pkg import proc_runner_ops as _proc_ops
|
|
from gui.web_gui_pkg import proc_runner_stats as _proc_stats
|
|
from gui.process_pause import resume_process_tree, suspend_process_tree
|
|
|
|
BASE_DIR = path_config.PROJECT_ROOT
|
|
CONFIG_PATH = path_config.get_config_path()
|
|
WEBUI_DIR = path_config.get_webui_dir()
|
|
|
|
import logging as _logging
|
|
|
|
# 模块级 logger:内部错误统一走 logging。
|
|
# 启动横幅和中断消息保留 print(属于交互/CLI 输出,不是日志事件)。
|
|
_LOGGER = _logging.getLogger("gui.web_gui")
|
|
|
|
|
|
|
|
|
|
# CSRF token for POST request protection (local-only server)
|
|
_CSRF_TOKEN = secrets.token_hex(32)
|
|
|
|
|
|
class ProcRunner:
|
|
@staticmethod # type: ignore[misc]
|
|
def _parse_countdown_seconds(text):
|
|
return _parse_countdown_seconds(text)
|
|
|
|
@staticmethod # type: ignore[misc]
|
|
def _bucket(value, edges):
|
|
return _bucket(value, edges)
|
|
|
|
@staticmethod # type: ignore[misc]
|
|
def _inc_map(m, k, n=1):
|
|
return _inc_map(m, k, n)
|
|
|
|
def __init__(self) -> None:
|
|
self._proc: Optional[subprocess.Popen] = None
|
|
self._lock = threading.Lock()
|
|
self._pid_lock = threading.Lock() # 保护 PID 相关操作
|
|
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
|
|
self._paused: bool = False
|
|
self._owned_run_cli_pids: set[int] = set()
|
|
|
|
# 运行统计(基于 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,
|
|
}
|
|
|
|
# 延迟属性:预先声明,避免静态检查报“在 __init__ 外定义属性”
|
|
self._log_permission_warned: bool = False
|
|
self._log_write_error_warned: bool = False
|
|
self._current_trace_id: str = ""
|
|
self._mdc_context: dict[str, str] = {}
|
|
|
|
# 事件流(用于趋势/分布/Top 统计),保留最近 N 条
|
|
self._events: list[dict] = []
|
|
self._events_cap: int = 5000
|
|
|
|
# 中奖记录(用于展示“福袋中奖内容”),保留最近 N 条
|
|
self._wins: list[dict] = []
|
|
self._wins_cap: int = 200
|
|
|
|
# 已记录福袋识别的跟踪(避免同一个直播间同一个福袋重复记录识别次数)
|
|
self._recorded_fudai_seen: set[tuple[str, str]] = (
|
|
set()
|
|
) # (room_title, fudai_content)
|
|
|
|
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 self._log_permission_warned:
|
|
_wg_log(f"[WEB_GUI] 警告:日志文件写入权限错误: {self._log_file_path}", level="WARNING")
|
|
_wg_log(f"[WEB_GUI] 错误详情: {e}", level="WARNING")
|
|
self._log_permission_warned = True
|
|
except Exception as e:
|
|
# 其他文件写失败不应影响主流程,但记录第一次错误以便调试
|
|
if not self._log_write_error_warned:
|
|
_wg_log(f"[WEB_GUI] 警告:日志文件写入失败: {self._log_file_path}", level="WARNING")
|
|
_wg_log(f"[WEB_GUI] 错误详情: {e}", level="WARNING")
|
|
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 :]
|
|
|
|
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:
|
|
"""委托到 gui/web_gui_pkg/stats_log_parser.update_stats_from_line。"""
|
|
from gui.web_gui_pkg.stats_log_parser import update_stats_from_line
|
|
update_stats_from_line(self, line)
|
|
|
|
def is_running(self) -> bool:
|
|
with self._lock:
|
|
return self._proc is not None and self._proc.poll() is None
|
|
|
|
def is_paused(self) -> bool:
|
|
with self._lock:
|
|
return bool(self._paused and self._proc is not None and self._proc.poll() is None)
|
|
|
|
def _list_project_run_cli_processes(self) -> list[tuple[int, str]]:
|
|
"""列出当前仓库下运行的 run_cli.py 进程(含 pid 与命令行)。"""
|
|
entries: list[tuple[int, str]] = []
|
|
root_norm = str(path_config.PROJECT_ROOT).replace("/", "\\").lower()
|
|
try:
|
|
if os.name == "nt":
|
|
ps_cmd = (
|
|
"Get-CimInstance Win32_Process "
|
|
"| Where-Object { $_.Name -eq 'python.exe' -and $_.CommandLine -like '*run_cli.py*' } "
|
|
"| Select-Object ProcessId,CommandLine | ConvertTo-Json -Compress"
|
|
)
|
|
proc = subprocess.run(
|
|
["powershell", "-NoProfile", "-Command", ps_cmd],
|
|
capture_output=True,
|
|
text=True,
|
|
encoding="utf-8",
|
|
errors="replace",
|
|
timeout=6,
|
|
check=False,
|
|
)
|
|
raw = (proc.stdout or "").strip()
|
|
if not raw:
|
|
return entries
|
|
try:
|
|
data = json.loads(raw)
|
|
except Exception:
|
|
data = None
|
|
if isinstance(data, dict):
|
|
data = [data]
|
|
if isinstance(data, list):
|
|
for item in data:
|
|
try:
|
|
pid = int(item.get("ProcessId") or 0)
|
|
cmdline = str(item.get("CommandLine") or "")
|
|
except Exception:
|
|
continue
|
|
if pid <= 0 or not cmdline:
|
|
continue
|
|
if root_norm in cmdline.replace("/", "\\").lower():
|
|
entries.append((pid, cmdline))
|
|
else:
|
|
proc = subprocess.run(
|
|
["ps", "-eo", "pid=,args="],
|
|
capture_output=True,
|
|
text=True,
|
|
encoding="utf-8",
|
|
errors="replace",
|
|
timeout=4,
|
|
check=False,
|
|
)
|
|
for line in (proc.stdout or "").splitlines():
|
|
s = str(line or "").strip()
|
|
if not s:
|
|
continue
|
|
parts = s.split(None, 1)
|
|
if len(parts) < 2:
|
|
continue
|
|
try:
|
|
pid = int(parts[0])
|
|
except Exception:
|
|
continue
|
|
cmdline = parts[1]
|
|
low = cmdline.lower()
|
|
if "run_cli.py" in low and root_norm in cmdline.replace("/", "\\").lower():
|
|
entries.append((pid, cmdline))
|
|
except Exception:
|
|
return []
|
|
return entries
|
|
|
|
def _cleanup_orphan_run_cli_processes(self, device_id: str = "") -> int:
|
|
"""清理当前仓库遗留的 run_cli.py 进程,避免同机并发导致重复动作。"""
|
|
try:
|
|
with self._lock:
|
|
tracked_pid = int(self._pid or 0)
|
|
owned_pids = {int(x) for x in (self._owned_run_cli_pids or set())}
|
|
except Exception:
|
|
tracked_pid = 0
|
|
owned_pids = set()
|
|
current_pid = int(os.getpid() or 0)
|
|
device_tag = str(device_id or "").strip()
|
|
if not device_tag:
|
|
return 0
|
|
killed = 0
|
|
|
|
for pid, cmdline in self._list_project_run_cli_processes():
|
|
if pid <= 0:
|
|
continue
|
|
if pid in (tracked_pid, current_pid):
|
|
continue
|
|
if pid not in owned_pids:
|
|
continue
|
|
if device_tag:
|
|
dev1 = f"--device-id {device_tag}"
|
|
dev2 = f'--device-id "{device_tag}"'
|
|
if dev1 not in cmdline and dev2 not in cmdline:
|
|
continue
|
|
try:
|
|
self._append_log(f"[启动清理] 发现遗留 run_cli 进程 pid={pid},准备终止")
|
|
except Exception:
|
|
pass
|
|
try:
|
|
if os.name == "nt":
|
|
subprocess.run(
|
|
["taskkill", "/PID", str(pid), "/T", "/F"],
|
|
capture_output=True,
|
|
text=True,
|
|
encoding="utf-8",
|
|
errors="replace",
|
|
timeout=8,
|
|
check=False,
|
|
)
|
|
else:
|
|
subprocess.run(
|
|
["kill", "-9", str(pid)],
|
|
capture_output=True,
|
|
text=True,
|
|
encoding="utf-8",
|
|
errors="replace",
|
|
timeout=5,
|
|
check=False,
|
|
)
|
|
killed += 1
|
|
try:
|
|
self._append_log(f"[启动清理] 已终止遗留 run_cli 进程 pid={pid}")
|
|
except Exception:
|
|
pass
|
|
except Exception as e:
|
|
try:
|
|
self._append_log(f"[启动清理] 终止遗留 run_cli 进程失败 pid={pid} error={e}")
|
|
except Exception:
|
|
pass
|
|
return killed
|
|
|
|
def get_reservations(self) -> dict:
|
|
return _proc_ops.get_reservations(self)
|
|
|
|
def get_high_value_rooms(self) -> dict:
|
|
return _proc_ops.get_high_value_rooms(self)
|
|
|
|
def send_back_key(self, device_id: str) -> bool:
|
|
return _proc_ops.send_back_key(self, device_id)
|
|
|
|
def force_stop(self) -> None:
|
|
with self._pid_lock:
|
|
with self._lock:
|
|
pid = self._pid
|
|
p = self._proc
|
|
self._append_log(f"[停止] 强制停止请求 pid={pid or '-'}")
|
|
if self.is_paused() and pid:
|
|
try:
|
|
resume_process_tree(int(pid))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
if p is not None and p.poll() is None:
|
|
p.kill()
|
|
except Exception:
|
|
pass
|
|
if pid:
|
|
try:
|
|
if os.name == "nt":
|
|
subprocess.run(["taskkill", "/PID", str(pid), "/T", "/F"], capture_output=True, text=True, check=False, timeout=10)
|
|
else:
|
|
subprocess.run(["kill", "-9", str(pid)], capture_output=True, text=True, check=False, timeout=10)
|
|
except Exception as e:
|
|
self._append_log(f"[停止] 系统强制结束失败: {e}")
|
|
with self._lock:
|
|
self._proc = None
|
|
self._pid = None
|
|
self._paused = False
|
|
if pid:
|
|
self._owned_run_cli_pids.discard(int(pid))
|
|
self._exit_code = self._exit_code if self._exit_code is not None else -9
|
|
try:
|
|
extra_killed = self._cleanup_orphan_run_cli_processes("")
|
|
if extra_killed > 0:
|
|
self._append_log(f"[停止] 额外清理遗留 run_cli 进程 {extra_killed} 个")
|
|
except Exception:
|
|
pass
|
|
self._append_log("[停止] 强制停止完成")
|
|
|
|
def stop(self) -> None:
|
|
with self._lock:
|
|
p = self._proc
|
|
if p is None or p.poll() is not None:
|
|
return
|
|
if self.is_paused():
|
|
self.resume()
|
|
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
|
|
self._paused = False
|
|
if getattr(p, "pid", None):
|
|
self._owned_run_cli_pids.discard(int(p.pid))
|
|
except Exception:
|
|
pass
|
|
self._append_log("[网页] 停止:已尝试终止并清理进程引用")
|
|
|
|
def pause(self) -> bool:
|
|
with self._lock:
|
|
p = self._proc
|
|
pid = self._pid or (p.pid if p is not None else None)
|
|
already_paused = self._paused
|
|
if p is None or p.poll() is not None or not pid:
|
|
self._append_log("[网页] 暂停:当前没有正在运行的进程")
|
|
with self._lock:
|
|
self._paused = False
|
|
return False
|
|
if already_paused:
|
|
self._append_log("[网页] 暂停:当前已经是暂停状态")
|
|
return True
|
|
try:
|
|
suspend_process_tree(int(pid))
|
|
with self._lock:
|
|
self._paused = True
|
|
self._append_log("[网页] 暂停:已暂停运行进程")
|
|
return True
|
|
except Exception as e:
|
|
self._append_log(f"[网页] 暂停失败:{e}")
|
|
return False
|
|
|
|
def resume(self) -> bool:
|
|
with self._lock:
|
|
p = self._proc
|
|
pid = self._pid or (p.pid if p is not None else None)
|
|
already_paused = self._paused
|
|
if p is None or p.poll() is not None or not pid:
|
|
self._append_log("[网页] 继续:当前没有可恢复的运行进程")
|
|
with self._lock:
|
|
self._paused = False
|
|
return False
|
|
if not already_paused:
|
|
self._append_log("[网页] 继续:当前不在暂停状态")
|
|
return True
|
|
try:
|
|
resume_process_tree(int(pid))
|
|
with self._lock:
|
|
self._paused = False
|
|
self._append_log("[网页] 继续:已恢复运行进程")
|
|
return True
|
|
except Exception as e:
|
|
self._append_log(f"[网页] 继续失败:{e}")
|
|
return False
|
|
|
|
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:
|
|
return _proc_stats.get_stats(self, include_events)
|
|
|
|
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:
|
|
return _proc_ops.start_test_yanghao(self, device_id, seconds)
|
|
|
|
def start_test_comment(self, device_id: str, text: str) -> None:
|
|
return _proc_ops.start_test_comment(self, device_id, text)
|
|
|
|
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):
|
|
val = get_nested_value(cfg, key, None) if "." in key else cfg.get(key)
|
|
if val is not None:
|
|
return val
|
|
return default
|
|
|
|
device_id = str(_pick("device_id", "") or "").strip()
|
|
adb = find_adb_executable()
|
|
device_id = resolve_adb_device(adb, device_id)
|
|
try:
|
|
cleaned = self._cleanup_orphan_run_cli_processes(device_id)
|
|
if cleaned > 0:
|
|
self._append_log(
|
|
f"[启动清理] 已清理同设备遗留 run_cli 进程 {cleaned} 个,避免重复切房"
|
|
)
|
|
except Exception:
|
|
pass
|
|
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))
|
|
try:
|
|
wait_minutes = int(_pick("wait_minutes", 5))
|
|
except Exception:
|
|
wait_minutes = 5
|
|
if wait_minutes < 0:
|
|
wait_minutes = 0
|
|
|
|
# 启动时自动截图
|
|
if device_id:
|
|
try:
|
|
from douyin.core.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
|
|
)
|
|
skip_if_countdown_gt_seconds = int(
|
|
_pick("skip_if_countdown_gt_seconds", 900) or 900
|
|
)
|
|
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_cmd = path_config.get_run_cli_command()
|
|
run_cli_path = run_cli_cmd[-1] if run_cli_cmd else path_config.get_run_cli_path()
|
|
if not os.path.exists(run_cli_path):
|
|
raise FileNotFoundError(
|
|
f"run_cli launcher not found.\n"
|
|
f"Expected path: {run_cli_path}\n"
|
|
f"Please ensure run_cli.py is in the source tree or run_cli.exe is in the install directory."
|
|
)
|
|
cmd = [
|
|
*run_cli_cmd,
|
|
"--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),
|
|
"--skip-if-countdown-gt-seconds",
|
|
str(skip_if_countdown_gt_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")
|
|
reset_action = str(_pick("reset_after_swipes_action", "swipe") or "swipe").strip().lower()
|
|
if reset_action in ("swipe", "back"):
|
|
cmd += ["--reset-after-swipes-action", reset_action]
|
|
try:
|
|
swipe_down_back_count = int(_pick("swipe_down_back_count", 0) or 0)
|
|
except Exception:
|
|
swipe_down_back_count = 0
|
|
swipe_down_back_enabled = bool(_pick("swipe_down_back_enabled", False))
|
|
if swipe_down_back_enabled:
|
|
cmd.append("--swipe-down-back-enabled")
|
|
if swipe_down_back_count > 0:
|
|
cmd += ["--swipe-down-back-count", str(swipe_down_back_count)]
|
|
else:
|
|
cmd.append("--swipe-down-back-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")
|
|
try:
|
|
cmd += ["--high-value-room-revisit-min-interval-seconds", str(int(_pick("high_value_room_revisit_min_interval_seconds", 300) or 300))]
|
|
cmd += ["--high-value-room-revisit-max-per-run", str(int(_pick("high_value_room_revisit_max_per_run", 5) or 5))]
|
|
cmd += ["--high-value-room-revisit-min-prize-value", str(float(_pick("high_value_room_revisit_min_prize_value", 0.0) or 0.0))]
|
|
cmd += ["--high-value-room-revisit-max-age-days", str(int(_pick("high_value_room_revisit_max_age_days", 30) or 30))]
|
|
except Exception:
|
|
pass
|
|
|
|
# 预约回退校验开关(由 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:
|
|
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
|
|
|
|
if bool(_pick("enable_back_on_misses", True)):
|
|
cmd.append("--enable-back-on-misses")
|
|
else:
|
|
cmd.append("--disable-back-on-misses")
|
|
if bool(_pick("yanghao_only", False)):
|
|
cmd.append("--yanghao-only")
|
|
try:
|
|
seconds = int(_pick("yanghao_seconds", _pick("yanghao_recommend_duration_seconds", 60)) or 60)
|
|
if seconds > 0:
|
|
cmd += ["--yanghao-seconds", str(seconds)]
|
|
except Exception:
|
|
pass
|
|
|
|
reenter_mode = str(
|
|
_pick("reenter_live_entry_mode", "follow_list") or "follow_list"
|
|
).strip().lower()
|
|
reenter_mode_source = "default"
|
|
try:
|
|
if (
|
|
isinstance(params, dict)
|
|
and params.get("reenter_live_entry_mode") is not None
|
|
):
|
|
reenter_mode_source = "params"
|
|
elif isinstance(cfg, dict) and cfg.get("reenter_live_entry_mode") is not None:
|
|
reenter_mode_source = "config"
|
|
except Exception:
|
|
reenter_mode_source = "default"
|
|
if reenter_mode in ("follow_list", "screen_center"):
|
|
cmd += ["--reenter-live-entry-mode", reenter_mode]
|
|
|
|
self._start_process(cmd)
|
|
try:
|
|
# 放在 _start_process 之后,避免被启动时日志清空逻辑抹掉
|
|
self._append_log(
|
|
"[WEB_DEBUG] 启动参数解析:reenter_live_entry_mode="
|
|
f"{reenter_mode} source={reenter_mode_source}"
|
|
)
|
|
self._append_log(
|
|
"[WEB_DEBUG] 启动命令检查:cmd_has_reenter_flag="
|
|
f"{'--reenter-live-entry-mode' in cmd}"
|
|
)
|
|
except Exception:
|
|
pass
|
|
|
|
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._paused = False
|
|
self._owned_run_cli_pids.add(int(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("[网页] 读取线程:stdout 为 None,无法读取子进程输出")
|
|
try:
|
|
rc = p.wait()
|
|
except Exception:
|
|
rc = None
|
|
self._append_log(f"[网页] 进程退出(无输出):退出码={rc}")
|
|
with self._lock:
|
|
self._exit_code = rc
|
|
self._paused = False
|
|
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("[网页] 读取线程:子进程stdout已关闭")
|
|
except Exception as e:
|
|
self._append_log(f"[网页] 读取线程异常:{e}")
|
|
|
|
try:
|
|
rc = p.wait(timeout=1)
|
|
except subprocess.TimeoutExpired:
|
|
rc = None
|
|
self._append_log("[网页] 等待进程退出超时,强制终止")
|
|
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
|
|
try:
|
|
self._proc = None
|
|
self._pid = None
|
|
self._paused = False
|
|
self._owned_run_cli_pids.discard(int(p.pid))
|
|
except Exception:
|
|
pass
|
|
|
|
threading.Thread(target=_reader, daemon=True).start()
|
|
|
|
|
|
RUNNER = ProcRunner()
|
|
atexit.register(lambda: RUNNER.force_stop())
|
|
|
|
|
|
class Handler(BaseHTTPRequestHandler):
|
|
def _send_json(self, obj, status: int = 200) -> None:
|
|
send_json(self, obj, status=status)
|
|
|
|
def _read_json(self) -> dict:
|
|
return read_json(self)
|
|
|
|
def _serve_static(self, rel_path: str) -> None:
|
|
serve_static(
|
|
self,
|
|
webui_dir=WEBUI_DIR,
|
|
rel_path=rel_path,
|
|
log_error=lambda msg: _wg_log(msg, level="ERROR"),
|
|
)
|
|
|
|
def do_GET(self):
|
|
u = urlparse(self.path)
|
|
return handle_get(self, u, RUNNER, _CSRF_TOKEN)
|
|
|
|
def do_POST(self):
|
|
u = urlparse(self.path)
|
|
return handle_post(self, u, RUNNER, _CSRF_TOKEN)
|
|
|
|
|
|
def main() -> int:
|
|
require_online_license_or_exit()
|
|
start_online_license_monitor(on_line=lambda line: print(line, flush=True))
|
|
host = get_web_gui_host()
|
|
# 支持 PORT / WEB_GUI_PORT 两种环境变量,默认 8000
|
|
port = get_web_gui_port()
|
|
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] 收到中断,退出")
|
|
try:
|
|
RUNNER.force_stop()
|
|
except Exception:
|
|
pass
|
|
finally:
|
|
try:
|
|
httpd.server_close()
|
|
except Exception:
|
|
pass
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
try:
|
|
from douyin.core.version import print_version_banner
|
|
|
|
print_version_banner("web_gui")
|
|
except Exception:
|
|
pass
|
|
raise SystemExit(main())
|