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
+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()
+96 -17
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)
if len(payload) > 2 * 1024 * 1024:
raise ValueError
items = json.loads(payload)
if not isinstance(items, list) or len(items) > 100:
raise ValueError
except HTTPError as error:
if error.code == 404: # A repository without public releases.
return []
raise
if len(payload) > 2 * 1024 * 1024:
raise ValueError("发布列表超出大小限制。")
items = json.loads(payload)
if not isinstance(items, list) or len(items) > 100:
raise ValueError("发布列表格式无效。")
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": []}