release: prepare Web 2.0.1 automatic strategies and private updates

This commit is contained in:
AttilaNet
2026-11-11 12:52:08 +08:00
parent 5b1ef25048
commit 533280e007
30 changed files with 1177 additions and 107 deletions
+1 -1
View File
@@ -58,7 +58,7 @@ jobs:
- name: Install Web dependencies only
run: python -m pip install -r ranch_web/requirements.txt
- name: Offline updater regression
run: python -B -m unittest ranch_web.tests.test_updates ranch_web.tests.test_web_updater -v
run: python -B -m unittest ranch_web.tests.test_updates ranch_web.tests.test_web_updater ranch_web.tests.test_private_updates ranch_web.tests.test_web_updater_package -v
- name: Build image
env:
WEB_VERSION: ${{ steps.version.outputs.version }}
+1 -1
View File
@@ -1,6 +1,6 @@
FROM python:3.12-slim-bookworm
ARG WEB_VERSION=2.0.0
ARG WEB_VERSION=2.0.1
ARG VCS_REF=unknown
LABEL org.opencontainers.image.source="https://github.com/attilanet/myrzx_bot" \
org.opencontainers.image.title="myrzx_bot Web" \
+9 -7
View File
@@ -1,11 +1,11 @@
# 牧羊人之心Bot
当前 Web 正式版本 **2.0.0**,源码入口为 `main`;原生 PySide6 桌面正式版本保留 **1.2.0**(`v1.2.0`)。两者的适配资料基线均为《牧羊人之心》Android **1.9.68**。
本轮 Web 发布目标 **2.0.1**,源码入口为 `main`;原生 PySide6 桌面正式版本保留 **1.2.0**(`v1.2.0`)。两者的适配资料基线均为《牧羊人之心》Android **1.9.68**。
支持多账号独立运行、牧场培养、每日事务、主线与委托推进、近似战斗模拟、探险、扫荡及本地掉落分析,能力与验证限制见下文。
## 运行指引
### Web 2.0.0(main)
### Web 2.0.1(main)
Windows 使用 Python 3.12+,在项目根目录执行:
@@ -15,10 +15,12 @@ py -3 -m venv .venv-web
.\Start_Ranch_Web.cmd
```
访问 `http://127.0.0.1:8765`。配置管理密码后先在独立 `/login` 页面登录,再添加游戏账号、选择区服或恢复保存的会话;本机 loopback 未设置管理密码时可直接访问。配置功能后,手动点击顶部“开启”运行策略;重启、恢复会话或导入配置后,策略默认关闭。
访问 `http://127.0.0.1:8765`。配置管理密码后先在独立 `/login` 页面登录,再添加游戏账号、选择区服或恢复保存的会话;本机 loopback 未设置管理密码时可直接访问。手动选服、恢复会话及自动重登成功读取角色后,默认开启策略,自动执行已配置且已勾选的功能,可用顶部“停止”暂停;各子功能仍按原有勾选生效,不会全选。导入配置只替换规则并停止执行,下次成功登录仍会自动开启;服务重启后未成功登录时不直接执行。
Web 无需 Node/npm 或 PySide6,数据独立保存在 `local_state/ranch_web`。Linux Python 启动、离线演示与环境配置见 [Web 运行说明](ranch_web/README.md);单服务 Docker、`/data` 持久化、子路径反代与宿主机受控更新见 [Web 部署说明](deploy/web/README.md)。
**2.0.1** 支持登录成功后自动执行已勾选策略,由用户手动触发在线更新。在线更新使用稳定 GitHub Release、对应正式镜像及心跳有效的宿主机受控更新器;私有仓库首次配置见[部署说明](deploy/web/README.md),更新结果以宿主机健康检查为准。
### 桌面 1.2.0
1. 在 Windows 中安装 Python 3,并确保 `python` 命令可用。
@@ -34,7 +36,7 @@ Web 无需 Node/npm 或 PySide6,数据独立保存在 `local_state/ranch_web`
| 组件与版本 | 《牧羊人之心》Android 基线 | 入口与状态 |
| --- | --- | --- |
| Web 2.0.0 | 1.9.68 | 正式版本;源码入口 `main`,`Start_Ranch_Web.cmd` / `sh start-web.sh` |
| Web 2.0.1 | 1.9.68 | 本轮发布目标;源码入口 `main`,`Start_Ranch_Web.cmd` / `sh start-web.sh` |
| 桌面 1.2.0(`v1.2.0`) | 1.9.68 | 当前桌面版本;`Start_Ranch_Helper.cmd` / `python -m ranch_assistant` |
| 桌面 1.1.1(`v1.1.1`) | 1.9.68 | 历史正式版本,1.1 系列修复与界面更新 |
| 桌面 1.1.0(`v1.1.0`) | 1.9.68 | 历史已发布版本 |
@@ -42,7 +44,7 @@ Web 无需 Node/npm 或 PySide6,数据独立保存在 `local_state/ranch_web`
本表记录适配资料基线,不代表其他客户端版本兼容或全部功能已完成实机验收。Docker 镜像以标签流水线成功结果为准,在线更新依赖对应 GitHub Release 条目;详见 [部署说明](deploy/web/README.md)。
## Web 2.0.0 主要功能与掉线修复
## Web 2.0.1 主要功能与掉线修复
- **原布局与15页**:沿用桌面页面顺序、账号页签、顶部玩家数值与统一启停、可调整日志区。
- **多账号与独立后台**:各账号隔离并行、同账号请求串行;关闭网页或退出管理登录后,服务端继续监控及已开启的策略。
@@ -50,9 +52,9 @@ Web 无需 Node/npm 或 PySide6,数据独立保存在 `local_state/ranch_web`
- **策略与数据**:复用孵蛋、牧场、喂养、突破、赠礼、每日、主线、委托、探险和扫荡策略,支持自动保存、导入导出、执行计划及掉落分析。
- **日志与更新**:普通日志按账号限量持久保存,调试详情按进程缓存;仅检查官方稳定 2.x Release,未配置执行器时仅检查,受控安装与备份/回滚由宿主机执行,自动安装默认关闭。
本次修复连接状态误判:区分在线、临时故障重试、游戏会话失效与未连接,显示最后成功通信及下次重试时间,旧快照标注为缓存。临时故障先停止策略,再退避执行只读探测;会话失效时停止游戏轮询,需手动恢复或重新登录。恢复成功后仍需手动开启策略,未确认的写操作不自动重发,页面轮询不会清除游戏连接错误。
连接状态区分在线、临时故障重试、游戏会话失效与未连接,显示最后成功通信及下次重试时间,旧快照标注为缓存。临时故障先停止策略,再退避执行只读探测;会话失效时停止游戏轮询,按自动重登设置等待,或手动恢复、重新登录。手动选服、恢复会话及自动重登成功后,均自动执行已勾选功能,可在顶部停止。获取区服候选或登录失败不视为成功;未确认的写操作不自动重发,页面轮询不会清除游戏连接错误。
战斗模拟仍为近似模型,特殊关卡并非全部支持。已有离线回归和早期部署烟测的阶段、命令及限制见 [Web 验证说明](ranch_web/README.md#离线验证);这些记录不代表正式 2.0.0 已完成真实游戏 API 或生产升级/回滚验收。
战斗模拟仍为近似模型,特殊关卡并非全部支持。已有离线回归和早期部署烟测的阶段、命令及限制见 [Web 验证说明](ranch_web/README.md#离线验证);这些记录不代表 2.0.1 已完成真实游戏 API 或生产升级/回滚验收。
## 桌面 1.2.0 功能基线
+39
View File
@@ -0,0 +1,39 @@
# 2.0.1
适配资料基线:《牧羊人之心》Android 1.9.68。保留原有 Web 布局及桌面 1.2.0 入口。
## 登录后自动执行
- 账号登录并进入区服、恢复会话、掉线自动重登录成功后,自动开启全局策略开关。
- 只执行已配置且已勾选的规则,不会自动勾选所有功能。没有规则时保持待命,之后配置即可生效。
- 顶部“停止”继续有效,状态刷新和心跳不会重新开启;下次成功登录时才自动开启。
- 获取区服列表、登录失败、身份不匹配、被取消的候选和单独导入配置均不会启动策略;未确认操作继续保留核对记录。
## 掉线重登录
登录页可按账号开启自动重登录,等待时长默认 30 分钟。使用服务端加密保存的账号密码,核对原区服、原角色后连接;关闭网页不影响计时。主动退出或清除记录会取消本次自动计划。
## 私有仓库在线更新
发布附件提供独立的 `updater.pyz` 及 `SHA256SUMS`,宿主机只需 Python 3.12+ 和原有 Docker/Compose。
当前旧更新器不支持私有仓库认证,需要由操作者首次初始化新版宿主机更新器。初始化后,由操作者手动检查或点击更新,应用通过拉取正式镜像、停机备份、健康检查及失败回滚完成更新,不需要上传应用源码。
1. 登录 GitHub,在本发布页下载 `updater.pyz` 和 `SHA256SUMS`,校验文件后,将更新器安装到宿主机 `/opt/ranch-web/updater.pyz`。
2. 按[私有仓库更新说明](https://github.com/AttilaNet/myrzx_bot/blob/v2.0.1/deploy/web/README.md)设置服务端 GitHub 发布读取凭据,并完成 GHCR 镜像读取认证。
3. 首次在线更新可执行:
```sh
sudo python3 -B /opt/ranch-web/updater.pyz --config /etc/ranch-web-updater.toml --check
sudo python3 -B /opt/ranch-web/updater.pyz --config /etc/ranch-web-updater.toml --apply v2.0.1
```
4. 按说明让现有 systemd 更新定时器使用新版 `updater.pyz`,此后可在网页“检查版本更新”中手动触发;自动安装默认关闭。
凭据仅保存在服务端文件中,不进入版本资产、策略导出或公共日志。没有权限时明确提示认证问题,不再将私有仓库不可访问误报成“没有新版本”。
服务器更新由操作者手动触发,自动安装默认关闭。战斗模型及特殊关卡支持范围沿用现有实现,未以真实游戏账号执行发布回归。
## 验证
本地后端及更新器回归共 297 项:294 通过,3 项因 Windows 权限或软链接限制跳过;浏览器 43 项全部通过。独立宿主机包通过隔离模式下的版本、帮助与 dry-run 检查。正式镜像由对应标签的 Linux 工作流构建并检查后发布。
+2 -2
View File
@@ -1,11 +1,11 @@
name: ranch-web
services:
web:
image: ${RANCH_WEB_IMAGE:-ghcr.io/attilanet/myrzx_bot-web:v2.0.0}
image: ${RANCH_WEB_IMAGE:-ghcr.io/attilanet/myrzx_bot-web:v2.0.1}
build:
context: .
args:
WEB_VERSION: ${RANCH_WEB_BUILD_VERSION:-2.0.0}
WEB_VERSION: ${RANCH_WEB_BUILD_VERSION:-2.0.1}
user: "10001:10001"
init: true
restart: unless-stopped
+85 -11
View File
@@ -1,6 +1,8 @@
# Web 2.0.0 Linux Docker 部署与更新
# Web 2 Linux Docker 部署与更新
本目录对应 Web 正式版本 `2.0.0`,源码入口 `main`;游戏资料基线为 `1.9.68`,桌面版保留 `1.2.0`。Docker 镜像以稳定 `v2.x.y` 标签流水线成功结果为准,以下 pull 命令仅在对应镜像已发布且可访问后可用。在线更新依赖对应 GitHub Release 条目;仅有 merge/tag 时可能仍显示“暂无正式版”,不会安装旧桌面 1.2.0。
以下更新示例以 `v2.0.1` 为目标;游戏资料基线为 `1.9.68`,桌面版保留 `1.2.0`。镜像流水线成功、Git tag 与 GitHub Release 是不同的发布步骤:在线更新必须等对应镜像及非草稿、非预发布的 Release 均发布后才能使用。私有仓库未获授权返回 404 属于访问失败,不代表没有版本;只有成功读取列表且没有稳定 2.x 时才显示“暂无正式版”。
已有部署首次接入私有在线更新时,按下文“已有宿主机首次初始化”操作。旧应用和旧更新器需要先配置私有发布认证,再由新版独立更新器在线拉取 `v2.0.1` 镜像。
## 容器与持久化
@@ -17,7 +19,7 @@ sudo install -m 0600 -o root -g root deploy/web/image.env.example .image.env
sudoedit .env .image.env
```
在 `.env` 填入独立的 `RANCH_WEB_PASSWORD`,这是 Web 管理密码,不是游戏密码;`.image.env` 示例默认 `RANCH_WEB_IMAGE=ghcr.io/attilanet/myrzx_bot-web:v2.0.0`,需确认对应镜像已发布后再 pull。Compose 默认只发布到宿主机 `127.0.0.1:8765`,容器内监听 `0.0.0.0:8765` 并强制管理密码。使用域名反代时,同时配置 `RANCH_WEB_ALLOWED_HOSTS` 与 `RANCH_WEB_ALLOWED_ORIGINS`;TLS 入口设置 `RANCH_WEB_SECURE_COOKIE=true`。代理保留正确的 Host,写请求依赖来源校验。
在 `.env` 填入独立的 `RANCH_WEB_PASSWORD`,这是 Web 管理密码,不是游戏密码;`.image.env` 选择 `RANCH_WEB_IMAGE=ghcr.io/attilanet/myrzx_bot-web:v2.0.1`,需确认对应镜像已发布后再 pull。Compose 默认只发布到宿主机 `127.0.0.1:8765`,容器内监听 `0.0.0.0:8765` 并强制管理密码。使用域名反代时,同时配置 `RANCH_WEB_ALLOWED_HOSTS` 与 `RANCH_WEB_ALLOWED_ORIGINS`;TLS 入口设置 `RANCH_WEB_SECURE_COOKIE=true`。代理保留正确的 Host,写请求依赖来源校验。
`/opt/ranch-web/data` 挂到容器 `/data`,包括账号、加密会话与密钥、配置、SQLite 统计和更新请求;独立于桌面数据。心跳控制目录独立只读挂到 `/run/ranch-updater`。使用 bind mount 的目录必须预先创建,Compose 不会悄悄创建 root 所有、容器无法写入的目录。默认容器用户 `10001:10001`,根文件系统只读,临时文件写到 `/tmp`。不要对现有账号目录重新初始化密钥。
@@ -32,7 +34,7 @@ curl --fail http://127.0.0.1:8765/api/health
脚本固定读取 `.env` 与 `.image.env`,相当于 `docker compose --project-name ranch-web --env-file .env --env-file .image.env --file compose.yaml ...`。更新器会持久化已选镜像到 `.image.env`,之后也应通过此脚本启动,以免误用默认镜像版本。
GitHub 首次创建 GHCR 包可能为私有;仓库管理员可将 `myrzx_bot-web` 包设为 Public。私有包部署需操作者先在宿主机执行 `sudo docker login ghcr.io`,使用具备 `read:packages` 的凭据;不要把 registry 凭据交给 Web 容器。[GHCR 官方文档](https://docs.github.com/en/packages/working-with-a-github-packages-registry/working-with-the-container-registry)
私有 GHCR 包由用户先在宿主机为运行更新器的 root 用户配置一次 `docker login ghcr.io --password-stdin`,见下文。仓库与镜像可以保持私有;registry 凭据由宿主机 Docker 管理,不交给 Web 容器,也不从开发机迁移。
若仅在 Linux 上验证审核后的 `main` 源码,可在本地构建后启动;这不会发布镜像,也不要求远端已有对应镜像:
@@ -47,22 +49,92 @@ sudo sh deploy/web/compose.sh up -d --no-build --pull never --wait --wait-timeou
Web 只读检查官方 GitHub Releases;默认只接受 `v2.MINOR.PATCH`,跳过草稿、预发布、1.x、3.x 和非法标签。数字不含前导零。`2.0.0.dev1 → v2.0.0` 可升级,`2.0.0 → v2.0.0` 不升级,拒绝降级。网络失败会明确显示检查失败,不使用虚构版本或下载脚本。
先安装 root 持有的配置(示例的所有自动化开关默认关闭):
全新安装时,先安装 root 持有的配置,并准备独立更新器(示例的自动化开关默认关闭):
```sh
sudo install -m 0600 -o root -g root deploy/web/updater.example.toml /etc/ranch-web-updater.toml
sudo python3 -B deploy/web/updater.py --config /etc/ranch-web-updater.toml --check
sudo python3 -B deploy/web/updater.py --config /etc/ranch-web-updater.toml --apply v2.0.0
python3 -B tools/build_web_updater.py --output /tmp/updater.pyz
sudo install -m 0644 -o root -g root /tmp/updater.pyz /opt/ranch-web/updater.pyz
python3 -B /opt/ranch-web/updater.pyz --version
```
也可从对应 Release 下载 `updater.pyz` 及 `SHA256SUMS`,核对后安装,宿主机不需要完整 Python 源码或 pip 依赖。构建器只打包 `__main__.py`、`updater.py`、`ranch_web/__init__.py`、`ranch_web/updates.py`,版本取构建时的 `ranch_web.__version__`;维护者升版后需重新生成资产。原有 `python3 -B deploy/web/updater.py ...` CLI 仍可运行,本文的 service 默认使用 `/opt/ranch-web/updater.pyz`。
### 已有宿主机首次初始化(用户自行执行)
前提是原有 `/opt/ranch-web` Compose 部署、数据目录及 `/etc/ranch-web-updater.toml` 均已存在,配置仍由 root 持有。保留原有数据和配置,不重新初始化密钥;数据目录由 `10001:10001` 持有。以下仅初始化在线更新器,不需要复制项目源码或 Compose。
1. 用户登录有私有仓库读取权限的 GitHub 账号,从 [v2.0.1 Release](https://github.com/attilanet/myrzx_bot/releases/tag/v2.0.1) 下载 `updater.pyz` 和 `SHA256SUMS`,放到宿主机临时目录。确认 Release 已发布且镜像可读取,在下载目录执行 `sha256sum -c SHA256SUMS` 后安装:
```sh
sudo install -m 0644 -o root -g root updater.pyz /opt/ranch-web/updater.pyz
python3 -B /opt/ranch-web/updater.pyz --help
python3 -B /opt/ranch-web/updater.pyz --version
python3 -B /opt/ranch-web/updater.pyz --config /etc/ranch-web-updater.toml --apply v2.0.1 --dry-run
```
`--version` 应显示 `ranch-web-updater 2.0.1`;`--help`、`--version` 和 `--dry-run` 均不联网、不读取 Token、不调用 Docker,dry-run 不创建文件。Python 需为 3.12+。
2. 用户创建只授予本仓库 Contents **read** 的 fine-grained GitHub Token,用交互终端输入;值不出现在 argv、shell 历史或更新状态中:
```sh
sudo python3 -B /opt/ranch-web/updater.pyz --config /etc/ranch-web-updater.toml --set-github-token
```
该命令只在本机原子保存 `<data_dir>/update-github-token`,不联网验证。默认宿主机路径 `/opt/ranch-web/data/update-github-token`,权限 `0600`、所有者 `10001:10001`;容器通过现有 `/data` 挂载读取同一文件 `/data/update-github-token`。文件为单个 ASCII Token(可带末尾换行、总长最多 4096 字节),拒绝软链接、硬链接及 POSIX 下非 `0600` 文件。更新器只向固定 `https://api.github.com/repos/attilanet/myrzx_bot/releases` 发送 Authorization,禁止重定向;错误、DTO 与日志不输出 Token。
默认文件不存在时继续匿名访问,兼容公共仓库。可显式设置环境变量 `RANCH_WEB_UPDATE_GITHUB_TOKEN_FILE` 为绝对**文件路径**,不可填 Token;显式路径缺失或文件不安全会失败,不会回退匿名。宿主机和容器的覆盖路径需各自可见,现有 Compose 不透传这个可选环境变量,通常应直接用默认共享文件。不要将 Token 写入 TOML、请求 JSON 或 Web 表单。[GitHub Releases 权限说明](https://docs.github.com/en/rest/releases/releases#list-releases)
3. GHCR 使用另一份凭据:有镜像读取权限的用户创建 PAT **classic**,授予 `read:packages`(组织要求时授权 SSO)。Releases 的 fine-grained Token 不保证能用于 Docker。以下 Bash 命令由用户在宿主机终端执行一次,Token 通过 stdin 传给 root 的 Docker,不放入命令参数:
```bash
sudo -v
read -r -p 'GitHub username: ' ranch_ghcr_user
read -r -s -p 'GHCR read:packages PAT (hidden): ' ranch_ghcr_pat
printf '\n'
printf '%s' "$ranch_ghcr_pat" | sudo docker --context default login ghcr.io --username "$ranch_ghcr_user" --password-stdin
unset ranch_ghcr_pat ranch_ghcr_user
```
Docker 保存的宿主机登录配置供更新器拉镜像使用;不要复制开发机的 Git/registry 凭据,也不要把 Docker 凭据放进 GitHub Token 文件或 Web 容器。[GHCR 官方认证说明](https://docs.github.com/en/packages/working-with-a-github-packages-registry/working-with-the-container-registry)
4. 使用新包先检查再由用户明确发起在线更新:
```sh
sudo python3 -B /opt/ranch-web/updater.pyz --config /etc/ranch-web-updater.toml --check
sudo python3 -B /opt/ranch-web/updater.pyz --config /etc/ranch-web-updater.toml --apply v2.0.1
```
新更新器会独立复验官方 Release、严格版本递增、固定官方镜像,并执行原有备份、健康检查与失败回滚。旧 Web 即使尚不能查询私有发布,此命令仍可启动更新;更新到含新私有支持的镜像后,Web 的检查/请求才会读取共享 Token。只有 tag 或镜像、尚无 2.x Release 时仍不能更新;不要把旧页面的匿名 404 当成“已是最新”。
5. 让原有 systemd timer 执行新包。用户运行 `sudo systemctl edit ranch-web-updater.service`,只添加一次覆盖:
```ini
[Service]
ExecStart=
ExecStart=/usr/bin/python3 -B /opt/ranch-web/updater.pyz --config /etc/ranch-web-updater.toml --run
```
随后执行:
```sh
sudo systemctl daemon-reload
sudo systemctl enable --now ranch-web-updater.timer
sudo systemctl start ranch-web-updater.service
```
原有 service 的 root、目录保护和 Docker 登录访问保持有效。新包成功初始化后,未来 Web 请求及 timer 都使用相同私有查询逻辑;未来要升级独立更新器本身时,仍由用户下载并替换受信任的 `updater.pyz`。`auto_apply=false` 继续默认关闭,允许 Web 按钮需另外显式设置 `accept_web_requests=true`。
`--apply` 不传版本时选比运行中版本更新的最新稳定 2.x。手动操作和定时任务共享排他锁。执行器固定官方仓库及镜像地址,重新查询 Releases 验证来源;Web 即使伪造 `update-request.json` 也不能指定命令、下载地址、路径或第三方镜像。
执行顺序:旧容器运行期间先 `compose pull --policy always web`;拉取失败则保持旧服务。然后停服,确认所有容器写入停止,为完整数据目录创建一致的快照(包含 SQLite 文件及 WAL、加密密钥);最后用新镜像 `compose up -d --no-build --pull never --wait --wait-timeout 180 web`。镜像已有 `/api/health` healthcheck,检查成功后才记录更新完成。
新服务健康失败时,更新器停止失败容器、恢复更新前数据、用旧镜像的准确本地 image ID 启动并检查健康。失败版本数据移入 `failed-data/`,快照保存在 `backups/`,均不自动删除。快照文件权限为 0600、备份目录 0700;不会打印账号数据、密钥、Compose 环境或容器日志。回滚也失败时保留恢复事务,下一次更新器运行会先恢复,需操作者检查服务状态。镜像拉取和停机发生在宿主机;Web 容器没有 Docker socket。
新服务健康失败时,更新器停止失败容器、恢复更新前数据、用旧镜像的准确本地 image ID 启动并检查健康。失败版本数据移入 `failed-data/`,快照保存在 `backups/`,均不自动删除。快照包含默认共享 Token 文件以及应用密钥,快照文件权限为 0600、备份目录 0700;不会打印账号数据、密钥、Compose 环境或容器日志。回滚也失败时保留恢复事务,下一次更新器运行会先恢复,需操作者检查服务状态。镜像拉取和停机发生在宿主机;Web 容器没有 Docker socket。
## 定时检查、Web 按钮与自动更新
全新部署确认已按上文生成或下载安装 `/opt/ranch-web/updater.pyz` 后,再安装以下 service;已有部署使用上文的一次性 override。
```sh
sudo install -m 0644 deploy/web/ranch-web-updater.service /etc/systemd/system/
sudo install -m 0644 deploy/web/ranch-web-updater.timer /etc/systemd/system/
@@ -79,13 +151,15 @@ Windows 或未安装执行器的 Docker 部署仍能检查版本,但按钮会
## CI 与验证范围
[web-image.yml](../../.github/workflows/web-image.yml) 仅对官方仓库的严格稳定 `v2.x.y` tag 推送 `ghcr.io/attilanet/myrzx_bot-web:v2.x.y`;校验 `ranch_web.__version__` 必须与 tag 一致,不能只改变镜像 label。PR 与手动运行只测试、构建,不推送。开发分支 push 不触发正式镜像发布,也没有 `latest` 滚动升级通道。CI 规划在无外网容器中检查 healthcheck、非 root 数据写权限、无 Qt 和正常停止;本轮没有触发 CI 或发布。
[web-image.yml](../../.github/workflows/web-image.yml) 仅对官方仓库的严格稳定 `v2.x.y` tag 推送 `ghcr.io/attilanet/myrzx_bot-web:v2.x.y`;校验 `ranch_web.__version__` 必须与 tag 一致,不能只改变镜像 label。PR 与手动运行只测试、构建,不推送。开发分支 push 不触发正式镜像发布,也没有 `latest` 滚动升级通道。CI 执行更新器、私有凭据和独立包回归,并在无外网容器中检查 healthcheck、非 root 数据写权限、无 Qt 和正常停止;镜像发布状态以对应 tag 的工作流结果为准。
本机 Windows 没有 Docker,已能执行的验证是离线单元测试、临时数据的备份/回滚测试、启动脚本语法与配置静态核对、更新器 dry-run;不代表 Linux/Docker 实机验证通过。可在无 Docker 的机器上只打印计划(不联网、不写文件):
```sh
python -B deploy/web/updater.py --config deploy/web/updater.example.toml --apply v2.0.0 --dry-run
python -B -m unittest ranch_web.tests.test_updates ranch_web.tests.test_web_updater -v
python -B tools/build_web_updater.py --output test-artifacts/updater.pyz
python -B test-artifacts/updater.pyz --version
python -B test-artifacts/updater.pyz --config deploy/web/updater.example.toml --apply v2.0.1 --dry-run
python -B -m unittest ranch_web.tests.test_updates ranch_web.tests.test_web_updater ranch_web.tests.test_private_updates ranch_web.tests.test_web_updater_package -v
```
命令参数依据 [Compose up](https://docs.docker.com/reference/cli/docker/compose/up/)、[Compose pull](https://docs.docker.com/reference/cli/docker/compose/pull/);发布权限与 GHCR 认证依据 [GitHub 镜像发布流程](https://docs.github.com/en/actions/tutorials/publish-packages/publish-docker-images)。检查使用 [GitHub Releases 列表 API](https://docs.github.com/en/rest/releases/releases#list-releases),不依赖可能指向桌面版的 `/latest`。
+8 -2
View File
@@ -1,6 +1,6 @@
# Web 2 更新接口(协议 1)
供 API、前端、宿主机更新器与 Main 集成。`ranch_web.updates.UpdateService(root, current_version)` 只依赖 Python 标准库;构造和 `status()` 不联网,`check()` 才访问固定官方 GitHub Releases,`request_update(version=None)` 仅提交文件请求。API 可在线程池中调用检查,不能在事件循环里等待网络。
供 API、前端、宿主机更新器与 Main 集成。`ranch_web.updates.UpdateService(root, current_version)` 只依赖 Python 标准库;构造和 `status()` 不联网,`check()` 访问固定官方 GitHub Releases,`request_update(version=None)` 再次联网验证后仅提交文件请求。宿主机 `HostUpdater.apply()` 独立再次验证发布。API 可在线程池中调用检查,不能在事件循环里等待网络。
- 固定仓库:`attilanet/myrzx_bot`;固定镜像:`ghcr.io/attilanet/myrzx_bot-web`。
- 唯一可选发布 tag:`v2.MINOR.PATCH`(十进制、不许前导零、无任何后缀)。草稿、预发布、1.x、3.x、dev 分支全部跳过;按版本数值比较,不信任 GitHub latest 排序。
@@ -9,6 +9,12 @@
- 心跳由宿主机定时任务写入,含 `protocol=1, executor_id, enabled, auto_apply, heartbeat_at, expires_at`。执行器配置默认 `accept_web_requests=false, auto_apply=false`,操作者必须显式启用 Web 请求。心跳有效期 15 分钟、timer 每 5 分钟运行。
- `update-request.json` 仅含 `protocol=1, request_id`(32 位小写十六进制)、`executor_id`、`version`(官方 tag)、`requested_at`(UTC ISO 8601)。禁止镜像地址、命令、下载地址或路径。宿主机再次联网验证 tag、版本单调递增并去重;Web 写文件不等于部署成功。
私有发布凭据只来自服务端 `<root>/update-github-token`,宿主机使用配置中的 `data_dir`;Docker 默认通过既有挂载共享同一文件。POSIX 权限必须为 `0600`,普通文件、非软/硬链接、最多 4096 字节;部署所有者为 `10001:10001`。可选 `RANCH_WEB_UPDATE_GITHUB_TOKEN_FILE` 仅接受绝对文件路径,显式无效路径直接失败。未提供覆盖且默认文件缺失时保持匿名公共访问;不读取 Git 凭据、不接收原始 Token 环境变量/TOML/Web 参数。低层 `github_releases(data_dir=None)` 保留无参数公共调用形式,服务与宿主机均传入自己的数据目录,每次查询重新读文件。
GitHub Authorization 只发往固定 `https://api.github.com/repos/attilanet/myrzx_bot/releases`,不跟随任何重定向。`401/403/404` 为 `check_failed`,固定 `message/error` 提醒检查私有仓库访问权限;凭据文件失效同样返回 `check_failed` 与固定文件权限提示,不能当作 `no_release`。本地 `update-check.json` 可记录白名单 `failure` 代码 `access_denied/token_file_invalid/check_failed`;公共 DTO 字段和协议号不变,不返回 Token、Token 路径、响应原文或原始异常。`request_update` 与宿主机复验遇到访问失败则拒绝请求/更新,保持原服务。
GitHub Releases 可使用限定仓库、Contents read 的 fine-grained Token;GHCR 由用户另用 PAT classic 的 `read:packages` 权限通过 `docker login --password-stdin` 配置。两份凭据分别管理,不假定 fine-grained Token 能拉私有镜像。独立 `updater.pyz` 构建/运行 CLI 及已有宿主机的一次性初始化、systemd override 见 [README.md](README.md);旧应用必须先经用户安装新宿主机更新器并升级镜像,才具有私有 Web 更新能力。
三个方法返回同一公共 DTO,示例:
```json
@@ -36,7 +42,7 @@
}
```
`status`:`unchecked / no_release / up_to_date / available / check_failed / unavailable / pending / applying / succeeded / rolled_back / failed`。无 2.x 正式版时 `latest_version=null, available=false, status=no_release`,不可退到桌面 1.2。
`status`:`unchecked / no_release / up_to_date / available / check_failed / unavailable / pending / applying / succeeded / rolled_back / failed`。仅成功读取列表且无 2.x 正式版时 `latest_version=null, available=false, status=no_release`,不可退到桌面 1.2。镜像构建成功或存在 tag 均不能替代正式 Release。
提交成功返回 `status=pending`,`request={request_id,version,requested_at,status:"pending"}`;前端应显示“等待宿主机”,定时 GET 状态。宿主机结果 `host_status={request_id,status,version,updated_at,error}`,错误是固定脱敏说明,不含原始异常、文件路径或子进程输出。`request_update` 在缺少执行器时返回 `status=unavailable` 和具体 `message`;非法/非官方/倒退版本抛 `ValueError`,API 映射 400。API `/apply` 的 HTTP 接受响应不应宣称已经升级;更新完成由宿主机健康检查决定。
+2 -2
View File
@@ -1,2 +1,2 @@
# Pull only after the v2.0.0 image publishing workflow succeeds and the image is available.
RANCH_WEB_IMAGE=ghcr.io/attilanet/myrzx_bot-web:v2.0.0
# Pull only after the v2.0.1 image publishing workflow succeeds and the image is available.
RANCH_WEB_IMAGE=ghcr.io/attilanet/myrzx_bot-web:v2.0.1
+1 -1
View File
@@ -10,7 +10,7 @@ Type=oneshot
User=root
Group=root
WorkingDirectory=/opt/ranch-web
ExecStart=/usr/bin/python3 -B /opt/ranch-web/deploy/web/updater.py --config /etc/ranch-web-updater.toml --run
ExecStart=/usr/bin/python3 -B /opt/ranch-web/updater.pyz --config /etc/ranch-web-updater.toml --run
TimeoutStartSec=30min
TimeoutStopSec=180s
UMask=0077
+5
View File
@@ -1,6 +1,11 @@
# Root-owned operator configuration. Never put this file in /data.
project_dir = "/opt/ranch-web"
data_dir = "/opt/ranch-web/data"
# Optional private GitHub releases: data_dir/update-github-token, mode 0600,
# owned by 10001:10001 (same file is /data/update-github-token in the app).
# Set with: sudo python3 -B /opt/ranch-web/updater.pyz --config /etc/ranch-web-updater.toml --set-github-token
# Optional ENV RANCH_WEB_UPDATE_GITHUB_TOKEN_FILE is an absolute PATH, not a token.
# Private GHCR access is configured separately by the operator via docker login --password-stdin.
control_dir = "/opt/ranch-web/updater-control"
backup_dir = "/opt/ranch-web/backups"
failed_data_dir = "/opt/ranch-web/failed-data"
+47 -3
View File
@@ -2,7 +2,8 @@
"""Root-owned Linux host updater; no shell, Docker socket, or code in Web.
Use --check for notification, --apply [v2.x.y] for an operator update, or
--run from the timer. --dry-run never contacts GitHub or Docker or writes files.
--run from the timer. --set-github-token prompts for a local credential file.
--dry-run never contacts GitHub or Docker or writes files.
"""
from __future__ import annotations
@@ -10,6 +11,7 @@ import argparse
from contextlib import contextmanager
from dataclasses import dataclass, fields
from datetime import timedelta
import getpass
import json
import os
from pathlib import Path, PurePosixPath
@@ -23,10 +25,12 @@ import tarfile
import tempfile
import tomllib
import uuid
import warnings
# This import is standard-library-only; no FastAPI/Qt installation on the host.
if __name__ == "__main__":
sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
from ranch_web import updates # noqa: E402
from ranch_web import __version__, updates # noqa: E402
_DIGEST = re.compile(r"sha256:[0-9a-f]{64}", re.ASCII)
_CONTAINER = re.compile(r"[0-9a-f]{12,64}", re.ASCII)
@@ -323,7 +327,9 @@ class HostUpdater:
if not old["running"]:
raise UpdaterError("现有服务未运行,请先由操作者处理。")
try:
tags = updates.official_tags(updates.github_releases())
tags = updates.official_tags(updates.github_releases(self.config.data_dir))
except updates.GitHubReleaseError as error:
raise UpdaterError(str(error)) from None
except Exception:
raise UpdaterError("无法独立验证官方 GitHub 正式发布,保留现有服务。") from None
target = version or (max(tags, key=updates.stable_version) if tags else None)
@@ -436,18 +442,53 @@ def interrupt_update(signum, frame):
raise InterruptedError("宿主机正在停止更新任务。")
def set_github_token(config):
"""Operator-only local setup: no argv secret, network, or credential discovery."""
try:
# getpass must not fall back to echoed input on a non-interactive console.
with warnings.catch_warnings():
warnings.simplefilter("error", getpass.GetPassWarning)
token = getpass.getpass("GitHub read-only release token (hidden): ")
token = updates._validate_token((token + "\n").encode("ascii"))
path = updates.github_token_path(config.data_dir)
if path.is_symlink():
raise updates.GitHubReleaseError("token_file_invalid")
descriptor, temporary = tempfile.mkstemp(prefix=".update-token-", dir=path.parent)
try:
with os.fdopen(descriptor, "w", encoding="ascii", newline="\n") as stream:
os.chmod(temporary, 0o600)
if hasattr(os, "chown"):
os.chown(temporary, 10001, 10001)
stream.write(token + "\n")
stream.flush()
os.fsync(stream.fileno())
os.replace(temporary, path)
finally:
if os.path.exists(temporary):
os.unlink(temporary)
except (OSError, UnicodeError, updates.GitHubReleaseError, EOFError, getpass.GetPassWarning, KeyboardInterrupt):
raise UpdaterError("GitHub Token 未保存;请使用交互终端并检查服务端文件与数据目录权限。") from None
return {"status": "configured", "message": "GitHub 只读 Token 已保存为 0600 文件;尚未联网验证权限。"}
def main(argv=None):
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--version", action="version", version=f"ranch-web-updater {__version__}")
parser.add_argument("--config", default="/etc/ranch-web-updater.toml")
mode = parser.add_mutually_exclusive_group(required=True)
mode.add_argument("--check", action="store_true")
mode.add_argument("--apply", nargs="?", const="", metavar="v2.x.y")
mode.add_argument("--run", action="store_true")
mode.add_argument("--set-github-token", action="store_true", help="interactively save a server-side token file")
parser.add_argument("--dry-run", action="store_true")
args = parser.parse_args(argv)
try:
config = Config.load(args.config, dry_run=args.dry_run)
if args.dry_run:
if args.set_github_token:
result = {"dry_run": True, "mode": "set-github-token",
"steps": ["prompt for read-only GitHub token; atomically save 0600 file owned by UID/GID 10001"]}
else:
result = dry_run(config, "check" if args.check else "run" if args.run else "apply", args.apply)
else:
if sys.platform != "linux" or os.geteuid() != 0:
@@ -467,6 +508,9 @@ def main(argv=None):
raise UpdaterError("执行器控制目录必须由 root 持有且禁止其他用户写入。")
signal.signal(signal.SIGTERM, interrupt_update)
with exclusive(config):
if args.set_github_token:
result = set_github_token(config)
else:
updater = HostUpdater(config)
recovery = updater.recover()
if recovery:
+4 -2
View File
@@ -1,8 +1,8 @@
# 牧羊人之心牧场助手 · Web 2.0.0
# 牧羊人之心牧场助手 · Web 2.0.1
## 产品约束
把现有桌面助手的功能和操作结构迁移至单管理员 Web 工作台。桌面版是页面顺序、信息密度、业务名称、保护条件与交互的依据,保留桌面兼容。Web 正式版本为 `2.0.0`,源码入口 `main`,游戏数据版本 `1.9.68`;桌面正式版保留 `1.2.0`。启动与配置见 [运行说明](README.md),Docker 与更新条件见 [部署说明](../deploy/web/README.md)。
把现有桌面助手的功能和操作结构迁移至单管理员 Web 工作台。桌面版是页面顺序、信息密度、业务名称、保护条件与交互的依据,保留桌面兼容。本轮 Web 发布目标为 `2.0.1`,源码入口 `main`,游戏数据版本 `1.9.68`;桌面正式版保留 `1.2.0`。启动与配置见 [运行说明](README.md),Docker 与更新条件见 [部署说明](../deploy/web/README.md)。
使用者在 Windows 本机配置、验证,随后可在 Linux Docker 常驻运行。多个浏览器访问同一个管理员工作台;账号互相隔离,各账号串行执行,账号之间可以并行。
@@ -17,12 +17,14 @@
## 核心操作
- 账号密码登录后选择区服进入;恢复已保存会话;退出与清除登录记录。游戏凭据仅交给同源服务端,不进入浏览器持久存储或 URL。
- 手动选服、恢复会话和自动重登成功读取角色后,均默认开启策略,自动执行已配置且已勾选的功能,可在顶部停止;不改变各子功能的勾选。获取区服候选及失败候选不视为登录成功,界面以服务端在线与运行状态为准。导入配置只替换规则并停止执行,下次成功登录仍自动开启;服务重启后未成功登录时不直接执行。
- 配置通过中文 schema 生成原生控件;逐蛋孵化/补货规则、物品赠礼保留量、逐魔物培养目标、关卡规则等直接在对应页面编辑。自动保存显示待保存、保存中、失败与已保存状态。
- 培育室扩建、牧场锁定/解锁、批量派遣/喂养、上下文菜单和费用二次确认沿用核心行为。切换功能页只读取视图,不触发游戏写操作。
- 主线默认当前主线,可切换筛选。地图按地区默认折叠,展示普通关卡、矿洞、难度、次数和工具库存。探险支持队员手选/自动与完成后自动领奖说明。
- 数据分析用真实 DTO 绘制 SVG 条形图,保留来源筛选、体力效率、样本和不确定性说明。没有样本时明确说明。
- 策略统一导入导出;收益 CSV/XLSX 导入与可用数据下载。错误展示具体原因,不把不支持的任务伪装成可执行任务。
- 帮助可检查 GitHub 正式版本并提交受控更新请求。未配置部署器时明确显示原因,更新提交不表示更新成功。
- 2.0.1 由用户手动触发在线更新,使用稳定 Release、对应正式镜像及完成私有认证的宿主机更新器;安装结果以宿主机健康检查为准。
## 安全与验证
+12 -8
View File
@@ -1,16 +1,16 @@
# Web 2.0.0 运行说明
# Web 2.0.1 运行说明
Web 正式版本 **2.0.0**,源码入口 `main`,游戏资料基线 **1.9.68**。桌面正式版保留 **1.2.0**,入口为 `python -m ranch_assistant`;Web 使用独立依赖与数据根。
本轮 Web 发布目标 **2.0.1**,源码入口 `main`,游戏资料基线 **1.9.68**。桌面正式版保留 **1.2.0**,入口为 `python -m ranch_assistant`;Web 使用独立依赖与数据根。
Web 采用 FastAPI / Uvicorn 和原生 HTML/CSS/ES 模块,无 Node、npm 或前端编译步骤,不安装 PySide6。页面和策略能力沿用现有核心,详细业务范围与原有限制见 [桌面使用说明](../ranch_assistant/README.md)。多浏览器连接同一个管理员工作台;一个服务实例内,各账号独立线程并行,同一账号操作串行。
## 迁移清单
- [x] 原15页:登录、培育室、背包、牧场、每日事务、自动孵蛋、自动主线、战斗记录、自动赠礼、自动委托、自动探险、自动扫荡、数据分析、执行计划、收益资料。
- [x] 保留账号页签、顶部数值与统一启停、可调日志;规则自动保存,配置与统计按账号/角色隔离,重启、恢复会话及导入策略后保持停止。
- [x] 保留账号页签、顶部数值与统一启停、可调日志;规则自动保存,配置与统计按账号/角色隔离,每次成功登录后自动执行已配置且已勾选的功能,可在顶部停止。
- [x] Windows Python 启动与离线演示;Web 导入链和依赖不使用 Qt,无 Node 构建步骤。
- [x] 提供 Linux Docker 与稳定 2.x 受控更新、停机备份及失败回滚脚本;已完成 Linux Docker 部署、持久化权限、健康检查和定时更新检查烟测。
- [x] 正式版本为 `2.0.0`,保留桌面兼容;战斗模拟为近似模型,特殊关卡并非全部支持,真实游戏 API 验收范围不因版本号变更而扩大。
- [x] 本轮发布目标为 `2.0.1`,保留桌面兼容;战斗模拟为近似模型,特殊关卡并非全部支持,真实游戏 API 验收范围不因版本号变更而扩大。
## Windows 本地运行
@@ -30,13 +30,13 @@ py -3 -m venv .venv-web
.\Start_Ranch_Web.cmd --demo --data-dir "$env:TEMP\ranch-web-demo-new" --no-browser
```
健康检查 `GET /api/health` 不访问游戏 API。关闭终端时使用 Ctrl+C,让应用正常关闭账号队列。重启、恢复会话或导入策略后仍需手动开启运行。
健康检查 `GET /api/health` 不访问游戏 API。关闭终端时使用 Ctrl+C,让应用正常关闭账号队列。手动选服、恢复会话及自动重登成功读取角色后,均默认开启策略,只执行已勾选的功能,子功能不会全选。顶部“停止”暂停策略,仍保留状态监控;可用“开启”继续。导入配置只替换规则并停止执行,下次成功登录仍会自动开启;服务重启后未成功登录时不直接执行。
### 后台运行与断线处理
关闭网页或退出 Web 管理登录不会停止服务器上的账号监控和已开启策略。账号监控和策略执行由服务端管理;“停止”策略后仍保留状态监控,退出游戏账号或停止服务后结束监控。
账号状态区分游戏在线、临时故障重试、游戏登录过期和未连接,显示最后成功通信时间及具体原因。临时网络故障采用退避后的只读状态检查;无法确认的操作保留核对记录,不自动重复提交。游戏会话失效后停止策略和游戏轮询,按自动重登录设置等待处理,或在登录页手动恢复;成功恢复后仍需手动开启策略。
账号状态区分游戏在线、临时故障重试、游戏登录过期和未连接,显示最后成功通信时间及具体原因。临时网络故障采用退避后的只读状态检查;无法确认的操作保留核对记录,不自动重复提交。游戏会话失效后停止策略和游戏轮询,按自动重登录设置等待处理,或在登录页手动恢复;成功登录后自动执行已配置且已勾选的功能,可在顶部停止。仅获取区服候选、候选角色验证失败或会话恢复失败,均不显示为登录成功。
服务重启会保留配置与加密会话;未启用自动重登录时,需要手动恢复会话。普通运行日志在各账号目录中限量持久保存,服务重启后仍可查看;调试请求详情仅在当前进程中按原有上限缓存。页面展示旧角色数据时会标注缓存状态,不把页面刷新视作游戏连接成功。
@@ -48,7 +48,7 @@ py -3 -m venv .venv-web
检测到掉线后,服务端按等待时长重新进行账号密码登录,回到原区服、原角色。登录页显示安排时间及执行结果,关闭浏览器不影响计时。临时网络故障的只读恢复检查继续运行,连接提前恢复后会取消重登录计划。重登录失败后按配置时长等待下一次尝试;缺少保存的密码或目标角色时会显示具体原因。
开启此功能且保留有效登录记录时,服务重启也会先等待所设时长,再尝试重登录。主动退出、清除登录记录或移除账号会取消自动计划。重登录成功恢复状态监控,策略执行保持停止;需要运行自动操作时,再点击顶部“开启”。
开启此功能且保留有效登录记录时,服务重启也会先等待所设时长,再尝试重登录;等待及失败阶段不执行策略。主动退出、清除登录记录或移除账号会取消自动计划。重登录成功读取原区服、原角色后,恢复状态监控并默认开启策略,自动执行已勾选功能,可点击顶部“停止”暂停。
## Linux Python 与环境变量
@@ -79,14 +79,18 @@ sh start-web.sh --no-browser
## Docker 与在线更新
完整步骤见 [Linux Docker 部署与受控更新](../deploy/web/README.md)。镜像使用 UID/GID 10001,持久化 `/data`,内置 `/api/health` healthcheck,正常退出宽限 120 秒,不挂载 Docker socket。
完整步骤及一次性私有更新器初始化见 [Linux Docker 部署与受控在线更新](../deploy/web/README.md)。镜像使用 UID/GID 10001,持久化 `/data`,内置 `/api/health` healthcheck,正常退出宽限 120 秒,不挂载 Docker socket。
已在 Ubuntu 24.04、Docker 29.8、Compose 5.5、Python 3.12 环境完成镜像构建和部署烟测:UID 10001 数据目录权限为 0700、密钥为 0600,应用根文件系统只读;健康检查及 FRP 转发返回 HTTP 200,Edge 管理登录后可访问 15 个功能页且无 JavaScript 错误,更新定时器已启用并成功完成首次 GitHub 检查。此部署烟测记录对应独立管理登录页调整前的版本;调整后的本地验证见下文,重新部署验收待完成,真实游戏 API 尚未验收。
Web 检查固定官方 GitHub Releases 的稳定 `v2.x.y`,跳过桌面 1.x、未来 3.x、草稿和预发布。开发版本 `2.0.0.dev1` 可升级至同数字的正式 `v2.0.0`;没有正式 Web 2 发布时明确显示暂无更新。Windows 默认仅检查;Web “更新”按钮仅在宿主机显式启用并有有效只读心跳时可提交 `pending` 请求,安装、备份和回滚由宿主机执行。默认定时检查只通知,自动安装需操作者 opt-in。
**2.0.1** 的在线更新由用户手动触发,使用稳定 Release、对应正式镜像,以及完成私有仓库认证、心跳有效的宿主机更新器。首次配置和操作步骤见[部署说明](../deploy/web/README.md),安装结果以宿主机健康检查为准。
## 离线验证
2.0.1 发布回归:后端及更新器 **297 项中 294 通过、3 项因 Windows 权限或软链接限制跳过**,浏览器 **43 项全部通过**。更新器专项命令增加 `ranch_web.tests.test_private_updates ranch_web.tests.test_web_updater_package`;Linux 镜像工作流也执行这两项模块,验证独立包、私有认证与容器健康。
自动重登录功能回归:后端及登录链路 **267 项中 266 通过、1 项因 Windows 符号链接权限跳过**,浏览器 **39 项全部通过**;另以禁止外部网络的合成账号完成 24 项独立审核。后端命令增加 `ranch_web.tests.test_auto_relogin ranch_assistant.tests.test_debug`,浏览器命令增加 `ranch_web.tests.browser.test_auto_relogin_browser.AutoReloginBrowserTests ranch_web.tests.browser.test_auto_relogin_browser.AutoReloginSchemaTests`。
2.0.0 发布整理本轮仅调整版本元数据,API 策略与行为未改;完整 Web 后端回归 **246 项:245 通过、1 项因 Windows 符号链接权限跳过、0 失败**。以下保留此前功能提交及开发阶段的验证记录。
+1 -1
View File
@@ -1,6 +1,6 @@
"""Headless Web workspace for the ranch assistant."""
__version__ = "2.0.0"
__version__ = "2.0.1"
GAME_VERSION = "1.9.68"
__all__ = ["__version__", "GAME_VERSION"]
+24 -10
View File
@@ -354,7 +354,7 @@ class AccountWorker:
elif self.demo:
message = "离线演示不执行自动重登"
elif self._auto_relogin_inflight:
state, message = "authenticating", "正在使用服务器保存的密码重新登录原区服、原角色;策略保持停止"
state, message = "authenticating", "正在使用服务器保存的密码重新登录原区服、原角色;激活成功后将尝试开启已勾选的策略"
elif not self.active_identity or self.schedule.disconnected_at is not None and not self._auto_relogin_target:
state, message = "blocked", "没有可确认的原区服和角色会话,请先手动登录并选择区服"
elif self.schedule.disconnected_at is not None:
@@ -459,8 +459,8 @@ class AccountWorker:
self._auto_relogin_blocked = False
self.schedule.game_resumed()
self.engine.heartbeat_enabled = True
if previous != "online":
self.log("游戏连接已确认;策略保持停止")
if previous != "online" and not activated:
self.log("游戏连接已确认;" + ("已勾选的策略继续运行" if self.running else "策略保持停止"))
def status(self):
with self.lock:
@@ -913,9 +913,8 @@ class AccountWorker:
self.check_intent()
if session_identity(client.session) != identity or int(snapshot.raw.get("master", {}).get("id") or 0) != target.role_id:
raise ValueError("进服后的角色与掉线前不匹配,已停止自动重登")
result = self._activate_client(client, snapshot)
result = self._activate_client(client, snapshot, login_message="自动重登成功,已恢复原区服和原角色")
client = None # The worker now owns this client.
self.log("自动重登成功,已恢复原区服和原角色的监控;策略保持停止")
return result
except Exception as error:
with self.lock:
@@ -1049,7 +1048,7 @@ class AccountWorker:
def _session_stamp(session):
return tuple(getattr(session, field) for field in Session.__dataclass_fields__)
def _activate_client(self, client, snapshot):
def _activate_client(self, client, snapshot, *, login_message="登录成功"):
self.check_intent()
session = client.session
role_id = int(snapshot.raw.get("master", {}).get("id") or 0)
@@ -1085,6 +1084,18 @@ class AccountWorker:
self.schedule.poll_finished(self.config)
self._game_succeeded(activated=True)
self._invalidate_views(clear=True)
# Activation and its new start authorization share the final
# generation check/lock. Never queue a start that could outlive
# a stop, logout or policy replacement during persistence.
try:
self._start({}, require_selection=False)
except ValueError as error:
message = login_message + ";策略保持停止:" + self.safe_text(str(error))
else:
message = login_message + ";策略已自动开启,仅执行已勾选的规则"
result = {"connected": True, "running": self._running,
"has_saved_password": self._has_saved_password, "message": message}
self.log(message)
except Exception:
with self.lock:
self.engine, self.active_identity, self.demo = old_engine, previous_identity, old_demo
@@ -1104,7 +1115,7 @@ class AccountWorker:
self.manager._release_identity(self, previous_identity)
if old_client is not None and old_client is not client:
old_client.close()
return {"connected": True, "running": False, "has_saved_password": self._has_saved_password}
return result
def _login(self, payload):
self.check_intent()
@@ -1234,7 +1245,7 @@ class AccountWorker:
self._invalidate_views()
return {"connected": False, "running": False, "has_saved_password": False}
def _start(self, payload):
def _start(self, payload, *, require_selection=True):
self.check_intent()
if not self.demo:
self._require_game()
@@ -1245,10 +1256,13 @@ class AccountWorker:
other = any(value[section]["enabled"] for section in ("quest_policy", "daily_policy", "sweep_policy", "explore_policy", "progression_policy"))
other = other or bool(policy["breakthrough_targets"]) or policy["gift_enabled"]
ranch = policy["enabled"] and any(policy[field] for field in ("buy", "fill", "dispatch", "collect", "feed"))
if not ranch and not other:
if require_selection and not ranch and not other:
raise ValueError("请先勾选至少一项功能,并启用对应策略")
if ranch and not other and not any(rule["enabled"] for rule in policy["egg_rules"].values()):
if require_selection and ranch and not other and not any(rule["enabled"] for rule in policy["egg_rules"].values()):
raise ValueError("请先在背包魔物蛋勾选要孵化的蛋,并设置优先级和孵出后的去向")
if (self.engine._progression_pending() or self.engine.explore_planner.pending(self.engine.snapshot)
or self.engine._breakthrough_pending):
raise ValueError("存在未确认的任务、战斗、探险或突破请求,禁止自动重发;请先核对")
with self.lock:
self.check_intent()
self._running = self.engine.auto = True
+12 -11
View File
@@ -9,9 +9,10 @@ const current = () => state.accounts.get(state.active);
const currentPage = () => { const account=current(); return account?.pages.get(account.page); };
const terminal = new Set(['succeeded','failed','cancelled']);
const jobLabels = {queued:'排队中',running:'执行中',succeeded:'已完成',failed:'失败',cancelled:'已取消'};
const operationLabels = {login:'登录',enter_server:'进入区服',restore_session:'恢复会话',refresh:'刷新 / 预览',start:'开启策略',stop:'停止策略',set_config:'保存配置',import_config:'导入策略',import_yields:'导入收益',claim_daily:'领取每日奖励',quote_expansion:'读取扩建费用',expand:'扩建',sell:'派遣',feed:'喂养',lock:'锁定',unlock:'解锁'};
const operationLabels = {login:'获取区服',enter_server:'进入区服',restore_session:'恢复会话',refresh:'刷新 / 预览',start:'开启策略',stop:'停止策略',set_config:'保存配置',import_config:'导入策略',import_yields:'导入收益',claim_daily:'领取每日奖励',quote_expansion:'读取扩建费用',expand:'扩建',sell:'派遣',feed:'喂养',lock:'锁定',unlock:'解锁'};
const connectionLabels = {online:'已登录',retrying:'正在重试',expired:'登录已过期',offline:'游戏离线'};
const gameRefreshOperations = new Set(['start','refresh','refresh_maps','refresh_tasks']);
const loginOperations = new Set(['enter_server','restore_session']);
function connectionState(summary) {
if(summary?.demo)return 'online';
@@ -121,7 +122,7 @@ function renderSummary() {
$('#refresh').disabled=!connected;$('#refresh').title=connected?'读取游戏状态并预览策略':details;
const task=account?[...account.jobs.values()].at(-1)?.job:null;
$('#job-status').textContent=task?`${operationLabels[task.operation] || task.operation} · ${jobLabels[task.status]}`:summary?.busy?'后台任务执行中':'';
const message=[details || summary?.error || (demo?'当前为离线演示,不连接游戏服务器。':connected?'角色状态自动刷新;配置功能后开启策略。':'请在登录页输入账号密码,或恢复已保存会话。'),...transportMessages(account)].filter(Boolean).join(';');
const message=[details || summary?.error || (demo?'当前为离线演示,不连接游戏服务器。':connected?summary.running?'角色状态自动刷新,正在自动执行已配置且已勾选的功能;可在顶部“停止”。':'角色状态自动刷新;策略已停止,可在顶部“开启”继续执行已勾选功能。':'请在登录页输入账号密码,或恢复已保存会话。'),...transportMessages(account)].filter(Boolean).join(';');
$('#data-summary').textContent=message;$('#data-summary').title=message;
account?.pages.forEach(renderPageConnection);renderStatus();
syncSaveStatus(account);
@@ -247,7 +248,7 @@ async function perform(account,operation,payload={},options={}) {
if(operation!=='stop')await flushConfig(account);
if(gameRefreshOperations.has(operation) && !gameAvailable(account))throw connectionError(account);
const job=await api.action(account.id,operation,payload);
setStatus(`${operationLabels[operation] || '操作'}:${gameRefreshOperations.has(operation)&&job.status==='succeeded'?'等待确认游戏状态':jobLabels[job.status] || '已提交'}`);
setStatus(`${operationLabels[operation] || '操作'}:${(gameRefreshOperations.has(operation)||loginOperations.has(operation))&&job.status==='succeeded'?'等待确认游戏状态':jobLabels[job.status] || '已提交'}`);
const result=await trackJob(account,job);
if(!state.accounts.has(account.id))return result;
if(result?.config){account.config=clone(result.config);account.revision=result.revision;}
@@ -255,12 +256,12 @@ async function perform(account,operation,payload={},options={}) {
try{account.summary=await api.status(account.id);account.transportErrors.delete('status');}
catch(failure){transportError(account,'status','Web 账号状态',failure);failure.connection=true;throw failure;}
renderAccountTabs();renderSummary();
if((gameRefreshOperations.has(operation)||['enter_server','restore_session'].includes(operation)) && !gameAvailable(account)){setStatus('工作台状态已更新');throw connectionError(account);}
if((gameRefreshOperations.has(operation)||loginOperations.has(operation)) && !gameAvailable(account)){setStatus('工作台状态已更新');throw connectionError(account);}
const page=options.page || account.pages.get(account.page);if(page)await loadPage(page,true);
if(operation==='login'&&result)account.pages.get('login')?.login?.update(result);
if(operation==='enter_server'||operation==='restore_session')notice('已读取角色。策略保持关闭,请配置功能后开启。');
else if(result?.message)notice(result.message);
setStatus(result?.message || `${operationLabels[operation] || '操作'}已完成`);
const message=loginOperations.has(operation)?account.summary.running?'已读取角色,已自动开启策略,执行已配置且已勾选的功能;可在顶部“停止”。':'已读取角色。策略已停止,可在顶部“开启”继续执行已勾选功能。':result?.message;
if(message)notice(message);
setStatus(message || `${operationLabels[operation] || '操作'}已完成`);
return result;
}
@@ -373,7 +374,7 @@ async function exportYields(account=current()) {
async function command(name,account=current()) {
try {
if(name==='add-account'||name==='add-demo')return await addAccount(name==='add-demo');
if(name==='about')return dialog('关于牧场助手',el('div',{},el('p',{text:`牧羊人之心牧场助手 Web ${state.meta?.version || '2.0.0'}`}),el('p',{text:`游戏数据版本 ${state.meta?.gameVersion || '1.9.68'}`}),el('p',{class:'info-note',text:'与桌面助手共用核心策略。配置在服务端自动保存;运行开关在重启和恢复会话后保持关闭。'})),{info:true});
if(name==='about')return dialog('关于牧场助手',el('div',{},el('p',{text:`牧羊人之心牧场助手 Web ${state.meta?.version || '2.0.1'}`}),el('p',{text:`游戏数据版本 ${state.meta?.gameVersion || '1.9.68'}`}),el('p',{class:'info-note',text:'与桌面助手共用核心策略。配置在服务端自动保存;每次成功登录后自动执行已勾选功能,可在顶部“停止”。服务重启后须先成功登录才执行。'})),{info:true});
if(name==='updates')return await showUpdates();
if(name==='admin-logout'){hideWorkbench();try{await api.logout();}finally{requireAuth();}return;}
if(!account)throw new Error('请先新增或选择账号。');
@@ -403,8 +404,8 @@ async function command(name,account=current()) {
if(name==='import-config'){
const file=await filePicker('.json');if(!file)return;if(file.size>1024*1024)throw new Error('策略文件过大。');
let config;try{config=JSON.parse(await file.text());}catch{throw new Error('策略文件不是有效的 JSON。');}
if(!await confirm('导入当前账号策略','将替换当前账号策略,策略运行保持关闭。',{confirm:'导入策略'}))return;
await flushConfig(account);const result=await trackJob(account,await api.importConfig(account.id,config));await refreshConfig(account);notice('策略已导入,运行保持关闭。');await loadPage(getPage(account,account.page),true);return result;
if(!await confirm('导入当前账号策略','将替换当前账号策略并停止执行;下次成功登录会自动执行已勾选功能。',{confirm:'导入策略'}))return;
await flushConfig(account);const result=await trackJob(account,await api.importConfig(account.id,config));await refreshConfig(account);notice('策略已导入,执行已停止;下次成功登录会自动执行已勾选功能。');await loadPage(getPage(account,account.page),true);return result;
}
if(name==='import-yields')return await importYields(account);
if(name==='export-yields')return await exportYields(account);
@@ -576,7 +577,7 @@ async function bootstrap() {
$('#app').hidden=false;
const [meta,schema]=await Promise.all([api.meta(),api.schema()]);state.meta=meta;state.schema=schema;
if(state.redirecting)return;
$('#app-version').textContent=meta.version || '2.0.0';$('#game-version').textContent=meta.gameVersion || '1.9.68';$('#access-mode').textContent=auth.access_mode==='local'||auth.access_mode==='loopback'?'本机工作台':auth.required?'管理工作台':'本机工作台';
$('#app-version').textContent=meta.version || '2.0.1';$('#game-version').textContent=meta.gameVersion || '1.9.68';$('#access-mode').textContent=auth.access_mode==='local'||auth.access_mode==='loopback'?'本机工作台':auth.required?'管理工作台':'本机工作台';
await syncAccounts();if(state.redirecting)return;state.ready=true;setStatus('工作台已连接');
}catch(failure){if(failure.status===401||$('#app').hidden){requireAuth();return;}if(state.redirecting)return;setStatus(failure.message);$('#page-host').replaceChildren(el('div',{class:'initial-state'},el('p',{text:failure.message}),el('button',{text:'重新连接',onClick:bootstrap})));}
}
+1 -1
View File
@@ -26,7 +26,7 @@
</div></details>
<details class="menu"><summary accesskey="h">帮助<span class="access-key">(H)</span></summary><div class="menu-popup"><button data-command="updates">检查版本更新…</button><button data-command="debug">调试日志</button><button data-command="about">关于…</button></div></details>
</nav>
<span class="window-title">牧羊人之心牧场助手 <span id="app-version">2.0.0</span></span>
<span class="window-title">牧羊人之心牧场助手 <span id="app-version">2.0.1</span></span>
<span id="access-mode" class="muted">正在连接本地服务</span>
</header>
<div class="account-bar"><div id="account-tabs" class="account-tabs" role="tablist" aria-label="账号"></div><button id="add-account" class="compact" title="新增账号">+ 新增账号</button></div>
+2 -2
View File
@@ -48,11 +48,11 @@ class LoginPage {
this.restore = el('button', {type: 'button', text: '恢复选中会话(无需重新输密码)', disabled: true, onClick: () => page.perform('restore_session', {session_id: this.saved.value}).catch(page.error)});
this.root.append(form,
field('第二步:区服 / 角色', el('div', {class: 'server-row'}, this.servers, this.enter)),
el('p', {class: 'info-note', text: '账号验证 → 获取官方区服 → 选择区服 → 进入区服 → 读取角色。登录后自动刷新状态,配置功能后开启顶部策略。'}),
el('p', {class: 'info-note', text: '账号验证 → 获取官方区服 → 选择区服 → 进入区服 → 读取角色。成功登录后自动刷新状态并执行已配置且已勾选的功能,可在顶部“停止”。'}),
el('div', {class: 'session-block policy-form'}, field('已保存账号 / 区服 / 角色', this.saved), el('div', {class: 'login-actions'}, this.restore)),
el('div', {class: 'page-toolbar'}, el('button', {type: 'button', text: '退出登录', onClick: () => page.perform('logout').catch(page.error)}),
el('button', {type: 'button', text: '退出并清除登录记录…', onClick: () => page.options.command('forget-login', page.account)})),
el('p', {class: 'info-note', text: '记住的账号密码和登录会话由服务端加密保存。浏览器不会保存游戏凭据。退出或恢复会话后,策略保持关闭。'}));
el('p', {class: 'info-note', text: '记住的账号密码和登录会话由服务端加密保存。浏览器不会保存游戏凭据。手动选服、恢复会话和自动重登成功后,均自动执行已勾选功能;退出登录后停止执行。'}));
host.append(this.autoReloginStatus, this.root);
}
@@ -14,7 +14,7 @@ from unittest.mock import patch
from urllib.parse import urlsplit
from ranch_assistant.model import Catalog
from ranch_web.policies import default_config
from ranch_web.policies import default_config, export_config
from ranch_web.views import build_view, schema
from . import test_workbench_browser as fixtures
@@ -68,6 +68,7 @@ class AutoReloginBrowserTests(unittest.TestCase):
fixtures.WorkbenchBrowserTests.setUp(self)
self.context.set_default_timeout(5000)
self.external_requests, self.unexpected_actions, self.writes, self.actions = [], [], [], []
self.action_handlers = {}
self.view_calls = 0
self.configs, self.summaries, self.login_data = {}, {}, {}
engine = SimpleNamespace(catalog=Catalog(), snapshot=None, demo=False)
@@ -112,6 +113,10 @@ class AutoReloginBrowserTests(unittest.TestCase):
if path.startswith(prefix + "/actions/"):
operation = path.rsplit("/", 1)[-1]
self.actions.append((identifier, operation, request.post_data_json))
handler = self.action_handlers.get((identifier, operation))
if handler:
self.fulfill(route, handler(request.post_data_json))
return
if operation != "logout":
self.unexpected_actions.append(operation)
route.abort()
@@ -132,7 +137,7 @@ class AutoReloginBrowserTests(unittest.TestCase):
def tearDown(self):
try:
self.assertEqual(self.external_requests, [])
self.assertEqual(self.unexpected_actions, [], "UI must never initiate game login or start strategies")
self.assertEqual(self.unexpected_actions, [], "UI must only submit explicitly requested fixture actions")
self.assertEqual(self.errors, [])
finally:
fixtures.WorkbenchBrowserTests.tearDown(self)
@@ -155,6 +160,11 @@ class AutoReloginBrowserTests(unittest.TestCase):
self.page.wait_for_function("() => document.querySelector('#save-status').textContent === '策略已自动保存'")
self.assertEqual(self.configs[identifier]["auto_relogin"], {"enabled": enabled, "delay_minutes": minutes})
def complete_login(self, operation, *, running=True):
self.summaries[self.first].update(connected=True, connection_state="online",
connection_message="游戏连接正常", error="", running=running)
return {"id": "mock-" + operation, "operation": operation, "status": "succeeded", "result": {}}
def test_defaults_visible_explanations_and_existing_layout(self):
self.open()
panel = self.go("login")
@@ -164,7 +174,7 @@ class AutoReloginBrowserTests(unittest.TestCase):
expect(delay).to_have_value("30")
for attribute, value in (("min", "1"), ("max", "10080"), ("step", "1")):
expect(delay).to_have_attribute(attribute, value)
for text in ("服务端", "记住账号和密码", "原区服", "角色", "恢复监控", "策略保持停止", "关闭页面", "服务重启"):
for text in ("服务端", "记住账号和密码", "原区服", "角色", "恢复监控", "自动执行已勾选功能", "顶部“停止”", "关闭页面", "服务重启"):
expect(panel).to_contain_text(text)
self.assertTrue(enabled.evaluate("node => Boolean(node.closest('.policy-form'))"))
self.assertTrue(enabled.evaluate("node => Boolean(node.compareDocumentPosition(document.querySelector('.login-layout')) & Node.DOCUMENT_POSITION_FOLLOWING)"))
@@ -176,6 +186,131 @@ class AutoReloginBrowserTests(unittest.TestCase):
self.assertEqual(self.writes, [])
self.assertEqual(self.actions, [])
def test_server_candidates_wait_for_role_then_run_only_selected_features_and_allow_stop(self):
self.configs[self.first]["daily_policy"].update(enabled=True, selected=["gift"])
original = copy.deepcopy(self.configs[self.first])
candidates = {"servers": [{"id": 7, "name": "离线测试区", "role_name": "离线角色"}]}
def login(payload):
self.login_data[self.first].update(candidates)
return {"id": "mock-login", "operation": "login", "status": "succeeded", "result": candidates}
def stop(payload):
self.summaries[self.first]["running"] = False
return {"id": "mock-stop", "operation": "stop", "status": "succeeded", "result": {"message": "策略已停止"}}
self.action_handlers.update({(self.first, "login"): login,
(self.first, "enter_server"): lambda payload: self.complete_login("enter_server"),
(self.first, "stop"): stop})
self.open()
panel = self.go("login")
panel.get_by_label("游戏账号", exact=True).fill("offline-role-test")
panel.get_by_label("游戏密码", exact=True).fill("synthetic-password")
panel.get_by_role("button", name="账号密码登录 / 获取区服", exact=True).click()
expect(panel.get_by_label("区服 / 角色", exact=True)).to_contain_text("离线测试区")
expect(self.page.locator("#connection")).to_have_text("游戏离线")
toggle = self.page.locator("#strategy-toggle")
expect(toggle).to_have_text("开启")
expect(toggle).to_be_disabled()
expect(self.page.locator("#notice")).to_be_hidden()
self.assertFalse(self.summaries[self.first]["running"])
panel.get_by_role("button", name="进入选中区服", exact=True).click()
expect(toggle).to_have_text("停止")
expect(toggle).to_have_attribute("aria-pressed", "true")
expect(self.page.locator("#notice")).to_contain_text("已自动开启策略")
expect(self.page.locator("#status-text")).to_contain_text("已配置且已勾选的功能")
expect(self.page.locator("#data-summary")).to_contain_text("顶部“停止”")
expect(self.page.locator("#page-tabs [role=tab]")).to_have_count(15)
self.assertEqual(self.configs[self.first], original, "Logging in must preserve every feature selection")
toggle.click()
expect(toggle).to_have_text("开启")
expect(self.page.locator("#data-summary")).to_contain_text("策略已停止")
self.assertEqual([operation for _, operation, _ in self.actions], ["login", "enter_server", "stop"])
self.assertEqual(self.actions[1][2], {"server_id": "7"})
self.assertEqual(self.configs[self.first], original)
self.assertEqual(self.writes, [])
def test_import_stays_stopped_and_next_restored_session_runs_imported_selection(self):
imported = copy.deepcopy(default_config())
imported["daily_policy"].update(enabled=True, selected=["gift"])
portable = export_config(imported)
imports = []
self.login_data[self.first]["saved_sessions"] = [{"id": "offline-session", "label": "离线区服 / 原角色"}]
self.action_handlers[(self.first, "restore_session")] = lambda payload: self.complete_login("restore_session")
def import_config(route):
imports.append(route.request.post_data_json)
self.configs[self.first] = copy.deepcopy(imported)
self.summaries[self.first]["running"] = False
self.summaries[self.first]["revision"] += 1
self.fulfill(route, {"id": "mock-import", "operation": "import_config", "status": "succeeded", "result": {}})
self.page.route(f"**/api/accounts/{self.first}/config/import", import_config)
self.open()
panel = self.go("login")
self.page.locator('.menu > summary').nth(2).click()
with self.page.expect_file_chooser() as chooser:
self.page.locator('[data-command="import-config"]').click()
chooser.value.set_files({"name": "offline-policy.json", "mimeType": "application/json",
"buffer": json.dumps(portable).encode("utf-8")})
expect(self.page.locator("#dialog-content")).to_contain_text("下次成功登录会自动执行已勾选功能")
self.page.locator("#dialog-confirm").click()
expect(self.page.locator("#notice")).to_contain_text("策略已导入,执行已停止")
expect(self.page.locator("#strategy-toggle")).to_be_disabled()
self.assertEqual(imports, [portable])
self.assertEqual(self.actions, [])
panel.get_by_role("button", name="恢复选中会话(无需重新输密码)", exact=True).click()
expect(self.page.locator("#strategy-toggle")).to_have_text("停止")
expect(self.page.locator("#notice")).to_contain_text("已自动开启策略")
self.assertEqual(self.actions, [(self.first, "restore_session", {"session_id": "offline-session"})])
self.assertEqual(self.configs[self.first], imported, "Restoring must preserve imported selections")
self.assertEqual(self.writes, [])
def test_failed_candidates_and_disconnected_success_jobs_never_report_login_success(self):
self.login_data[self.first].update(servers=[{"id": 7, "name": "候选区服"}],
saved_sessions=[{"id": "offline-session", "label": "候选角色"}])
for operation, label in (("enter_server", "进入选中区服"), ("restore_session", "恢复选中会话(无需重新输密码)")):
for job_status in ("failed", "succeeded"):
with self.subTest(operation=operation, job_status=job_status):
self.action_handlers[(self.first, operation)] = lambda payload, op=operation, status=job_status: {
"id": "mock-candidate", "operation": op, "status": status,
"error": "候选角色验证失败", "result": {"message": "候选声称登录成功"}}
self.open()
panel = self.go("login")
self.page.evaluate("""() => {
window.loginFeedback = [];
new MutationObserver(() => {
for (const id of ['status-text', 'notice']) {
const node = document.getElementById(id);
if (node && !node.hidden) window.loginFeedback.push(node.textContent);
}
}).observe(document.body, {subtree:true, childList:true, characterData:true,
attributes:true, attributeFilter:['hidden']});
}""")
panel.get_by_role("button", name=label, exact=True).click()
expect(self.page.locator("#notice.error")).to_be_visible()
expect(self.page.locator("#notice")).to_contain_text("候选角色验证失败" if job_status == "failed" else "尚未连接游戏")
expect(self.page.locator("#connection")).to_have_text("游戏离线")
expect(self.page.locator("#strategy-toggle")).to_be_disabled()
feedback = "\n".join(self.page.evaluate("window.loginFeedback"))
for false_success in ("已完成", "已读取角色", "已自动开启策略", "候选声称登录成功"):
self.assertNotIn(false_success, feedback)
self.assertNotIn("start", [operation for _, operation, _ in self.actions])
self.assertEqual(self.writes, [])
def test_stop_after_restore_is_shown_from_confirmed_server_status(self):
self.login_data[self.first]["saved_sessions"] = [{"id": "offline-session", "label": "离线角色"}]
self.action_handlers[(self.first, "restore_session")] = lambda payload: self.complete_login("restore_session", running=False)
self.open()
panel = self.go("login")
panel.get_by_role("button", name="恢复选中会话(无需重新输密码)", exact=True).click()
expect(self.page.locator("#connection")).to_have_text("已登录")
expect(self.page.locator("#notice")).to_contain_text("策略已停止")
expect(self.page.locator("#notice")).not_to_contain_text("已自动开启")
expect(self.page.locator("#data-summary")).to_contain_text("策略已停止")
expect(self.page.locator("#strategy-toggle")).to_have_text("开启")
self.assertEqual(self.actions, [(self.first, "restore_session", {"session_id": "offline-session"})])
def test_native_autosave_range_validation_refresh_and_focus(self):
self.open()
panel = self.go("login")
@@ -286,10 +421,14 @@ class AutoReloginBrowserTests(unittest.TestCase):
self.set_status(self.first, "failed", reason)
expect(status).to_contain_text(reason)
expect(status.locator("img")).to_have_count(0)
self.set_status(self.first, "monitoring", "重登成功,已恢复监控,策略保持停止")
self.summaries[self.first].update(connected=True, connection_state="online", connection_message="游戏连接正常", running=False)
expect(status).to_contain_text("已恢复监控,策略保持停止")
expect(self.page.locator("#strategy-toggle")).to_have_text("开启")
expect(self.page.locator("#strategy-toggle")).to_be_disabled()
original = copy.deepcopy(self.configs[self.first])
self.set_status(self.first, "monitoring", "重登成功,已恢复监控并自动执行已勾选功能,可在顶部停止")
self.summaries[self.first].update(connected=True, connection_state="online", connection_message="游戏连接正常", running=True)
expect(status).to_contain_text("已恢复监控并自动执行已勾选功能")
expect(self.page.locator("#strategy-toggle")).to_have_text("停止")
expect(self.page.locator("#data-summary")).to_contain_text("正在自动执行已配置且已勾选的功能")
self.assertEqual(self.configs[self.first], original)
self.assertEqual(self.actions, [])
def test_restart_wait_persists_across_reload_and_closing_page_has_no_actions(self):
@@ -297,12 +436,15 @@ class AutoReloginBrowserTests(unittest.TestCase):
self.open()
panel = self.go("login")
expect(panel.locator("[data-auto-relogin-status]")).to_contain_text("服务重启")
expect(self.page.locator("#strategy-toggle")).to_be_disabled()
before = len(self.writes)
self.page.reload(wait_until="networkidle")
panel = self.go("login")
expect(self.controls(panel)[0]).to_be_checked()
expect(self.controls(panel)[1]).to_have_value("30")
expect(panel.locator("[data-auto-relogin-countdown]")).to_contain_text("秒后自动重新登录")
expect(self.page.locator("#strategy-toggle")).to_have_text("开启")
expect(self.page.locator("#strategy-toggle")).to_be_disabled()
self.page.goto("about:blank")
self.page.close()
self.assertEqual(len(self.writes), before)
@@ -283,6 +283,8 @@ class WorkbenchBrowserTests(unittest.TestCase):
def test_fake_login_uses_servers_without_persisting_password(self):
payloads = []
summary = copy.deepcopy(self.manager.status(self.first))
summary.update(demo=False, connected=False, running=False, connection_state="offline", connection_message="尚未连接游戏")
login_result = {"servers": [{"id": 7, "name": "测试区", "role_name": "测试角色"}], "has_saved_password": True}
def route_login(route):
payloads.append(route.request.post_data_json)
@@ -294,12 +296,16 @@ class WorkbenchBrowserTests(unittest.TestCase):
self.fulfill(route, response)
self.page.route(f"**/api/accounts/{self.first}/actions/login", route_login)
self.page.route(f"**/api/accounts/{self.first}/views/login?*", route_login_view)
self.page.route("**/api/accounts", lambda route: self.fulfill(route, [summary, self.manager.status(self.second)]))
self.page.route(f"**/api/accounts/{self.first}/status", lambda route: self.fulfill(route, summary))
self.open()
panel = self.go("login")
panel.get_by_label("游戏账号", exact=True).fill("offline-test")
panel.get_by_label("游戏密码", exact=True).fill("test-password-never-persist")
panel.get_by_role("button", name="账号密码登录 / 获取区服", exact=True).click()
expect(panel.get_by_label('区服 / 角色',exact=True)).to_contain_text('测试区')
expect(self.page.locator('#connection')).to_have_text('游戏离线')
expect(self.page.locator('#strategy-toggle')).to_be_disabled()
self.assertEqual(payloads[0], {"account": "offline-test", "password": "test-password-never-persist", "remember": True})
self.assertEqual(panel.get_by_label("游戏密码", exact=True).input_value(), "")
self.assertEqual(self.page.evaluate("Object.keys(localStorage).length + Object.keys(sessionStorage).length"), 0)
+92 -2
View File
@@ -32,6 +32,7 @@ class AutoReloginTests(unittest.TestCase):
idle = fixtures.ServiceTests.idle
job = fixtures.ServiceTests.job
login = fixtures.ServiceTests.login
enable = fixtures.ServiceTests.enable
def connected(self, *, remember=True, server=2, account=None):
self.manager.login_factory = AutoLogin
@@ -79,6 +80,8 @@ class AutoReloginTests(unittest.TestCase):
def test_first_expiry_deadline_survives_idle_refresh_and_duplicate_ticks(self):
identifier, worker = self.connected()
self.enable(identifier)
selected = deepcopy(worker.config)
identity = worker.active_identity
self.disconnect(identifier, worker)
status = self.auto_status(identifier)
@@ -92,13 +95,17 @@ class AutoReloginTests(unittest.TestCase):
self.assertEqual(self.auto_status(identifier)["next_attempt_at"], status["next_attempt_at"])
self.assertEqual(len(AutoLogin.calls), before)
self.now += 1
self.tick(identifier, worker)
result = self.tick(identifier, worker)["result"]
self.assertEqual(len(AutoLogin.calls), before + 1)
self.assertEqual(worker.active_identity, identity)
self.assertEqual(worker.engine.client.session.server_id, 2)
self.assertEqual(worker.engine.client.session.role_id, 102)
self.assertTrue(self.manager.status(identifier)["connected"])
self.assertFalse(self.manager.status(identifier)["running"])
self.assertTrue(self.manager.status(identifier)["running"])
self.assertTrue(worker.engine.auto)
self.assertTrue(result["running"])
self.assertIn("已勾选", result["message"])
self.assertEqual(worker.config, selected)
self.assertTrue(worker.schedule.monitoring)
self.assertIsNone(self.auto_status(identifier)["next_attempt_at"])
for _ in range(3):
@@ -201,6 +208,8 @@ class AutoReloginTests(unittest.TestCase):
with patch.object(AutoLogin, "authenticate", wrong):
self.tick(identifier, worker)
self.assertFalse(self.manager.status(identifier)["connected"])
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
self.assertFalse(any(url.endswith("userServerService/enterGame")
for _, url, _ in fixtures.FakeClient.calls[before:]))
self.assertEqual(self.auto_status(identifier)["state"], "failed")
@@ -239,6 +248,8 @@ class AutoReloginTests(unittest.TestCase):
def test_portable_import_preserves_local_login_preference(self):
identifier, worker = self.connected()
self.enable(identifier)
self.job(identifier, self.manager.submit(identifier, "start"))
portable = export_config(default_config(), worker.engine.snapshot)
self.job(identifier, self.manager.submit(identifier, "import_config", {"config": portable}))
self.assertEqual(self.manager.get_config(identifier)["config"]["auto_relogin"],
@@ -246,6 +257,85 @@ class AutoReloginTests(unittest.TestCase):
public = json.dumps(self.manager.get_config(identifier)) + json.dumps(export_config(worker.config))
self.assertNotIn("synthetic-password", public)
self.assertNotIn("synthetic-center-token", public)
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
def test_restart_opt_in_activates_after_thirty_minutes_and_supersedes_old_stop(self):
identifier, worker = self.connected()
self.enable(identifier)
self.configure(identifier, delay=30)
self.manager.submit(identifier, "stop")
selected = deepcopy(worker.config)
self.manager.close()
before = len(AutoLogin.calls), len(fixtures.FakeClient.calls)
self.manager = WebManager(self.root, start_scheduler=False, login_factory=AutoLogin)
self.addCleanup(self.manager.close)
self.idle(identifier)
worker = self.manager._worker(identifier)
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
self.assertIsNone(worker.engine.client)
self.assertEqual((len(AutoLogin.calls), len(fixtures.FakeClient.calls)), before)
origin = worker.schedule.disconnected_at
worker.schedule.clock = lambda: self.now
self.now = origin + 1799
self.tick(identifier, worker)
self.assertFalse(worker.running)
self.assertEqual(len(AutoLogin.calls), before[0])
self.now = origin + 1800
result = self.tick(identifier, worker)["result"]
self.assertTrue(result["connected"])
self.assertTrue(result["running"])
self.assertTrue(worker.running)
self.assertTrue(worker.engine.auto)
self.assertEqual(worker.config, selected)
self.assertEqual(len(AutoLogin.calls), before[0] + 1)
def test_final_activation_revocation_never_starts_relogin_candidate(self):
for operation in ("stop", "logout", "forget_login", "policy", "disable", "delay"):
with self.subTest(operation=operation):
identifier, worker = self.connected()
self.enable(identifier)
self.disconnect(identifier, worker)
original_client = worker.engine.client
identity = worker.active_identity
entered, release = threading.Event(), threading.Event()
self.addCleanup(release.set)
original = worker.securestore.set_active
def held(active):
if active == identity and not release.is_set():
entered.set()
if not release.wait(5):
raise AssertionError("Relogin activation gate not released")
return original(active)
self.now += 60
before = self.manager.logs(identifier)["next"]
with patch.object(worker.securestore, "set_active", side_effect=held):
candidate = worker.enqueue("__tick")
self.assertTrue(entered.wait(2))
if operation in {"stop", "logout", "forget_login"}:
followup = self.manager.submit(identifier, operation)
else:
config = self.manager.get_config(identifier)["config"]
if operation == "policy":
config["daily_policy"]["enabled"] = False
else:
config["auto_relogin"].update(enabled=operation != "disable", delay_minutes=2)
followup = self.manager.set_config(identifier, config)["job"]
self.assertFalse(worker.running)
release.set()
self.job(identifier, candidate, status="cancelled")
self.job(identifier, followup)
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
if operation in {"logout", "forget_login"}:
self.assertIsNone(worker.engine.client)
else:
self.assertIs(worker.engine.client, original_client)
self.assertFalse(any("已自动开启" in row["message"]
for row in self.manager.logs(identifier, after=before)["entries"]))
def test_restart_opt_in_waits_and_logout_disarms_restart(self):
identifier, worker = self.connected()
+22 -1
View File
@@ -31,6 +31,8 @@ class ConnectionStateTests(unittest.TestCase):
if running:
self.enable(identifier)
self.job(identifier, self.manager.submit(identifier, "start"))
else:
self.manager.submit(identifier, "stop")
return identifier, worker
def tick(self, identifier, worker, *, status="succeeded"):
@@ -70,7 +72,26 @@ class ConnectionStateTests(unittest.TestCase):
self.assertIsNotNone(worker.securestore.load(worker.active_identity))
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": worker.active_identity}))
self.assertEqual(self.manager.status(identifier)["connection_state"], "online")
self.assertFalse(self.manager.status(identifier)["running"])
self.assertTrue(self.manager.status(identifier)["running"])
self.assertTrue(worker.engine.auto)
def test_explicit_stop_survives_heartbeat_local_refresh_and_monitor_until_login(self):
identifier, worker = self.connected(running=True)
self.manager.submit(identifier, "stop")
worker.engine.last_heartbeat = 0
result = self.tick(identifier, worker)["result"]
self.assertEqual(result["kind"], "heartbeat")
self.job(identifier, self.manager.submit(identifier, "refresh", {"page": "statistics"}))
self.job(identifier, self.manager.submit(identifier, "refresh"))
worker.schedule.next_poll = 0
self.tick(identifier, worker)
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
self.assertTrue(self.manager.status(identifier)["connected"])
result = self.job(identifier, self.manager.submit(identifier, "restore_session", {
"session_id": worker.active_identity}))["result"]
self.assertTrue(result["running"])
self.assertTrue(worker.engine.auto)
def test_timeout_retries_only_snapshot_and_keeps_uncertain_write_evidence(self):
identifier, worker = self.connected(running=True)
+195
View File
@@ -0,0 +1,195 @@
"""Private release transport checks using fake HTTP only, never user credentials."""
from contextlib import contextmanager
from email.message import Message
import io
import json
import os
from pathlib import Path
import tempfile
import traceback
import unittest
from unittest.mock import patch
from urllib.error import HTTPError, URLError
from urllib.request import HTTPSHandler, build_opener
from urllib.response import addinfourl
from ranch_web import updates
TOKEN = "github_pat_offline_test_secret"
RELEASES = [{"tag_name": "v2.0.1", "draft": False, "prerelease": False}]
class PrivateReleaseTests(unittest.TestCase):
def setUp(self):
temporary = tempfile.TemporaryDirectory(prefix="private-release-test-")
self.addCleanup(temporary.cleanup)
self.root = Path(temporary.name)
self.token_path = self.root / updates.TOKEN_FILE_NAME
environment = patch.dict(os.environ, {"RANCH_WEB_UPDATER_DIR": ""})
environment.start()
self.addCleanup(environment.stop)
os.environ.pop(updates.TOKEN_FILE_ENV, None)
network = patch("socket.socket.connect", side_effect=AssertionError("Live network forbidden"))
network.start()
self.addCleanup(network.stop)
def token(self, payload=None):
self.token_path.write_bytes(payload if payload is not None else (TOKEN + "\n").encode("ascii"))
self.token_path.chmod(0o600)
@contextmanager
def transport(self, body=None):
payload = body if body is not None else json.dumps(RELEASES).encode("ascii")
with patch.object(updates, "build_opener") as build:
build.return_value.open.side_effect = lambda *args, **kwargs: io.BytesIO(payload)
yield build
def test_missing_default_retains_public_and_no_argument_api(self):
with self.transport() as build:
self.assertEqual(updates.github_releases(), RELEASES)
self.assertEqual(updates.github_releases(self.root), RELEASES)
for call in build.return_value.open.call_args_list:
self.assertIsNone(call.args[0].get_header("Authorization"))
def test_shared_file_adds_auth_only_to_fixed_github_endpoint(self):
self.token()
with self.transport() as build:
self.assertEqual(updates.github_releases(self.root), RELEASES)
request = build.return_value.open.call_args.args[0]
self.assertEqual(request.full_url, updates.RELEASES_API + "?per_page=100&page=1")
self.assertEqual(request.get_header("Authorization"), "Bearer " + TOKEN)
self.assertIsInstance(build.call_args.args[0], updates._NoRedirect)
def test_absolute_override_is_a_file_and_takes_precedence(self):
self.token(b"ignored_default\n")
alternate = self.root / "alternate-token"
alternate.write_text(TOKEN, encoding="ascii")
alternate.chmod(0o600)
os.environ[updates.TOKEN_FILE_ENV] = str(alternate)
with self.transport() as build:
updates.github_releases(self.root)
self.assertEqual(build.return_value.open.call_args.args[0].get_header("Authorization"), "Bearer " + TOKEN)
def test_invalid_explicit_file_never_falls_back_or_exposes_path(self):
for value in ("", TOKEN, str(self.root / "missing-private-token")):
with self.subTest(value=value), self.transport() as build:
os.environ[updates.TOKEN_FILE_ENV] = value
with self.assertRaises(updates.GitHubReleaseError) as caught:
updates.github_releases(self.root)
self.assertEqual(caught.exception.code, "token_file_invalid")
self.assertNotIn(TOKEN, str(caught.exception))
self.assertNotIn(str(self.root), str(caught.exception))
build.assert_not_called()
def test_malformed_empty_large_and_header_injection_tokens_rejected(self):
for payload in (b"", b"bad token", b"token\r\nInjected: secret", b"\xff", b"a" * 4097):
with self.subTest(payload=payload[:20]), self.transport() as build:
self.token(payload)
with self.assertRaises(updates.GitHubReleaseError):
updates.github_releases(self.root)
build.assert_not_called()
def test_hard_link_token_rejected(self):
self.token()
os.link(self.token_path, self.root / "token-hardlink")
with self.transport() as build, self.assertRaises(updates.GitHubReleaseError):
updates.github_releases(self.root)
build.assert_not_called()
def test_symlink_even_to_missing_file_rejected(self):
try:
self.token_path.symlink_to(self.root / "missing-target")
except OSError:
self.skipTest("Symlinks unavailable for this test user")
with self.transport() as build, self.assertRaises(updates.GitHubReleaseError):
updates.github_releases(self.root)
build.assert_not_called()
@unittest.skipUnless(os.name == "posix", "POSIX permission check")
def test_readable_by_group_or_others_is_not_accepted(self):
self.token()
for mode in (0o644, 0o640, 0o400, 0o660):
self.token_path.chmod(mode)
with self.subTest(mode=mode), self.transport() as build, self.assertRaises(updates.GitHubReleaseError):
updates.github_releases(self.root)
build.assert_not_called()
def test_file_permission_errors_are_fixed_and_secret_free(self):
with patch.object(updates.os, "open", side_effect=PermissionError(TOKEN)), self.transport() as build:
with self.assertRaises(updates.GitHubReleaseError) as caught:
updates.github_releases(self.root)
self.assertNotIn(TOKEN, str(caught.exception))
build.assert_not_called()
def test_http_access_errors_with_and_without_token_are_not_no_release(self):
service = updates.UpdateService(self.root, "2.0.0")
for authenticated in (False, True):
if authenticated:
self.token()
for status in (401, 403, 404):
with self.subTest(authenticated=authenticated, status=status), self.transport() as build:
build.return_value.open.side_effect = HTTPError(updates.RELEASES_API, status, TOKEN, {}, io.BytesIO(TOKEN.encode()))
state = service.check()
self.assertEqual(state["status"], "check_failed")
self.assertIn("权限", state["message"])
self.assertFalse(state["available"])
self.assertFalse(state["can_apply"])
self.assertIsNone(state["latest_version"])
self.assertNotIn(TOKEN, json.dumps(state))
self.assertNotIn(TOKEN, (self.root / "update-check.json").read_text(encoding="utf-8"))
def test_untrusted_response_and_network_exception_are_sanitized(self):
self.token()
for body in (TOKEN.encode(), json.dumps({"error": TOKEN}).encode()):
with self.subTest(body=body), self.transport(body):
with self.assertRaises(updates.GitHubReleaseError) as caught:
updates.github_releases(self.root)
self.assertNotIn(TOKEN, "".join(traceback.format_exception(caught.exception)))
with self.transport() as build:
build.return_value.open.side_effect = URLError(TOKEN)
with self.assertRaises(updates.GitHubReleaseError) as caught:
updates.github_releases(self.root)
self.assertNotIn(TOKEN, "".join(traceback.format_exception(caught.exception)))
def test_redirect_responses_never_issue_a_second_request(self):
self.token()
requests = []
class RedirectTransport(HTTPSHandler):
def https_open(self, request):
requests.append(request)
headers = Message()
headers["Location"] = destination
response = addinfourl(io.BytesIO(b""), headers, request.full_url, status)
response.msg = "redirect"
return response
for destination in ("https://evil.invalid/" + TOKEN, updates.RELEASES_API + "/redirect"):
for status in (301, 302, 303, 307, 308):
requests.clear()
opener = build_opener(updates._NoRedirect(), RedirectTransport())
with self.subTest(destination=destination, status=status), patch.object(updates, "build_opener", return_value=opener):
with self.assertRaises(updates.GitHubReleaseError) as caught:
updates.github_releases(self.root)
self.assertEqual(len(requests), 1)
self.assertNotIn(TOKEN, str(caught.exception))
def test_untrusted_endpoint_is_rejected_before_loading_credentials(self):
for endpoint in ("https://evil.invalid/releases", "http://api.github.com/repos/attilanet/myrzx_bot/releases",
updates.RELEASES_API + "?redirect=bad", "https://api.github.com@evil.invalid/releases"):
with self.subTest(endpoint=endpoint), patch.object(updates, "RELEASES_API", endpoint), patch.object(updates, "_github_token") as read:
with self.assertRaises(updates.GitHubReleaseError):
updates.github_releases(self.root)
read.assert_not_called()
def test_cache_cannot_inject_freeform_failure_message(self):
for failure in (TOKEN, [TOKEN], {TOKEN: TOKEN}):
updates.atomic_json(self.root / "update-check.json", {"status": "check_failed", "failure": failure})
state = updates.UpdateService(self.root, "2.0.0").status()
self.assertEqual(state["status"], "check_failed")
self.assertNotIn(TOKEN, json.dumps(state))
if __name__ == "__main__":
unittest.main()
+126 -2
View File
@@ -143,7 +143,7 @@ class ServiceTests(unittest.TestCase):
status = self.manager.status(identifier)
self.assertTrue(status["connected"])
self.assertFalse(status["demo"])
self.assertFalse(status["running"])
self.assertTrue(status["running"])
worker = self.manager._worker(identifier)
identity = worker.active_identity
before = worker.securestore.load(identity).reqid
@@ -161,7 +161,131 @@ class ServiceTests(unittest.TestCase):
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": identity}))
restored = self.manager._worker(identifier).securestore.load(identity)
self.assertGreater(restored.reqid, before)
self.assertFalse(self.manager.status(identifier)["running"])
self.assertTrue(self.manager.status(identifier)["running"])
self.assertTrue(self.manager._worker(identifier).engine.auto)
def test_verified_login_starts_only_saved_selections_after_server_activation(self):
identifier = self.account(False)
self.login(identifier)
self.enable(identifier)
selected = deepcopy(self.manager.get_config(identifier)["config"])
self.job(identifier, self.manager.submit(identifier, "logout"))
before = len(FakeClient.calls)
self.job(identifier, self.manager.submit(identifier, "login", {
"account": "synthetic-owner", "password": "synthetic-password"}))
worker = self.manager._worker(identifier)
self.assertFalse(worker.running, "SDK server discovery activated strategies")
self.assertFalse(worker.engine.auto)
self.assertIsNone(worker.engine.client)
result = self.job(identifier, self.manager.submit(identifier, "enter_server", {"server_id": 1}))["result"]
self.assertTrue(result["connected"])
self.assertTrue(result["running"])
self.assertTrue(worker.engine.auto)
self.assertEqual(worker.config, selected, "Login changed the user's strategy selections")
self.assertIn("已勾选", result["message"])
self.assertEqual(self.manager.logs(identifier)["entries"][-1]["message"], result["message"])
self.assertEqual([url.rsplit("/", 2)[-2:] for _, url, _ in FakeClient.calls[before:]],
[["userServerService", "enterGame"], ["masterService", "masterQueryDetail"]])
def test_login_without_selected_rules_stays_enabled_and_later_selections_take_effect(self):
identifier = self.account(False)
self.job(identifier, self.manager.submit(identifier, "login", {
"account": "synthetic-owner", "password": "synthetic-password"}))
worker = self.manager._worker(identifier)
selected = deepcopy(worker.config)
result = self.job(identifier, self.manager.submit(identifier, "enter_server", {"server_id": 1}))["result"]
self.assertTrue(result["connected"])
self.assertTrue(result["running"])
self.assertTrue(worker.engine.auto)
self.assertEqual(worker.config, selected)
self.assertIn("已勾选", result["message"])
self.assertEqual(worker.engine.plans(), [])
before = len(FakeClient.calls)
worker.engine.last_heartbeat = worker.schedule.clock()
worker.schedule.next_poll = 0
self.job(identifier, worker.enqueue("__tick"))
self.assertTrue(worker.running)
self.assertTrue(worker.engine.auto)
self.assertTrue(all(url.endswith("masterService/masterQueryDetail")
for _, url, _ in FakeClient.calls[before:]))
self.enable(identifier)
self.assertTrue(worker.running)
self.assertTrue(worker.engine.auto)
self.assertTrue(worker.engine.daily_policy.enabled)
def test_restore_with_unknown_write_keeps_evidence_and_never_replays(self):
identifier = self.account(False)
self.login(identifier)
self.enable(identifier)
worker = self.manager._worker(identifier)
journal = worker.engine.battle_journal
pending = journal.begin(worker.engine.snapshot, {"kind": "battle", "description": "未确认战斗",
"path": "stageService/stageStart", "payload": {}, "stage_id": "0101", "difficulty": "1"})
journal.update(pending, "unknown", message="已有未确认请求,禁止重发")
evidence = journal.path.read_bytes()
before = len(FakeClient.calls)
result = self.job(identifier, self.manager.submit(identifier, "restore_session", {
"session_id": worker.active_identity}))["result"]
self.assertTrue(result["connected"])
self.assertFalse(result["running"])
self.assertFalse(worker.engine.auto)
self.assertIn("核对", result["message"])
self.assertEqual(journal.path.read_bytes(), evidence)
self.job(identifier, self.manager.submit(identifier, "start"), status="failed")
worker.engine.last_heartbeat = worker.schedule.clock()
self.job(identifier, worker.enqueue("__tick"))
self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot)["attempt_id"], pending["attempt_id"])
self.assertEqual(journal.path.read_bytes(), evidence)
self.assertTrue(all(url.endswith(("masterService/masterQueryDetail", "heartBeatService/keepAlive"))
for _, url, _ in FakeClient.calls[before:]))
def test_activation_persistence_can_be_revoked_before_final_commit(self):
for operation in ("enter_server", "restore_session"):
for revoke in ("stop", "logout", "forget_login", "config"):
with self.subTest(operation=operation, revoke=revoke):
identifier = self.account(False)
self.login(identifier, account="owner-" + identifier)
self.enable(identifier)
worker = self.manager._worker(identifier)
original_client = worker.engine.client
identity = worker.active_identity
if operation == "enter_server":
self.job(identifier, self.manager.submit(identifier, "login", {
"account": "owner-" + identifier, "password": "synthetic-password"}))
entered, release = threading.Event(), threading.Event()
self.addCleanup(release.set)
original = worker.securestore.set_active
def held(active):
if active == identity and not release.is_set():
entered.set()
if not release.wait(5):
raise AssertionError("Activation gate not released")
return original(active)
payload = {"server_id": 1} if operation == "enter_server" else {"session_id": identity}
before = self.manager.logs(identifier)["next"]
with patch.object(worker.securestore, "set_active", side_effect=held):
candidate = self.manager.submit(identifier, operation, payload)
self.assertTrue(entered.wait(2))
if revoke == "config":
config = self.manager.get_config(identifier)["config"]
config["daily_policy"]["enabled"] = False
followup = self.manager.set_config(identifier, config)["job"]
else:
followup = self.manager.submit(identifier, revoke)
self.assertFalse(worker.running)
release.set()
self.job(identifier, candidate, status="cancelled")
self.job(identifier, followup)
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
if revoke in {"stop", "config"}:
self.assertIs(worker.engine.client, original_client)
else:
self.assertIsNone(worker.engine.client)
self.assertFalse(any("已自动开启" in row["message"]
for row in self.manager.logs(identifier, after=before)["entries"]))
def test_role_workspaces_do_not_copy_targets_or_other_profiles_overrides(self):
first, other = self.account(False), self.account()
+1
View File
@@ -24,6 +24,7 @@ class UpdateTests(unittest.TestCase):
self.environment = patch.dict(os.environ, {"RANCH_WEB_UPDATER_DIR": ""})
self.environment.start()
self.addCleanup(self.environment.stop)
os.environ.pop(updates.TOKEN_FILE_ENV, None)
self.github = patch.object(updates, "github_releases", return_value=[])
self.releases = self.github.start()
self.addCleanup(self.github.stop)
+98 -1
View File
@@ -88,11 +88,12 @@ class HostUpdaterTests(unittest.TestCase):
self.addCleanup(self.github.stop)
# Linux CI runs unprivileged; real chown is a host deployment check.
self.chown = patch.object(updater.os, "chown", create=True)
self.chown.start()
self.mock_chown = self.chown.start()
self.addCleanup(self.chown.stop)
self.environment = patch.dict(os.environ, {"RANCH_WEB_UPDATER_DIR": str(self.config.control_dir)})
self.environment.start()
self.addCleanup(self.environment.stop)
os.environ.pop(updates.TOKEN_FILE_ENV, None)
def samples(self, directory=None):
with closing(sqlite3.connect((directory or self.config.data_dir) / "samples.sqlite3")) as connection:
@@ -282,6 +283,102 @@ class HostUpdaterTests(unittest.TestCase):
result = updater.HostUpdater(config, self.docker).run()
self.assertEqual(result["status"], "succeeded")
def test_private_web_check_request_and_host_apply_each_reread_shared_token(self):
self.enable()
self.github.stop()
path = self.config.data_dir / updates.TOKEN_FILE_NAME
tokens = ["github_pat_offline_check", "github_pat_offline_request", "github_pat_offline_host"]
path.write_text(tokens[0], encoding="ascii")
path.chmod(0o600)
payload = json.dumps([release("v2.0.1")]).encode("ascii")
service = updates.UpdateService(self.config.data_dir, "2.0.0")
with patch.object(updates, "build_opener") as build:
build.return_value.open.side_effect = lambda *args, **kwargs: io.BytesIO(payload)
self.assertTrue(service.check()["available"])
path.write_text(tokens[1], encoding="ascii")
self.assertEqual(service.request_update("v2.0.1")["status"], "pending")
path.write_text(tokens[2], encoding="ascii")
self.assertEqual(self.host.run()["status"], "succeeded")
authorizations = [call.args[0].get_header("Authorization") for call in build.return_value.open.call_args_list]
self.assertEqual(authorizations, ["Bearer " + token for token in tokens])
for document in [*self.config.data_dir.glob("*.json"), *self.config.control_dir.glob("*.json")]:
for token in tokens:
self.assertNotIn(token, document.read_text(encoding="utf-8"))
def test_private_access_failure_blocks_web_request_and_host_before_pull(self):
from urllib.error import HTTPError
self.enable()
self.github.stop()
service = updates.UpdateService(self.config.data_dir, "2.0.0")
for status in (401, 403, 404):
with self.subTest(status=status), patch.object(updates, "build_opener") as build:
build.return_value.open.side_effect = HTTPError(updates.RELEASES_API, status, "private-secret", {}, None)
with self.assertRaises(ValueError) as web_error:
service.request_update("v2.0.1")
with self.assertRaises(updater.UpdaterError) as host_error:
self.host.apply("v2.0.1")
for error in (web_error.exception, host_error.exception):
self.assertIn("权限", str(error))
self.assertNotIn("private-secret", str(error))
self.assertFalse((self.config.data_dir / "update-request.json").exists())
self.assertFalse(self.host.journal.exists())
self.assertFalse(self.config.backup_dir.exists())
self.assertEqual(self.docker.events, [])
def test_health_failure_restores_shared_token_permissions(self):
path = self.config.data_dir / updates.TOKEN_FILE_NAME
path.write_text("github_pat_offline_before", encoding="ascii")
path.chmod(0o600)
self.docker.fail_start = True
original_up = self.docker.up
def start(image):
if image != self.docker.old_image:
path.write_text("github_pat_offline_failed", encoding="ascii")
return original_up(image)
with patch.object(self.docker, "up", side_effect=start):
self.assertEqual(self.host.apply()["status"], "rolled_back")
self.assertEqual(path.read_text(encoding="ascii"), "github_pat_offline_before")
if os.name == "posix":
self.assertEqual(path.stat().st_mode & 0o777, 0o600)
def test_interactive_token_setup_is_local_hidden_and_sets_shared_ownership(self):
token = "github_pat_offline_interactive"
with patch.object(updater.getpass, "getpass", return_value=token), patch.object(updates, "build_opener") as network, patch.object(updater.Docker, "run") as docker:
result = updater.set_github_token(self.config)
path = self.config.data_dir / updates.TOKEN_FILE_NAME
self.assertEqual(path.read_text(encoding="ascii"), token + "\n")
self.assertEqual(self.mock_chown.call_args.args[1:], (10001, 10001))
if os.name == "posix":
self.assertEqual(path.stat().st_mode & 0o777, 0o600)
self.assertNotIn(token, json.dumps(result))
network.assert_not_called()
docker.assert_not_called()
def test_token_setup_rejects_echo_fallback_and_preserves_old_token_on_failure(self):
path = self.config.data_dir / updates.TOKEN_FILE_NAME
path.write_text("old-offline-token", encoding="ascii")
for failure in (EOFError("private-secret"), updater.getpass.GetPassWarning("private-secret")):
with self.subTest(failure=type(failure).__name__), patch.object(updater.getpass, "getpass", side_effect=failure):
with self.assertRaises(updater.UpdaterError) as caught:
updater.set_github_token(self.config)
self.assertNotIn("private-secret", str(caught.exception))
with patch.object(updater.getpass, "getpass", return_value="new-offline-token"), patch.object(updater.os, "replace", side_effect=OSError("private-secret")):
with self.assertRaises(updater.UpdaterError):
updater.set_github_token(self.config)
self.assertEqual(path.read_text(encoding="ascii"), "old-offline-token")
self.assertEqual(list(self.config.data_dir.glob(".update-token-*")), [])
def test_token_setup_dry_run_does_not_prompt_read_credentials_or_write(self):
source = Path(updater.__file__).with_name("updater.example.toml")
with patch.object(updater.getpass, "getpass") as prompt, patch.object(updates, "_github_token") as read, redirect_stdout(io.StringIO()) as output:
code = updater.main(["--config", str(source), "--set-github-token", "--dry-run"])
self.assertEqual(code, 0)
self.assertEqual(json.loads(output.getvalue())["mode"], "set-github-token")
prompt.assert_not_called()
read.assert_not_called()
def test_malformed_request_fails_without_network_or_docker(self):
self.enable()
updates.atomic_json(self.config.data_dir / "update-request.json", ["invalid"])
@@ -0,0 +1,72 @@
"""The release asset must run from outside the repo with only Python stdlib."""
import json
from pathlib import Path
import subprocess
import sys
import tempfile
import unittest
import zipfile
from ranch_web import __version__
ROOT = Path(__file__).resolve().parents[2]
OFFLINE_RUNNER = """
import os, runpy, socket, subprocess, sys
def forbidden(*args, **kwargs):
raise AssertionError('Network/Docker/prompt forbidden in package smoke test')
socket.socket.connect = forbidden
socket.create_connection = forbidden
subprocess.run = forbidden
import getpass
getpass.getpass = forbidden
os.environ['RANCH_WEB_UPDATE_GITHUB_TOKEN_FILE'] = '/nonexistent/private-token'
sys.argv = sys.argv[1:]
runpy.run_path(sys.argv[0], run_name='__main__')
"""
class UpdaterPackageTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.temporary = tempfile.TemporaryDirectory(prefix="standalone-updater-test-")
cls.addClassCleanup(cls.temporary.cleanup)
cls.folder = Path(cls.temporary.name)
cls.asset = cls.folder / "updater.pyz"
subprocess.run([sys.executable, "-I", "-S", "-B", str(ROOT / "tools/build_web_updater.py"),
"--output", str(cls.asset)], cwd=cls.folder, capture_output=True, check=True)
cls.config = cls.folder / "updater.toml"
cls.config.write_bytes((ROOT / "deploy/web/updater.example.toml").read_bytes())
def invoke(self, *arguments):
result = subprocess.run([sys.executable, "-I", "-S", "-B", "-X", "utf8", "-c", OFFLINE_RUNNER,
str(self.asset), *arguments], cwd=self.folder,
capture_output=True, text=True, encoding="utf-8", timeout=15)
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
return result.stdout
def test_help_and_version_work_without_config_repo_or_dependencies(self):
self.assertIn("--set-github-token", self.invoke("--help"))
self.assertEqual(self.invoke("--version").strip(), f"ranch-web-updater {__version__}")
def test_dry_run_is_offline_does_not_load_token_or_write_files(self):
before = sorted(path.relative_to(self.folder) for path in self.folder.rglob("*"))
result = json.loads(self.invoke("--config", str(self.config), "--apply", "v2.0.1", "--dry-run"))
self.assertTrue(result["dry_run"])
self.assertEqual(result["image"], "ghcr.io/attilanet/myrzx_bot-web:v2.0.1")
self.assertFalse(result["auto_apply"])
self.assertFalse(result["accept_web_requests"])
self.assertEqual(before, sorted(path.relative_to(self.folder) for path in self.folder.rglob("*")))
def test_archive_is_minimal_and_reproducible(self):
second = self.folder / "second.pyz"
subprocess.run([sys.executable, "-I", "-S", "-B", str(ROOT / "tools/build_web_updater.py"),
"--output", str(second)], cwd=self.folder, capture_output=True, check=True)
self.assertEqual(self.asset.read_bytes(), second.read_bytes())
with zipfile.ZipFile(self.asset) as archive:
self.assertEqual(set(archive.namelist()), {"__main__.py", "updater.py", "ranch_web/__init__.py", "ranch_web/updates.py"})
self.assertEqual(archive.read("ranch_web/__init__.py"), (ROOT / "ranch_web/__init__.py").read_bytes())
if __name__ == "__main__":
unittest.main()
+94 -15
View File
@@ -14,6 +14,7 @@ import stat
import tempfile
import threading
from urllib.error import HTTPError
from urllib.parse import urlsplit
from urllib.request import HTTPRedirectHandler, Request, build_opener
import uuid
@@ -21,6 +22,14 @@ REPOSITORY = "attilanet/myrzx_bot"
IMAGE = "ghcr.io/attilanet/myrzx_bot-web"
RELEASES_API = f"https://api.github.com/repos/{REPOSITORY}/releases"
PROTOCOL = 1
TOKEN_FILE_NAME = "update-github-token"
TOKEN_FILE_ENV = "RANCH_WEB_UPDATE_GITHUB_TOKEN_FILE"
_TOKEN_LIMIT = 4096
_RELEASE_FAILURES = {
"check_failed": "GitHub 发布检查失败,请稍后重试。",
"access_denied": "无法访问官方 GitHub 发布(401/403/404);请检查服务端 GitHub Token 文件及私有仓库的只读发布权限。",
"token_file_invalid": "GitHub Token 文件不可用;请检查服务端文件、0600 权限及数据目录 UID 10001 所有权。",
}
_TAG = re.compile(r"v2\.(0|[1-9][0-9]{0,8})\.(0|[1-9][0-9]{0,8})", re.ASCII)
_CURRENT = re.compile(r"v?2\.(0|[1-9][0-9]{0,8})\.(0|[1-9][0-9]{0,8})(\.dev[0-9]+)?", re.ASCII)
_ID = re.compile(r"[0-9a-f]{32}", re.ASCII)
@@ -129,32 +138,93 @@ class _NoRedirect(HTTPRedirectHandler):
return None
def github_releases():
"""Fetch only the fixed public repository. No tokens or asset downloads."""
class GitHubReleaseError(RuntimeError):
"""Fixed, public explanations; never retain credentials or HTTP bodies."""
def __init__(self, code="check_failed"):
self.code = code if code in _RELEASE_FAILURES else "check_failed"
super().__init__(_RELEASE_FAILURES[self.code])
def github_token_path(data_dir=None):
"""An explicit override is a server-side path, never a raw token."""
override = os.environ.get(TOKEN_FILE_ENV)
if override is not None:
if not override or not Path(override).is_absolute():
raise GitHubReleaseError("token_file_invalid")
return Path(override)
return Path(data_dir) / TOKEN_FILE_NAME if data_dir is not None else None
def _validate_token(payload):
try:
token = payload.decode("ascii").rstrip("\r\n")
if not 0 < len(payload) <= _TOKEN_LIMIT or re.fullmatch(r"[!-~]+", token) is None:
raise ValueError
except (UnicodeError, ValueError):
raise GitHubReleaseError("token_file_invalid") from None
return token
def _github_token(data_dir):
path = github_token_path(data_dir)
if path is None:
return None
flags = os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0) | getattr(os, "O_NONBLOCK", 0)
try:
if path.is_symlink():
raise GitHubReleaseError("token_file_invalid")
descriptor = os.open(path, flags)
with os.fdopen(descriptor, "rb") as stream:
info = os.fstat(stream.fileno())
if (not stat.S_ISREG(info.st_mode) or info.st_nlink != 1 or info.st_size > _TOKEN_LIMIT
or (os.name == "posix" and stat.S_IMODE(info.st_mode) != 0o600)):
raise GitHubReleaseError("token_file_invalid")
return _validate_token(stream.read(_TOKEN_LIMIT + 1))
except FileNotFoundError:
if TOKEN_FILE_ENV not in os.environ:
return None # Existing public deployments need no credential.
raise GitHubReleaseError("token_file_invalid") from None
except OSError:
raise GitHubReleaseError("token_file_invalid") from None
def github_releases(data_dir=None):
"""Fetch fixed official releases using only an optional server token file."""
# Validate before loading credentials, even if a caller monkey-patches the URL.
endpoint = urlsplit(RELEASES_API)
if (endpoint.scheme != "https" or endpoint.netloc != "api.github.com"
or endpoint.path != f"/repos/{REPOSITORY}/releases" or endpoint.query or endpoint.fragment):
raise GitHubReleaseError()
token = _github_token(data_dir)
opener = build_opener(_NoRedirect())
releases = []
for page in range(1, 11):
request = Request(f"{RELEASES_API}?per_page=100&page={page}", headers={
headers = {
"Accept": "application/vnd.github+json",
"User-Agent": "ranch-web-release-checker/2",
"X-GitHub-Api-Version": "2022-11-28",
})
}
if token is not None:
headers["Authorization"] = f"Bearer {token}"
request = Request(f"{RELEASES_API}?per_page=100&page={page}", headers=headers)
try:
with opener.open(request, timeout=8) as response:
payload = response.read(2 * 1024 * 1024 + 1)
except HTTPError as error:
if error.code == 404: # A repository without public releases.
return []
raise
if len(payload) > 2 * 1024 * 1024:
raise ValueError("发布列表超出大小限制。")
raise ValueError
items = json.loads(payload)
if not isinstance(items, list) or len(items) > 100:
raise ValueError("发布列表格式无效。")
raise ValueError
except HTTPError as error:
error.close()
raise GitHubReleaseError("access_denied" if error.code in {401, 403, 404} else "check_failed") from None
except Exception:
raise GitHubReleaseError() from None
releases.extend(items)
if len(items) < 100:
return releases
raise ValueError("发布列表超出页数限制,请稍后重试。")
raise GitHubReleaseError()
def official_tags(releases):
@@ -260,13 +330,17 @@ class UpdateService:
state = request["status"]
elif host:
state = host["status"]
failure = cache.get("failure")
failure = failure if isinstance(failure, str) else None
message = (_RELEASE_FAILURES.get(failure, _MESSAGES[state])
if state == "check_failed" else _MESSAGES[state])
result = {
"current_version": self.current_version, "latest_version": latest,
"available": available, "checked_at": timestamp(checked) if checked else None,
"release_url": f"https://github.com/{REPOSITORY}/releases/tag/{latest}" if latest else None,
"channel": "stable-2.x", "repository": REPOSITORY,
"status": state, "message": _MESSAGES[state],
"error": _MESSAGES[state] if state in {"check_failed", "failed", "rolled_back"} else None,
"status": state, "message": message,
"error": message if state in {"check_failed", "failed", "rolled_back"} else None,
"can_apply": available and executor["enabled"] and state not in {"pending", "applying"},
"executor": executor, "request": request, "host_status": host,
}
@@ -275,10 +349,13 @@ class UpdateService:
def check(self):
with self._lock:
try:
tags = official_tags(github_releases())
tags = official_tags(github_releases(self.root))
latest = max(tags, key=stable_version) if tags else None
state = "no_release" if latest is None else "available" if stable_version(latest) > self._current else "up_to_date"
cache = {"status": state, "latest_version": latest, "checked_at": timestamp()}
except GitHubReleaseError as error:
cache = {"status": "check_failed", "failure": error.code,
"latest_version": None, "checked_at": timestamp()}
except Exception:
# Never expose response bodies, proxy addresses, tokens, or paths.
cache = {"status": "check_failed", "latest_version": None, "checked_at": timestamp()}
@@ -299,7 +376,9 @@ class UpdateService:
return state
# Revalidate against live official releases, never just a local cache.
try:
tags = official_tags(github_releases())
tags = official_tags(github_releases(self.root))
except GitHubReleaseError as error:
raise ValueError(str(error)) from None
except Exception:
raise ValueError(_MESSAGES["check_failed"]) from None
target = version or (max(tags, key=stable_version) if tags else None)
+1 -1
View File
@@ -94,7 +94,7 @@ def _strategy_fields(catalog):
"login": [_field(["auto_relogin", "enabled"], "掉线后自动重新登录", value=False,
help="需在服务端记住账号和密码,并已保存原区服和角色;开启后,掉线或服务重启均等待设定时长,再返回原区服、原角色。"),
_field(["auto_relogin", "delay_minutes"], "重登等待时长(分钟)", "integer", min=1, max=10080, value=30,
help="1~10080 的整数分钟,默认 30 分钟。重登成功恢复监控,策略保持停止;关闭页面不影响服务端自动重登,手动退出登录可取消本次安排。")],
help="1~10080 的整数分钟,默认 30 分钟。重登成功恢复监控并自动执行已勾选功能,可在顶部“停止”;关闭页面不影响服务端自动重登,手动退出登录可取消本次安排。")],
"incubator": [], "bag": [], "ranch": [], "battles": [], "statistics": [], "plans": []}
+52
View File
@@ -0,0 +1,52 @@
#!/usr/bin/env python3
"""Build the standalone host updater using only the Python standard library."""
from __future__ import annotations
import argparse
import os
from pathlib import Path
import tempfile
import zipfile
ROOT = Path(__file__).resolve().parents[1]
SOURCES = {
"updater.py": "deploy/web/updater.py",
"ranch_web/__init__.py": "ranch_web/__init__.py",
"ranch_web/updates.py": "ranch_web/updates.py",
}
ENTRYPOINT = b"from updater import main\nraise SystemExit(main())\n"
def build(output):
output = Path(output)
output.parent.mkdir(parents=True, exist_ok=True)
descriptor, temporary = tempfile.mkstemp(prefix=".updater-", dir=output.parent)
try:
# Fixed order/timestamps make the asset reproducible for a given source.
with os.fdopen(descriptor, "wb") as stream, zipfile.ZipFile(stream, "w", compression=zipfile.ZIP_DEFLATED) as archive:
contents = {"__main__.py": ENTRYPOINT}
contents.update({name: (ROOT / source).read_bytes() for name, source in SOURCES.items()})
for name, content in contents.items():
compile(content, name, "exec")
info = zipfile.ZipInfo(name, date_time=(2020, 1, 1, 0, 0, 0))
info.compress_type = zipfile.ZIP_DEFLATED
info.external_attr = 0o100644 << 16
archive.writestr(info, content)
os.replace(temporary, output)
finally:
if os.path.exists(temporary):
os.unlink(temporary)
return output
def main(argv=None):
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--output", required=True, type=Path, metavar="PATH", help="destination updater.pyz release asset")
args = parser.parse_args(argv)
print(build(args.output))
return 0
if __name__ == "__main__":
raise SystemExit(main())