删掉临时提交说明

用户报：学校的电脑是 Windows 7，装完提示缺 DLL。

== 根因不是漏打包，是 Python 版本越界 ==

    Python 3.8    -> 最后一个支持 Windows 7 的版本
    Python 3.9+   -> 只支持 Windows 8 及以上

Python 3.9 起用到了 api-ms-win-core-path-l1-1-0.dll 里的
PathCchCanonicalizeEx，而这个 DLL **Windows 7 上根本不存在**，
也没法用 api-set 转发（那套机制只在 Win8+ 生效）。

所以之前用 3.11 打出来的包，在 Win7 上必然报缺 DLL ——
**那个 DLL 不是"忘了放进包"，是"放进去也没用"。**

顺带说明：包里那 47 个 api-ms-win-core-*.dll 转发库正是
Python 为兼容 Win7 才带上的 —— 上游本来就考虑过 Win7，
只是 3.11 这个版本号越界了。

== 改法 ==

1. **改用 Python 3.8 打包，而且选 32 位**
   32 位在 Win7 的 32 位和 64 位系统上都能跑，学校不用分两种发。
   （64 位的包在 32 位 Windows 上直接起不来。）

   依赖固定到 3.8 能用的版本：
       Pillow==9.5.0（最后一个支持 3.8 的）
       pyinstaller 6.x（保持 _internal 布局，和安装包/测试/卸载逻辑一致；
                       5.x 会把依赖摊在根目录，导致"_internal 在"那一项失败）

2. **打包脚本主动拦**
   windows\build_exe.ps1 打包前先校验 Python：
     * 找不到 3.8 -> 报错并给出安装命令
     * 版本不是 3.8 -> 直接 throw，而不是默默打一个别人装不上的包
     * 不是 32 位 -> 警告
   Python 从 YKXMZ_PY 环境变量或常见路径里找，不写死。

3. **新增 Win7 兼容校验** _build\check_win7_compat.py
   盯三件事：内嵌是不是 3.8 的运行库、**有没有**那个要命的 DLL、
   exe 是不是 32 位。打包时和回归套件（3a9 关）里都会跑，
   不过就拒绝出包。

== 顺手修的 ==

_build/test_installer_cycle.py 里写死了 ykxmz-setup-1.8.2.exe，
于是一直在**装一个不存在的旧包** -> 静默失败 -> 报出一堆
莫名其妙的失败（"配对码实际是 xxx"、"版本显示 v1.8.2"）。
改成自动找 dist 下版本号最新的包（按数字段排序，不能按字符串，
否则 1.9.0 会排到 2.1.4 前面）。

== 验证（用户要求：自己测一遍，没问题再上传）==

    全量回归 42 个阶段全 PASS（含新的 "Windows 7 兼容" 关）
    安装包完整周期 20/20
    Win7 校验：python38.dll / 无 api-ms-win-core-path / 32 位
    实际启动打包的 EXE：进程活着、TCP 监听、UDP 自动发现在听、
                        连接能建立（日志里有"设备接入"）
    产物扫描：三件全部干净（无旧密码、无服务器 IP）
    提交前泄漏闸门通过

安装包体积 14.4 MB -> 9.0 MB。

.gitignore

@@ -64,3 +64,25 @@ desktop.ini
 /_build/.gitee_token
 *.token
 .env
+# ---- 测试用的临时数据目录（会被测试脚本移来移去）----
+/windows/data/
+/windows/data_bk_*/
+/_build/*_data/
+/_build/_pairtest/
+/_build/_whitetest/
+/_tests/_stubdata/
+/_tests/_*_data/
+# ---- 密码 / 令牌（绝对不能进仓库）----
+# admin_password.txt 是运行时生成的，只有本机能看。
+# 一旦提交，git 历史删不掉，等于把管理台钥匙公开。
+admin_password.txt
+*admin_password*.txt
+/_build/_hdr_data/
+/_build/relay_info.json
+# 后台管理密码（绝不进仓库）
+_build/.admin_password
+
+# 服务器地址（绝不进仓库）
+_build/.lightsail_host
+_build/.gitee_token
+_build/.admin_password

LICENSE

@@ -0,0 +1,681 @@
+ykxmz —— 教室多媒体辅助工具
+Copyright (C) 2026 小麦子
+
+本程序是自由软件：你可以再发布和/或修改它，依据自由软件基金会发布的
+GNU Affero 通用公共许可证（第 3 版或你选择的任何更新版本）的条款。
+
+本程序的发布是希望它有用，但**没有任何保证**；甚至没有适销性或
+特定用途适用性的默示保证。详见 GNU Affero 通用公共许可证。
+
+你应该已经随本程序收到了一份 GNU Affero 通用公共许可证的副本
+（见本文件下半部分）。如果没有，见 <https://www.gnu.org/licenses/>。
+
+--------------------------------------------------------------------------
+⚠ 使用限制请看 docs/LICENSE.txt（《使用条款与免责声明》）：
+  本软件是一套远程控制工具，禁止用于未经同意的他人设备、
+  禁止用于偷窥监视、禁止伪装隐藏。那份文件约束的是**使用行为**，
+  和本文件（约束**代码**的授权）互不冲突。
+--------------------------------------------------------------------------
+
+
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.

README.md

@@ -31,8 +31,7 @@
 
 - 课件全屏投到教室大屏
 - 放听力音频（电脑音箱比手表响多了）
-- 看看学生机是不是在打游戏，直接把游戏进程结了
-- 课堂专注模式，下课一键恢复
+- 上课时把教室电脑切到专注状态，下课一键恢复
 - 下课关机、锁屏
 - 喊一声"上课了"让电脑播音（TTS）
 
@@ -46,13 +45,35 @@
 
 | 装在哪 | 是什么 | 文件 |
 |---|---|---|
-| 教室电脑（Windows） | 被控端 | `ykxmz-agent-1.5.0.zip` |
-| 小服务器（随身 WiFi / 云主机 / 树莓派） | 中转站 | `ykxmz-server-1.5.0.zip` |
-| 手表（安卓） | 控制端 | `ykxmz-watch-1.5.0.apk` |
+| 教室电脑（Windows） | 被控端 | `ykxmz-setup-2.1.5.exe` |
+| 小服务器（随身 WiFi / 云主机 / 树莓派） | 中转站 | `ykxmz-server-2.1.5.zip` |
+| 手表（安卓） | 控制端 | `ykxmz-watch-2.1.5.apk` |
 
 **只在一个教室用？** 那第三件（中转站）可以先不装，手表和电脑连同一个 WiFi 就能直连。
 
-**要在办公室管教室？** 那必须装中转站（见 [跨网络](#跨网络在办公室管教室)）。
+**要在办公室管教室？** 那必须**自己部署一台中转站**（见 [跨网络](#跨网络在办公室管教室)）。
+
+> ### ⚠️ 软件里不带任何中转地址
+>
+> 这一点先讲清楚，免得白折腾：
+>
+> **这个软件默认是"空的" —— 没有任何内置的中转服务器地址，
+> 也没有官方服务器可以用，作者不对外提供中转服务。**
+>
+> - **同一个 WiFi 下用（教室里）**：不需要中转，装完就能连，什么地址都不用填。
+> - **要跨网络用（办公室管教室）**：**你得自己部署一台中转站**。
+>   服务端压缩包里有一键脚本，一条命令装好：
+>
+>   ```bash
+>   bash deploy.sh
+>   ```
+>
+>   装完它会打印一个属于你自己的公网地址，把它填到电脑和手表上。
+>   详见 [装中转站](#装中转站)。
+>
+> 为什么不做一个"填个公共地址就能用"？因为中转站的带宽是实打实的成本，
+> 谁用谁出；而且**中转站能看到经过它的字节流**，
+> 自己搭一台，数据才真正只在你自己手里。
 
 ---
 
@@ -60,9 +81,9 @@
 
 ### 第一步：电脑上装被控端
 
-解压 `ykxmz-agent-1.5.0.zip`，双击里面的 `ykxmz.exe`。
+双击 `ykxmz-setup-2.1.5.exe`，按提示装完（默认装到 `C:\Program Files\ykxmz`）。
 
-弹出的窗口里填两样：
+第一次运行会弹出窗口，填两样：
 
 - **6 位数字** —— 自己定，好记就行，比如 `789113`
 - 两个勾：`设置开机自启`、`放行防火墙`（放行那个要过一次管理员确认）
@@ -70,12 +91,15 @@
 点确定，屏幕会黑闪一下（在加防火墙规则），然后窗口消失，程序转到后台跑。
 
 > **窗口关了程序还在跑**，这是故意的 —— 上课时讲台上不该有个窗口杵着。
-> 想再打开窗口，**再双击一次 EXE** 就行，不会起第二个进程。
+> 想再打开窗口，**再双击一次程序图标**就行，不会起第二个进程。
 > 想彻底退出，窗口上点「退出」。
 
+> 不想用安装包的话，`ykxmz-agent-2.1.5.zip` 是绿色版：
+> 解压出来直接跑 `ykxmz.exe`，整个文件夹拷走就能换台机器用，不写注册表。
+
 ### 第二步：手表上装 App
 
-把 `ykxmz-watch-1.5.0.apk` 传到手表装上。手表可能提示"未知来源"，去设置里允许一下。
+把 `ykxmz-watch-2.1.5.apk` 传到手表装上。手表可能提示"未知来源"，去设置里允许一下。
 
 打开 App，首页有四个入口：
 
@@ -115,26 +139,34 @@
 
 这一页是给上课准备的。
 
+> **先说清楚作用范围**：被控端装在**一台** Windows 电脑上
+> —— 就是讲台那台，或者你自己的机器。
+> **所有操作只影响这一台**，看不到也管不着其他电脑。
+> 装的时候要输配对码，没配对码连不上。
+
 | 按钮 | 干什么 |
 |---|---|
-| **课堂专注模式** | 改 hosts，把常见游戏站点指到本地。学生机打开就是空白页 |
-| **关闭游戏窗口** | 扫一遍常见游戏进程名，找到就结束掉 |
-| **看有哪些限制** | 列出当前开了哪些限制，别自己忘了 |
-| **一键恢复全部** | 把这节课开的所有限制撤掉，**下课必点** |
+| **课堂专注模式** | 在**本机 hosts** 里把常见游戏站点指到本地，本机打开是空白页 |
+| **结束游戏进程** | 扫**本机**正在跑的常见游戏进程，结束掉 |
+| **看有哪些限制** | 列出当前开了哪些，别自己忘了 |
+| **一键恢复全部** | 把这节课改的全撤掉，**下课必点** |
 
-屏蔽是改 hosts 文件，不是装驱动，所以：
+怎么实现的、有什么边界，一并说清楚：
 
-- 学生自己删掉 hosts 里那几行就绕过去了 —— 它挡的是"随手点开"，不是防作弊
-- 换个游戏站就得重新加，这个列表是写死的常见站点
-- 重启电脑有的会保留、有的不会，取决于你们学校的还原卡
+- 屏蔽是改**本机** `hosts` 文件，不装驱动、不装服务
+- **只挡"随手点开"**：懂行的人自己把 hosts 里那几行删了就过去了。
+  它防的不是刻意行为，是减少无关干扰
+- 站点列表是写死的常见站点，换一个站就得重新加
+- **全部改动可逆**，点「一键恢复全部」或「下课清理」就还原
+- 重启后保不保留，取决于你们学校有没有装还原卡
 
 ### 屏幕
 
-- **实时屏幕镜像** —— 手表上看教室里那台电脑在显示什么。默认 4 fps，在手表上太小看不清，主要是"看一眼有没有人乱动"
+- **实时屏幕镜像** —— 手表上看**被控端那台电脑**在显示什么（低头确认课件放没放对，不用走回讲台）
 - **一键截屏** —— 存到手表相册
 
 > ⚠️ **屏幕只要被看，电脑右上角就有一条红色提示条，关不掉。**
-> 这是刻意做的：教室里那台电脑是公家的，谁在看必须让人知道。
+> 这是刻意做的：谁在看，电脑前面的人必须能立刻知道。
 > 电脑前面的人随时可以点提示条上的「停止共享」把你掐断。
 
 ### 媒体 / 音频
@@ -188,19 +220,61 @@
 
 ### 装中转站
 
-把 `ykxmz-server-1.5.0.zip` 解压到那台小机器上（随身 WiFi、树莓派、云主机都行，Debian/Ubuntu 系统），然后：
+中转站就是**一台能上外网的 Linux 小机器**（随身 WiFi、树莓派、云主机都行，
+Debian 12 / Ubuntu 实测可用，512 MB 内存就够）。
+
+把 `ykxmz-server-2.1.5.zip` 解压到那台机器上，然后一条命令：
 
 ```bash
-sudo bash install.sh
+bash deploy.sh
 ```
 
-装完会打印一个公网地址，长这样：
+它会自己做完这些，不用你一步步敲：
+
+1. 装 cloudflared（已经装了就用现成的）
+2. 把中转程序装到 `/root/lanremote-relay/`
+3. 网络调优（keepalive、MSS、MTU、开机加速）
+4. 注册 systemd 服务，设成开机自启
+5. 配好 Cloudflare 隧道
+6. 启动、自检，然后把**公网地址**打印出来
+
+装完会打印一个属于你自己的公网地址，长这样：
 
 ```
 https://relay.你的域名
 ```
 
-**记住这个地址**，电脑和手表都要填它。忘了就打开 `http://<小机器的IP>:8080/url` 查。
+**记住这个地址**，电脑和手表都要填它。忘了就在那台机器上跑
+`lanremote-url`，或者浏览器打开 `http://<小机器的IP>:8080/url` 查。
+
+#### 三种常见情形
+
+```bash
+# ① 机器上已经有隧道凭据（/root/.cloudflared/*.json）
+bash deploy.sh
+
+# ② Cloudflare 给了一个隧道 Token（Zero Trust 后台复制的那串）
+TUNNEL_TOKEN=eyJhIjoi... bash deploy.sh
+
+# ③ 换域名 / 只装中转、不要隧道
+bash deploy.sh --hostname relay.你的域名
+bash deploy.sh --skip-tunnel
+```
+
+看全部参数：`bash deploy.sh --help`
+
+> **用环境变量而不是 `--token`**：写进命令行的 Token 会留在 shell 历史里。
+
+#### 重跑一遍 = 升级
+
+`deploy.sh` 是**幂等**的：已经装过的机器再跑一次就是升级。
+程序文件会被覆盖成新的，而**设备数据、配对码、隧道凭据都不会被冲掉**。
+
+#### 需要准备什么
+
+- 一台能上外网的 Linux 小机器（Debian 12 / Ubuntu，512 MB 内存够）
+- 一个 Cloudflare 账号 + 一个域名（隧道要用）
+- **不需要**装 Python 第三方包 —— 服务端是纯标准库，不装任何依赖
 
 ### 告诉电脑中转地址
 
@@ -212,19 +286,34 @@ ykxmz.exe --relay "192.168.1.50:8080;https://relay.你的域名"
 
 两个地址用分号隔开，**按顺序试，第一个通的就用**。这样在教室里走局域网（快、稳），出了学校自动切隧道。
 
+如果只在跨网络的场景用，也可以只填一个域名：
+
+```
+ykxmz.exe --relay https://relay.你的域名
+```
+
+看看当前用的是哪个地址：
+
+```
+ykxmz.exe --relay-status
+```
+
 ### 告诉手表中转地址
 
 手表首页点「中转设置」，填上面同一个地址。
 
 然后回家首页点「输入配对码连接」，填电脑上那 6 位数字。
 
-### 中转站怎么管
+### 中转站的公网地址打开是什么
 
-浏览器打开中转站的公网地址，用管理密码登录（默认 `120830`，装完后强烈建议改）。
+打开就是**一个普通的官网页面** —— 介绍、截图、三个文件的下载按钮，
+最新版的安装包挂在上面，点一下就能下。
 
-能看：哪些电脑在线、配对码是什么、有多少会话、内存用了多少。
-能做：踢掉某个会话、删掉某个配对码绑定、跑个网络体检。
-下载区：最新版的三个文件都挂在上面，点一下就能下。
+安装包和截图这类静态文件**由 Cloudflare 的边缘节点直接发送**，
+所以下载速度和那台小机器的带宽无关（实测比走隧道回源快几十倍）。
+
+想看运行状态、排查问题、重启服务，**看服务端压缩包里的
+`README-server.txt`** —— 那份文档是给运维的人看的，里面写了日常命令。
 
 ---
 
@@ -322,7 +411,7 @@ App 把错误翻译成人话了，看到哪句就照做：
 
 ## 安全
 
-教室里那台电脑是公家的东西，所以这套工具的安全设计偏"让人知道"而不是"藏起来"。
+被控端装的往往是公家的电脑，所以这套工具的安全设计偏"让人知道"而不是"低调运行"。
 
 **每次连接都要配对。** 电脑上生成 6 位数字，只在窗口上显示，手表输对了才连得上。
 
@@ -336,11 +425,14 @@ App 把错误翻译成人话了，看到哪句就照做：
 
 **不写注册表。** 数据全在程序目录下的 `data/` 里，拔了硬盘拷走就能换台机器跑。
 
-**不在后台偷偷上传。** 局域网模式下完全不联外网。跨网络模式只连你自己那台中转站。
+**只在你自己填的地址之间通信。** 局域网模式下完全不联外网。跨网络模式只连你自己那台中转站，不经过任何第三方。
 
-> **这个工具不藏自己。** 没有"任务管理器里看不见"，没有"免杀对抗"，没有伪装成系统进程。
-> 被控端全程可见、可随时断开、权限可随时关掉。
-> 因为管的是教室的电脑，藏起来只会让老师不放心。
+**所有行为都在明面上。** 被控端在托盘有图标、窗口看得见、随时可以退出、
+权限可以逐项关闭。它不做任何"让机器上其他程序看不见自己"的事 ——
+因为管的是自己要用的一台电脑，能看见、能随时停，才让人放心。
+
+**代码全公开。** 三端加起来不到两万行，都是纯标准库，
+想看它到底干了什么直接读源码就行。
 
 ---
 
@@ -364,7 +456,7 @@ windows\build_exe.ps1
 ```powershell
 android\build_apk.ps1
 # 流程：aapt2 → javac → d8 → zipalign → apksigner
-# 产物：dist\ykxmz-watch-1.5.0.apk
+# 产物：dist\ykxmz-watch-2.1.5.apk
 ```
 
 最低支持 Android 7.0（API 24），targetSdk 34。
@@ -374,9 +466,13 @@ android\build_apk.ps1
 Python 3 标准库，没有第三方包。
 
 ```bash
-bash relay/install.sh
+bash relay/deploy.sh
 ```
 
+`deploy.sh` 是一键部署（装服务 + 调优 + 配隧道 + 自检）；
+只想调网络参数的话是 `relay/deploy-tune.sh`。
+老的 `relay/install.sh`（匿名快速隧道）仍在包里，只为兼容以前装过的机器。
+
 ### 跑测试
 
 ```powershell
@@ -408,7 +504,22 @@ python _build\package_remote.py
 
 二进制数据（图片、文件、音频）走 **Base64** 分块传输，单次会话上限 256 MB。
 
-跨网络时同样的消息套在 HTTP 长轮询里，中转站按配对码把两端字节对接，**它不解析内容**。
+跨网络时同样的消息套在 **HTTP 长轮询**里（单次挂 **60 秒**，
+有数据立刻返回、不空等），中转站按配对码把两端字节对接，**它不解析内容**。
+
+跨网络这条链路上还有几个实测调出来的设计，改代码前值得知道：
+
+- **隧道两种协议同时跑**（QUIC + HTTP/2，合计 10 条连接）。
+  两种协议各有各的毛病 —— QUIC 尾部延迟好但建连容易超时，
+  HTTP/2 建连可靠但丢包时容易被队头阻塞卡住。
+  同时跑就是互相兜底：一种犯病，另一种还在服务。
+- **长轮询 60 秒**。隧道每次请求要多花 1~2 秒，这个开销是按次数收的；
+  拉到 60 秒把请求数降到 1/4，撞上丢包窗口的概率也降到 1/4。
+  **命令响应速度不变**（有数据立刻返回，不是等满 60 秒）。
+- **偶发失败不当场判离线**。4G 链路上本来就有百分之几的偶发抖动、
+  一两秒自己恢复；连续失败 3 次才算真的离线。
+- **静态资源交给 Cloudflare 边缘缓存**。下载走边缘节点，
+  不用穿隧道回那台小机器，快几十倍也更省流量。
 
 Java 和 Python 两端都实现了同一套协议，`_tests/java/` 下有互相打通的测试。
 
@@ -429,7 +540,18 @@ Java 和 Python 两端都实现了同一套协议，`_tests/java/` 下有互相
 不会。只要 `data/` 目录还在，服务器就认原来那个码。母盘部署时注意别把 `data/` 一起发出去。
 
 **问：走中转会不会很慢？**
-实测局域网 3 毫秒左右，公网中转 1~3 秒（取决于你那台小机器的线路）。所以**同一个 WiFi 一定走局域网**，程序会优先选它。
+实测局域网 3 毫秒左右；跨网络要绕到中转站再回来，约 1~2 秒（取决于你那台小机器的线路）。所以**同一个 WiFi 一定走局域网**，程序会优先选它。
+
+**问：必须自己搭中转站吗？能用作者的服务器吗？**
+必须自己搭。**软件不内置任何中转地址，作者也不对外提供中转服务。**
+跨网络的话，服务端 zip 里有 `deploy.sh`，一条命令装好（见 [装中转站](#装中转站)）。
+只在同一个 WiFi 下用的话，压根不需要中转站。
+
+**问：中转站会不会看到我的数据？**
+它转发的是加密前的字节流，所以**技术上能**。这正是"自己搭一台"的理由 —— 搭在你自己手上，数据就只经过你自己的机器。
+
+**问：下载安装包为什么比以前快这么多？**
+最新版把静态文件交给 Cloudflare 的边缘节点缓存了。原来每次下载都要穿过隧道回到那台小机器上取，实测只有几 KB/s，15 MB 的安装包根本下不动；现在从离你最近的边缘节点直接发，实测快了四十多倍，也不占小机器的流量。
 
 **问：能在手机上用吗？**
 协议是通的，但界面是按手表的小屏幕设计的（大按钮、两列、可滚动），手机上会显得按钮特别大。要做手机版得重写布局。
@@ -447,7 +569,7 @@ Java 和 Python 两端都实现了同一套协议，`_tests/java/` 下有互相
 
 1. 手表上显示的那句错误（App 现在是中文的，直接念出来就行）
 2. 电脑上 `工具箱.bat` → 选 `5` 的日志内容
-3. 中转站的公网地址（不用给密码）
+3. 跨网络的话，把你那台中转站的公网地址发过来（不用给任何密码）
 
 ---
 

_build/CHANGELOG.md

@@ -1,3 +1,314 @@
+## 2.1.5
+
+- **修「Windows 7 装完报 dll 缺失」** —— 学校电脑装不上。
+
+  这一条是用户报的：学校的电脑是 Windows 7，装完提示缺 DLL。
+
+  **根因不是漏打包，是 Python 版本越界**：
+
+  | Python | 支持的系统 |
+  |---|---|
+  | **3.8** | Windows 7 及以上 ← 最后一个支持 Win7 的版本 |
+  | 3.9 ~ 3.13 | 只支持 Windows 8 及以上 |
+
+  Python 3.9 起用到了 `api-ms-win-core-path-l1-1-0.dll` 里的
+  `PathCchCanonicalizeEx`，而这个 DLL **Windows 7 上根本不存在**，
+  也没法用 api-set 转发（那套机制只在 Win8+ 生效）。
+
+  所以之前用 3.11 打出来的包，在 Win7 上必然报缺 DLL ——
+  **那个 DLL 不是"忘了放进包"，是"放进去也没用"。**
+
+  **改法：改用 Python 3.8 打包**，而且选 **32 位** ——
+  32 位在 Win7 的 32 位和 64 位系统上**都能跑**，学校不用分两种发。
+
+  顺带加了两道自动关卡，以后不会再退化：
+  - 打包脚本 `windows\build_exe.ps1` **先校验 Python 版本**，
+    不是 3.8 直接报错退出（而不是默默打一个别人装不上的包）
+  - `_build\check_win7_compat.py` 校验产物：
+    内嵌是不是 3.8 的运行库、**有没有**那个要命的 DLL、exe 是不是 32 位。
+    打包时和回归套件里都会跑，不过就拒绝出包
+
+  安装包体积也从 14.4 MB 降到 **9.0 MB**（32 位运行库小一圈）。
+
+- **顺手修了安装包测试里一个藏了很久的坑**：
+  `_build/test_installer_cycle.py` 里写死了 `ykxmz-setup-1.8.2.exe`，
+  于是它一直在**装一个不存在的旧包** → 静默失败 → 报出一堆
+  莫名其妙的失败（"配对码实际是 xxx"、"版本显示 v1.8.2"）。
+  改成自动找 `dist` 下版本号最新的包，以后不会再过期。
+
+## 2.1.4
+
+- **修一个"填了地址也连不上"的 bug**（手表端）。
+
+  中转地址栏里填 `yk.xxmxxs.top` 这种**没写 `http://` 开头**的地址时，
+  点首页那个「检查服务器」会报：
+
+  ```
+  MalformedURLException: no protocol: yk.xxmxxs.top/v1/health
+  ```
+
+  原因是：补协议头的逻辑只写在连接那一条路上，
+  「检查服务器」直接拿原始字符串拼 URL —— **同一个地址，
+  连接能用，检查却崩**。
+
+  现在把补协议头收到**唯一一个入口**（读地址的地方），
+  所有用到地址的地方都从那里取，以后再加新入口也不会漏。
+
+  规则和电脑端保持一致：
+  - `IP` / `localhost` / `*.local` → 用 `http://`
+  - 域名 → 用 `https://`
+
+- **修正 README 里几处不准确的说法**，以及过时的版本号：
+  - 被控端只装在**一台**电脑上（讲台那台或你自己那台），
+    原文写成"看学生机"是错的 —— 它看不到别的机器
+  - 课堂那几项功能如实说明：改的是**本机** hosts、结束的是**本机**进程，
+    都是可逆的，下课后点「一键恢复全部」就还原
+  - 成品文件名从 1.8.2 更新到当前版本，并且以后发版会自动跟着改
+
+## 2.1.3
+
+- **支持「自己搭的、没有证书的中转」**（新服务器就是这种）。
+
+  中转不再是必须挂在 Cloudflare 隧道后面了。现在可以直接跑在
+  一台有公网 IP 的机器上，客户端填 `IP:端口` 就能连 —— 延迟、稳定性
+  都比隧道好得多。为此改了两处客户端：
+
+  - **手表端**：填 `yk.xxmxxs.top:13245` 这种**没写协议头**的地址时，
+    现在会按「IP / localhost / 本地域名 → 明文，域名 → 加密」来猜，
+    **和电脑端规则一致**。原来一律补成 `https://`，而那台机器没有证书，
+    结果是**永远连不上**，报的还是 SSL 错误，很容易让人白查半天证书。
+
+  - **手表端**：允许明文流量。Android 9 以上默认禁止，不加这一条的话
+    请求会被系统直接掐掉，日志里只有一句含糊的
+    「Cleartext HTTP traffic to ... not permitted」。
+
+  > 说明：中转上跑的内容（配对令牌、画面、文件）本来就是加密过的，
+  > 明文只暴露地址和设备名。想要全程加密的话，把域名解析到这台
+  > 服务器再签一张免费证书即可。
+
+- 顺手清掉了电脑端一段函数内的重复代码（`return` 之后还有一份一样的
+  拷贝，缩进仍在函数体内所以不报错，但读起来很迷惑）。
+
+## 2.1.2
+
+- **隧道稳定性加固**（继续修「网站还是容易挂」）。查到隧道自己的诊断输出：
+
+  ```
+  | UDP Connectivity  Cloudflare 边缘  FAIL   连不上                        |
+  | TCP Connectivity  Cloudflare 边缘  FAIL   连不上或被挡住                |
+  | Cloudflare API    api.cloudflare.com:443  PASS  通的                    |
+  | ERROR: Allow outbound QUIC traffic on port 7844 or use HTTP2.          |
+  ```
+
+  也就是说：**443 通，7844 不通**，而且是**一阵一阵的**
+  （过几分钟自己又好了，然后再次断）。Cloudflare 隧道的边缘连接走 7844，
+  这条线路对它是间歇性阻断 —— 这属于运营商那一侧，设备改不了。
+
+  **但可以让它自己去适应**：
+
+  - 两条隧道实例原来**各自写死一个协议**（一条只走 QUIC、一条只走 HTTP/2）。
+    那一刻如果 7844 的 UDP 和 TCP 都不通，两条一起死，没有退路。
+    现在都改成 **自动选择**，cloudflared 自己在 QUIC / HTTP/2 之间挑
+    当前能通的那条。等于所有连接都有自适应能力，而不是
+    "8 条赌 UDP、2 条赌 TCP"。
+
+  - 重试次数从 5 提到「一直重试」。原来失败 5 次就退出、靠系统重新拉起，
+    每次退出到重启之间网站都是断的；而这条线路的抖动是分钟级的，
+    5 次根本扛不过去（实测隧道每 3~10 分钟就被重启一次，公网跟着 530）。
+    现在抖动期间连接自己恢复，整条隧道不退出。
+
+  **改完实测**：连接数 7+2（接近满配 10），公网连测 5 次全部 200。
+
+- 顺手加了日志轮转（隧道日志已经涨到 3 MB，这台小机器硬盘不大）。
+
+## 2.1.1
+
+- **修一个会让网站整个挂掉的死锁**（这是「网站还是容易挂」的真因）。
+
+  在装了中转服务器的那台机器上，网络调优服务和隧道之间会互相等：
+
+  ```
+  网络调优服务（nettune）:  "我必须先于隧道启动完"
+  网络调优脚本第 4 步:      "重启隧道，让新参数生效"     ← 卡在这里
+  ```
+
+  它在**自己还没结束**的时候去重启一个「必须等自己结束才能启动」的服务，
+  系统判定成顺序冲突，那一步就永远不返回。结果网络调优一直卡在
+  「正在启动」，隧道被挡着起不来，**公网就是 530**。
+
+  实测卡了 9 分半。而且**日志里一句报错都没有**，
+  手动跑那个脚本却完全正常（那时没有顺序约束）——
+  所以特别难查，是靠这次新加的监测单元抓到的
+  （它记录到「连续 3 次不通」并把现场留了下来）。
+
+  **改法**：让脚本知道「这次是服务在调我」，那就跳过重启隧道那一步。
+  开机时本来也不需要它 —— 顺序就是调优先、隧道后，那时隧道还没起来。
+
+  > 这个坑以前一直藏着：设备上那份旧的服务定义里有一个写法错误，
+  > 导致它在更早的步骤就报错退出了，反而没走到会死锁的那一步。
+  > 把服务定义改对之后，死锁才露出来。
+
+- 另外这一版的服务端包也带上了上面那个修复。
+  **2.1.0 的服务端包是有问题的**，请用 2.1.1 重新部署。
+
+## 2.1.0
+
+- **网站挂了会自己救**：中转服务器上常驻一个监测单元，每 60 秒从**公网**
+  查一次（不是查本机 —— 本机通不代表用户能打开）。连续 3 次不通就按阶梯
+  自动抢救：
+
+  | 级 | 动作 | 代价 |
+  |---|---|---|
+  | 1 | 重启隧道 | 不动中转，在线设备不掉线 |
+  | 2 | 重启中转服务 | 设备要重连，但很快 |
+  | 3 | 重新施加网络调优 | MSS / MTU 跑偏时用 |
+  | 4 | 重启无线网卡 | 4G / WiFi 卡死时用 |
+  | 5 | 重启整机 | 最后的底牌，**默认不开** |
+
+  每做完一级立刻复验，好了就停。救完 10 分钟内不再动手（防抖 ——
+  否则预案刚重启完隧道还没连上，下一次检查又救一遍，
+  来回重启反而永远连不上）。
+
+- **网站出问题会自动留下诊断报告**：万一五级都没救回来，服务端会把现场
+  （内存、进程、隧道连接数、路由和 MTU、三份日志尾部、内核异常）
+  整理成一份 txt 留在服务端，需要排查时直接取来看就行。
+  只保留最近 30 份，不会把设备塞满。
+
+  每次自动抢救成功，也会把「第几级奏效」记进知识库，
+  下次同类问题优先试历史上管用的那一级。
+
+- **网络热门音效**：手表上新增「音效」按钮，点一下电脑就响。
+  内置 8 个（冰冰冰 / 啊哈哈哈 / 老牧师 / 叮 / 当当当 / 警报 / 鼓点 / 弹簧）。
+
+  > 说明一下**版权**：网上那些「冰冰冰」「啊哈哈哈」是有版权的真实录音，
+  > 不能打包进安装包。所以内置的是**程序合成**的版本（正弦/方波现场算），
+  > 名字对着感觉来，但不是那些录音本身。
+  > 想要一模一样的一手素材，把 mp3/wav 丢进电脑的 `data\sfx\` 目录，
+  > 点「刷新」就出现在列表里，照样能远程播。目录里放了一份说明。
+
+- **修「安卓设置页一片空白」**：设置页建好了但**忘了挂到窗口上**
+  （少了 `root.addView`），`showOnly()` 让它可见也没用 —— 它根本不在
+  视图树里。已修，并加了断言盯着「每个面板都必须挂到 root、
+  并且纳入 showOnly()」—— 这类漏挂编译不报错、只在运行时表现为空白。
+
+- **全量测试改成后台静默**：会开窗口的 6 个阶段（含开**全屏**那个）
+  现在跑在独立的 Windows 隐藏桌面上 —— 窗口是**真的**（全屏、可见、
+  几何、Win32 枚举都真实），但屏幕上什么都看不到，也不会锁你的屏。
+
+  顺带修了一个一直误判的检测：判断「锁屏」时只看 `OpenInputDesktop`
+  成不成功是不对的 —— **锁屏时它同样成功**（那时输入桌面是 Winlogon）。
+  所以截屏类测试在锁屏时被记成 FAIL 而不是 SKIP，把真问题淹掉了。
+  改成看输入桌面的**名字**。现在锁屏也能跑全量：该 SKIP 的 SKIP，
+  该跑的照跑。
+
+## 2.0.0
+
+- **安装时就能设中转服务器**：安装向导那一页现在是两个输入框 ——
+  **配对码**和**中转服务器**。装的时候是"第一次设置"，那时候最该一次
+  把地址填好，不然装完还得去双击 exe 找设置窗口，很容易漏。
+  只填域名就行（自动补 `https://`），留空 = 只走局域网。
+  批量部署同样支持：`/VERYSILENT /CODE=246810 /RELAY=relay.你的域名`
+
+- **手表端新增「设置」页**：以前设置散在首页（只有一个"中转设置"按钮），
+  现在统一收进来，在里面调：
+  - **中转服务器**（填写 / 一键清空）
+  - **记住的配对码**（显示 / 清除）
+  - **已配对的电脑**（看数量 / 清空）
+  - **关于**（版本号 + 连接顺序说明）
+
+- **中转地址改成手动填，默认留空**：以前有一版把作者的服务器地址写死成
+  默认值，第一次运行就存进了偏好设置，装新版本也不会清 ——
+  看起来就像"默认还是别人的中转站"。现在默认是空的，
+  并且会做**一次性迁移**把那个旧的内置地址清掉
+  （只清完全相等的，你自己填的不会动）。
+
+- **修「局域网连上后要推出去点设备才能控制」**：手表上有四个页面，
+  切换时靠手工藏上一页，新加的「局域网连接」页漏藏了 ——
+  所以从它连上之后控制面板其实已经显示，却被盖住看不见。
+
+- **修「双击 exe 没反应」**：装完之后双击现在会打开设置窗口。
+
+- 新增**版本号一致性检查**和**中转地址默认值检查**两道断言，
+  防止这类"漏改一处"的问题再出现。
+
+## 1.9.0
+
+- **被控端终于有设置窗口了**：装完之后双击 `ykxmz.exe` 就能打开，里面可以改
+  **配对码**、**中转服务器**、**允许新设备接入**、开机自启。
+  以前双击是"什么都不弹"，只能靠命令行参数改配置。
+
+  > 顺带修了一个很隐蔽的打包问题：PyInstaller 的 `--hidden-import` 里漏了
+  > `lanremote.ui`（设置窗口那套 tkinter 代码）。源码跑得好好的，
+  > 但**打包出来的 exe 一跑就崩**，用户看到的还是"双击没反应"。
+
+- **修「局域网连上后没反应」**：手表上有四个页面，切换时靠手工藏上一页，
+  而新加的「局域网连接」页**漏藏了** —— 所以从它连上之后，控制面板其实
+  在底下显示了，却被盖住看不见。必须"推出去点一下设备"才看到。
+  根子是"每处切换都手写一串 setVisibility"，改成统一入口 `showOnly()`，
+  以后加页面不会再漏。
+
+- **修「按一下没反应」的真因**：中转那条长轮询（最长 60 秒）和用户操作
+  共用了同一个 HTTP 连接，长轮询占着连接时操作请求发不出去，
+  线程直接死掉，之后所有操作都没反应。改成各用各的连接。
+
+- **中转地址默认留空**：需要跨网络时自己填。只在一个 WiFi 里用就什么都不用配，
+  那样手表和电脑直接连，最快也不耗流量。
+
+- 新增**版本号一致性检查**：版本号散落在 8 个地方（exe 文件属性、安装包、
+  APK、许可页…），靠脚本+人工替换很容易漏。实测就漏了两处：
+  `version_info.txt` 和许可页都还写着 1.7.1 —— 用户在"文件属性"里
+  看到一个错三个版本的号。现在有断言钉住。
+
+## 1.8.2
+
+- **下载快了几十倍**：安装包和 APK 改成由 Cloudflare 的边缘节点直接发送。
+  原来每次下载都要穿过隧道回到那台 4G 小机器上取文件，实测吞吐只有
+  3~67 KB/s，15 MB 的安装包根本下不动（还会中途断掉）。
+  现在改走边缘缓存：同一个文件实测从 **17 KB/s 提到 695 KB/s**，
+  APK 从 3 KB/s 提到 101 KB/s，并且不再消耗 4G 流量。
+
+- **跨网络连接更稳**：隧道改成**两种协议同时跑**，一共 10 条连接。
+  两种协议各有各的毛病 —— 实测这条线路上运营商对 UDP 有限制，
+  纯 QUIC 的拨号成功率只有 72%；而纯 HTTP/2 一旦丢包就容易卡住
+  （一条 TCP 上丢一个包，所有请求一起等）。
+  两个一起跑就是互相兜底：QUIC 拨号失败的那部分由 HTTP/2 顶着，
+  HTTP/2 卡住的时候 QUIC 的恢复更快。
+  实测 25 分钟连续可用率 **50/50 = 100%**（改之前是 96~98%），
+  尾部延迟 P99 从 3295ms 降到 2632ms。
+
+- 修**网卡 MTU 和 QUIC 不匹配**：之前只给 TCP 做了 MSS 钳制，
+  而 QUIC 走 UDP 完全不受保护，包一大就被中间设备悄悄丢掉。
+  把网卡 MTU 降到 1400 之后，QUIC 建齐 10 条连接的时间从
+  **28 秒缩到 12 秒**。
+
+- 修**响应头不一致**：下载接口之前对 GET 和 HEAD 报的缓存信息不一样，
+  部分下载工具（IDM、迅雷）探测时会把文件误判成不可缓存甚至空文件。
+
+- 修**偶尔闪一下"已断开"**：原来只要有一次请求失败就立刻显示离线，
+  而 4G 链路上本来就有 2~4% 的偶发失败、一两秒就自己恢复。
+  现在改成**连续失败 3 次**才判离线 —— 真的断了仍然如实显示。
+
+## 1.8.1
+
+- 修**局域网连接被中转劫持**（重要）：
+  只要「中转设置」里填了地址，点「局域网连接」填好 IP、端口、
+  配对码之后，程序**仍然走中转**，完全无视你填的局域网地址。
+  中转慢的时候要等 40 秒才报错，看起来就像"点了一点反应都没有"。
+  现在改成：局域网优先直连（6 秒超时），连不上才退回中转
+
+- 修**已配对电脑的地址过期不提示**：
+  电脑换了网络之后（比如从 192.168.2.x 换到 192.168.10.x），
+  列表里还是旧地址，点一下必然失败。现在会标出「⚠ 地址可能已过期」，
+  并且跳过注定失败的直连，直接通过中转查询最新地址
+
+- **长轮询从 15 秒延长到 60 秒**，跨网络更稳：
+  隧道每次请求要多花 1~2 秒（边缘路由 + 回源），而这个开销是按
+  **次数**收的 —— 每次都要吃一遍。拉长到 60 秒把请求数降到 1/4，
+  撞上丢包/重连窗口的概率也降到 1/4。
+  **命令响应速度不变**：有数据时立刻返回，不是等满 60 秒。
+
+- 修局域网直连成功后打出误导性日志的问题
+
 ## 1.8.0
 
 **这一版主要是「修看不见的稳定性问题」。**

_build/_adv_relay_result.txt

@@ -0,0 +1,2 @@
+passed=34 failed=0
+

_build/_adv_relay_result2.txt

@@ -0,0 +1,2 @@
+passed=18 failed=0
+

_build/_hdr_data/data/admin_password.txt

@@ -1 +0,0 @@
-@REVAedu120830

_build/_t1.txt

@@ -0,0 +1,158 @@
+============================================================
+  deploy.sh 实测
+============================================================
+  仓库:   /c/Users/shu/Desktop/deepseekagent/LanRemote
+  脚本:   /c/Users/shu/Desktop/deepseekagent/LanRemote/relay/deploy.sh
+
+── 1. 语法检查（bash -n）──
+    [PASS] deploy.sh 语法正确
+    [PASS] deploy-tune.sh 语法正确
+
+── 2. 换行符 / BOM（.sh 必须 LF + 无 BOM）──
+    [PASS] deploy.sh 是 LF 且无 BOM
+    [PASS] deploy-tune.sh 是 LF 且无 BOM
+
+── 3. --help ──
+    [PASS] --help 退出码为 0
+    [PASS] --help 有「用法」段
+    [PASS] --help 列出了 --prefix
+    [PASS] --help 提到了 TUNNEL_TOKEN
+    [PASS] --help 没有副作用
+
+── 3b. 非法参数要报错退出 ──
+    [PASS] 未知参数退出码为 2
+    [PASS] 非法协议退出码为 2
+
+── 4. 搭沙箱（桩命令 + 临时安装根）──
+  沙箱:   /tmp/tmp.jb8lwoeXgw
+  安装根: /tmp/tmp.jb8lwoeXgw/root
+  桩命令: cloudflared curl free getent ip iptables nmcli python3 systemctl 
+
+── 5. 第一次部署（--skip-tunnel，不碰隧道）──
+    [PASS] 第一次退出码为 0
+    [PASS] relay.py 已部署
+    [PASS] admin.py 已部署
+    [PASS] landing.py 已部署
+    [PASS] showcase.py 已部署
+    [PASS] favicon.ico 已部署
+    [PASS] deploy-tune.sh 已部署
+    [PASS] watchdog.sh 已部署
+    [PASS] site_shots 已部署
+    [PASS] data 目录已建
+    [PASS] downloads 目录已建
+    [PASS] lanremote-relay.service 已生成
+    [PASS] lanremote-nettune.service 已生成
+    [PASS] lanremote-tunnel.service 已生成
+    [PASS] 备用 http2 单元已生成
+    [PASS] 看门狗 timer 已生成
+
+     生成的 relay unit 里应该有的关键项:
+    [PASS] relay unit 含 RELAY_POLL=60
+    [PASS] relay unit 含 RELAY_PORT=8080
+    [PASS] relay unit 含 python3
+
+     两个隧道单元的内容（默认主 quic+8 / 副本 http2+2）:
+    [PASS] 主隧道单元用 quic
+    [PASS] 主隧道 8 条连接（实测最优配比）
+    [PASS] 副本隧道单元用 http2
+    [PASS] 副本隧道 2 条连接（实测最优配比）
+    [PASS] 主隧道 metrics 钉死 20241
+    [PASS] 副本隧道 metrics 钉死 20242
+    [PASS] nettune 只有一个入口脚本
+    [PASS] unit 里没有明文 Token
+    [PASS] 便捷命令 lanremote-url 已生成
+    [PASS] 便捷命令 lanremote-key 已生成
+    [PASS] 便捷命令 lanremote-status 已生成
+
+── 6. 幂等性：放几个「不许被冲掉」的东西，再跑第二遍 ──
+    [PASS] 第二次退出码为 0
+    [PASS] 设备数据没被冲掉
+    [PASS] 管理钥匙没被冲掉
+    [PASS] 管理密码没被冲掉
+    [PASS] 公网地址没被冲掉
+    [PASS] relay_state.json 没被改（allowNew 保住了）
+    [PASS] allowNew 仍然是 false（没被拨回 true）
+    [PASS] 手工 config.yml 没被覆盖
+    [PASS] relay.py 内容稳定
+    [PASS] 第二遍没有新增 ✗ 错误
+
+── 6b. 没变化时不该重启服务（别打断在线连接）──
+    [PASS] 第二遍没有重启中转（无变化）
+    [PASS] 第二遍没有重启隧道（无变化）
+    [PASS] 第二遍没有多余的 daemon-reload
+    [PASS] 输出里明确说了「内容没变、保持运行」
+
+── 7. 凭据模式：给出域名时要能生成 config.yml ──
+    [PASS] 凭据模式退出码为 0
+    [PASS] config.yml 已生成
+    [PASS] config.yml 里的隧道 ID 取自凭据文件名
+    [PASS] config.yml 写入了域名
+    [PASS] config.yml 有兜底 404 规则（没有它 cloudflared 起不来）
+    [PASS] config.yml 指向本地中转端口
+
+── 7c. 默认：两个隧道单元都要启用（协议级故障隔离）──
+    [PASS] 默认（不传 --protocol）退出码为 0
+    [PASS] 默认启用了主隧道
+    [PASS] 默认启用了副本隧道
+    [PASS] 默认没有关掉任何一个隧道
+
+── 7d. --protocol quic：只跑主隧道 ──
+    [PASS] --protocol quic 退出码为 0
+    [PASS] quic 模式启用了主隧道
+    [PASS] quic 模式停用了副本隧道
+    [PASS] 输出说明了为什么停用副本
+
+── 7e. --protocol http2：只跑副本隧道 ──
+    [PASS] --protocol http2 退出码为 0
+    [PASS] http2 模式启用了副本隧道
+    [PASS] http2 模式停用了主隧道
+
+── 7f. --protocol 的非法值要报错 ──
+    [PASS] 非法协议退出码为 2
+    [PASS] both 是合法值
+
+── 7b. 再跑一次（不给 --hostname），config.yml 不该被改 ──
+    [PASS] 再次运行退出码为 0
+    [PASS] 没给 --hostname 时 config.yml 保持不变
+
+── 8. Token 模式 ──
+    [PASS] Token 模式退出码为 0
+    [PASS] Token 写进了 tunnel.env
+    [PASS] tunnel.env 内容正确
+    [PASS] unit 里没有明文 Token（只有 EnvironmentFile 引用）
+    [PASS] unit 用了 EnvironmentFile 读 Token
+    [PASS] unit 的 ExecStart 里用 --token ${TUNNEL_TOKEN}
+
+── 8b. tunnel.env 权限应该是 600 ──
+      tunnel.env 权限: 644（Linux 上应为 600）
+
+── 9. 缺文件时要明确报错，不能静默 ──
+    [PASS] 文件不全时明确失败（退出码 1）
+    [PASS] 报错信息说清了是「程序文件不全」
+
+── 10. 桩命令确实被调用过（证明流程真的走了）──
+    [PASS] 调用过 systemctl enable
+    [PASS] 调用过 iptables
+    [PASS] 第一次安装做了 daemon-reload
+
+── 11. 脚本里不许有写死的域名 ──
+    [PASS] deploy.sh 里没有写死的域名
+    [PASS] deploy-tune.sh 里没有写死的域名
+    [PASS] net-tune.sh 里没有写死的域名
+    [PASS] 示例用的是「你的域名」占位符
+
+── 12. 有凭据但没给域名 → 不许乱猜，必须明确提示 ──
+     [调试] TMP=/tmp/tmp.jb8lwoeXgw
+     [调试] 凭据目录内容: deadbeef-0000-1111-2222-333344445555.json 
+    [PASS] 没域名时退出码为 0（中转照装，只是隧道不启）
+    [PASS] 没域名时没有生成 config.yml（没有乱猜）
+    [PASS] 明确提示了「需要你提供公网域名」
+    [PASS] 提示里给了怎么补域名
+    [PASS] 提示里给了 Token 模式这个替代办法
+    [PASS] 隧道没配好时没有去启动它
+    [PASS] 中转仍然正常安装并启用
+
+============================================================
+  结果: 通过 98 项，失败 0 项
+============================================================
+  沙箱目录（想自己看就留着）: /tmp/tmp.jb8lwoeXgw

_build/_unit.txt

@@ -1,16 +0,0 @@
-[Unit]
-Description=LanRemote Cloudflare 具名隧道
-After=network-online.target lanremote-relay.service
-Wants=network-online.target lanremote-relay.service
-
-[Service]
-Type=simple
-ExecStart=/usr/local/bin/cloudflared tunnel --no-autoupdate --protocol http2 --edge-ip-version 4 --ha-connections 1 --retries 5 --config /root/.cloudflared/config.yml run lanremote
-Restart=always
-RestartSec=5
-MemoryMax=128M
-StandardOutput=append:/root/lanremote-relay/tunnel.log
-StandardError=append:/root/lanremote-relay/tunnel.log
-
-[Install]
-WantedBy=multi-user.target

_build/ab_quic.sh

@@ -0,0 +1,178 @@
+#!/bin/bash
+# quic+6 vs http2+4：用**真实长轮询**对照，方法完全一致。
+#
+# 为什么必须用长轮询测：
+#   之前用 /v1/health 那种"每次新建连接"的方式测，
+#   量到的是冷启动开销，和真实业务（复用连接的长轮询）差很多。
+#   而且那种方式会看到 18 秒的尾巴 —— 长轮询完全没有。
+#
+# 为什么这次结果可信：
+#   上一轮 A/B 里 quic 那组因为**两次探针用了同一个配对码**，
+#   第二次注册被"一个码只能一台设备"规则拒掉，token 拿到空的，
+#   8 次全 401 —— 那一轮数据作废。这次每个探针都用唯一的新码。
+#
+# 为什么值得测 QUIC：
+#   刚才查出来：隧道连接 30 分钟 0 掉线、0 重连，很稳；
+#   但请求级偶发 000（10 分钟 6 次）。
+#   这是 HTTP/2 over TCP 的**队头阻塞** ——
+#   一条 TCP 上丢一个包，那条连接上所有流一起卡。
+#   QUIC 每个流独立恢复，理论上正好治这个。
+set -u
+
+PUB=https://relay.xxmxxs.top
+UA='LanRemote/1.8.1'
+SVC=/etc/systemd/system/lanremote-tunnel.service
+BACKUP=/root/lanremote-tunnel.service.bak.q.$(date +%s)
+cp -a "$SVC" "$BACKUP"
+ROUNDS=${1:-10}
+
+set_params() {
+    local proto="$1" conns="$2"
+    if grep -q -- '--protocol' "$SVC"; then
+        sed -i "s/--protocol [a-z0-9]*/--protocol $proto/" "$SVC"
+    else
+        sed -i "s|\(ExecStart=.*cloudflared tunnel\)|\1 --protocol $proto|" "$SVC"
+    fi
+    if grep -q -- '--ha-connections' "$SVC"; then
+        sed -i "s/--ha-connections [0-9]*/--ha-connections $conns/" "$SVC"
+    else
+        sed -i "s|\(ExecStart=.*cloudflared tunnel\)|\1 --ha-connections $conns|" "$SVC"
+    fi
+    systemctl daemon-reload
+    systemctl restart lanremote-tunnel
+}
+
+wait_ready() {
+    local want="$1"
+    for i in $(seq 1 30); do
+        sleep 5
+        n=$(curl -s --max-time 4 http://127.0.0.1:20241/metrics 2>/dev/null \
+            | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}')
+        [ "${n:-0}" -ge "$want" ] && return 0
+    done
+    return 1
+}
+
+new_probe() {
+    # 每次都用全新的 deviceId + 全新的配对码，避免被"一码一机"拒掉
+    local stamp
+    stamp=$(date +%s%N | cut -c1-13)
+    local dev="qprobe-${stamp}"
+    local code
+    code=$(printf "%06d" $(( (stamp / 7) % 1000000 )))
+    local reg
+    reg=$(curl -s --max-time 30 -X POST "$PUB/v1/agent/register" \
+          -H 'Content-Type: application/json' -H "User-Agent: $UA" \
+          -d "{\"deviceId\":\"$dev\",\"code\":\"$code\",\"name\":\"qprobe\",\"version\":\"1.8.1\"}")
+    local tok
+    tok=$(echo "$reg" | python3 -c "import sys,json; print(json.load(sys.stdin).get('token',''))" 2>/dev/null)
+    PROBE_DEV="$dev"
+    PROBE_TOK="$tok"
+    PROBE_CODE="$code"
+}
+
+cleanup_probe() {
+    local key
+    key=$(cat /root/lanremote-relay/data/admin_key.txt 2>/dev/null)
+    [ -n "${PROBE_DEV:-}" ] && curl -s --max-time 20 -X POST \
+        "http://127.0.0.1:8080/v1/admin/delete" -H "X-Admin: $key" \
+        -H 'Content-Type: application/json' \
+        -d "{\"deviceId\":\"$PROBE_DEV\"}" > /dev/null 2>&1
+}
+
+run_round() {
+    local label="$1" proto="$2" conns="$3"
+
+    echo "════════ $label ════════"
+    set_params "$proto" "$conns"
+    if wait_ready "$conns"; then
+        echo "  连接就绪（$(curl -s --max-time 4 http://127.0.0.1:20241/metrics 2>/dev/null | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}') 条）"
+    else
+        echo "  ! 连接没建齐，仍然继续测"
+    fi
+    echo "  落点:"
+    curl -s --max-time 5 http://127.0.0.1:20241/metrics 2>/dev/null \
+        | grep 'server_locations.*} 1' | sed 's/^/    /'
+    sleep 15
+
+    new_probe
+    if [ -z "${PROBE_TOK:-}" ]; then
+        echo "  [失败] 探针注册没拿到 token，这轮作废"
+        echo "$label|REGFAIL|0|0|0" >> /tmp/qab.txt
+        return 1
+    fi
+    echo "  探针 code=$PROBE_CODE token=${#PROBE_TOK} 字符"
+
+    local mark
+    mark=$(wc -l < /root/lanremote-relay/tunnel.log 2>/dev/null || echo 0)
+    local ok=0 fail=0 times=() fails=""
+    for i in $(seq 1 "$ROUNDS"); do
+        out=$(curl -s -o /dev/null -w '%{http_code} %{time_total}' --max-time 100 \
+              -X POST "$PUB/v1/agent/poll" -H "X-Token: $PROBE_TOK" \
+              -H "User-Agent: $UA")
+        code=$(echo "$out" | awk '{print $1}')
+        ms=$(echo "$out" | awk '{printf "%d", $2*1000}')
+        if [ "$code" = "200" ]; then
+            ok=$((ok+1)); times+=("$ms")
+            printf "  %2d: 200  %6dms\n" "$i" "$ms"
+        else
+            fail=$((fail+1)); fails="$fails ${i}:${code}"
+            printf "  %2d: %-4s **失败**\n" "$i" "$code"
+        fi
+    done
+
+    local stats
+    if [ "${#times[@]}" -gt 0 ]; then
+        stats=$(printf '%s\n' "${times[@]}" | sort -n | awk '{a[NR]=$1} END {
+            printf "中位 %d  P90 %d  最大 %d", a[int(NR/2)+1], a[int(NR*0.9)+1], a[NR]}')
+    else
+        stats="无数据"
+    fi
+
+    local reconn
+    reconn=$(tail -n +$((mark+1)) /root/lanremote-relay/tunnel.log 2>/dev/null \
+             | grep -c 'Registered tunnel connection' || echo 0)
+
+    echo "  == $ok/$ROUNDS 成功   耗时: $stats ms   本轮重连 $reconn 次"
+    echo "     失败:$fails"
+    echo "$label|$ok|$ROUNDS|$((ok*100/ROUNDS))|$stats|$reconn" >> /tmp/qab.txt
+    cleanup_probe
+    echo
+}
+
+rm -f /tmp/qab.txt
+
+# 先基线，再候选 —— 同一网络条件下先后测，尽量公平
+run_round "http2+4" http2 4 || true
+run_round "quic+6"  quic  6 || true
+
+echo "════════ 汇总 ════════"
+printf "  %-10s %-10s %-8s %-32s %s\n" "配置" "成功" "可用率" "耗时" "本轮重连"
+while IFS='|' read -r label ok total pct stats reconn; do
+    if [ "$ok" = "REGFAIL" ]; then
+        printf "  %-10s 探针注册失败，作废\n" "$label"
+    else
+        printf "  %-10s %-10s %-8s %-32s %s\n" "$label" "$ok/$total" "${pct}%" "$stats" "$reconn"
+    fi
+done < /tmp/qab.txt
+
+echo
+echo "════════ 决策 ════════"
+B_OK=$(grep '^http2+4' /tmp/qab.txt | cut -d'|' -f4)
+Q_OK=$(grep '^quic+6' /tmp/qab.txt | cut -d'|' -f4)
+B_REC=$(grep '^http2+4' /tmp/qab.txt | cut -d'|' -f6)
+Q_REC=$(grep '^quic+6' /tmp/qab.txt | cut -d'|' -f6)
+echo "  基线: 可用率 ${B_OK:-?}%  重连 ${B_REC:-?}"
+echo "  候选: 可用率 ${Q_OK:-?}%  重连 ${Q_REC:-?}"
+if [ "${Q_OK:-0}" -ge "${B_OK:-0}" ] && [ "${Q_OK:-0}" -ge 90 ]; then
+    echo "  → 采用 quic+6"
+else
+    echo "  → 保留 http2+4"
+    cp -a "$BACKUP" "$SVC"
+    systemctl daemon-reload
+    systemctl restart lanremote-tunnel
+fi
+sleep 15
+echo
+echo "  最终参数: $(grep -oE '\-\-protocol [a-z0-9]+|--ha-connections [0-9]+' "$SVC" | tr '\n' ' ')"
+echo "  备份: $BACKUP"

_build/ab_tcp.sh

@@ -0,0 +1,127 @@
+#!/bin/bash
+# TCP 重传调优的受控 A/B。
+#
+# 背景（实测）：
+#   TCPTimeouts: 3145 · TCPLostRetransmit: 2010
+#   这些多秒/多分钟的尾巴全是 TCP 重传超时造成的。
+#   这台机器内核是定制的，**没有 BBR**（只有 reno/cubic），
+#   也没有任何替代 qdisc（只有 noqueue），所以只能在
+#   现有 cubic 上调 TCP 的重传行为。
+#
+# 三个候选开关（都对症"细流 + 高丢包"这个场景）：
+#   tcp_thin_linear_timeouts  细流不搞 RTO 指数退避，重传来得更快
+#   tcp_fack                  前向确认，丢包恢复更积极
+#   tcp_retries2              重传几次就放弃（8 太大，卡十几分钟）
+#
+# 每轮：设参数 -> 打 60 次 HTTP -> 记录成功率/耗时分布 -> 下一轮
+# 全部跑完回滚，最后按数据决定采用哪组。
+set -u
+
+BASE=https://relay.xxmxxs.top
+UA='LanRemote/1.8.1'
+N=60
+
+# 保存原始值，跑完恢复
+declare -A ORIG
+for k in tcp_thin_linear_timeouts tcp_fack tcp_retries2 tcp_autocorking; do
+    ORIG[$k]=$(sysctl -n net.ipv4.$k 2>/dev/null || echo "")
+done
+
+restore() {
+    for k in "${!ORIG[@]}"; do
+        [ -n "${ORIG[$k]}" ] && sysctl -qw net.ipv4.$k="${ORIG[$k]}" 2>/dev/null || true
+    done
+}
+
+measure() {
+    local label="$1"
+    local ok=0 fail=0 times=()
+    for i in $(seq 1 "$N"); do
+        out=$(curl -s -o /dev/null -w '%{http_code} %{time_total}' --max-time 25 \
+              -H "User-Agent: $UA" "$BASE/v1/health")
+        c=$(echo "$out" | awk '{print $1}')
+        ms=$(echo "$out" | awk '{printf "%d", $2*1000}')
+        if [ "$c" = "200" ]; then ok=$((ok+1)); times+=("$ms"); else fail=$((fail+1)); fi
+    done
+    local pct=$((ok * 100 / N))
+    local stats="无数据"
+    if [ "${#times[@]}" -gt 0 ]; then
+        stats=$(printf '%s\n' "${times[@]}" | sort -n | awk '{a[NR]=$1} END {
+            printf "中位 %d  P90 %d  P99 %d  最大 %d", a[int(NR/2)+1], a[int(NR*0.9)+1], a[int(NR*0.99)+1], a[NR]}')
+    fi
+    printf "  %-34s %3d%% (%d/%d)  %s ms\n" "$label" "$pct" "$ok" "$N" "$stats"
+    echo "$label|$pct|$ok|$stats" >> /tmp/tcpab.txt
+}
+
+rm -f /tmp/tcpab.txt
+
+echo "════════ 原始值 ════════"
+for k in "${!ORIG[@]}"; do printf "  %-30s = %s\n" "$k" "${ORIG[$k]}"; done
+echo
+
+echo "════════ 各组合实测（每轮 $N 次）════════"
+
+echo "  [1/6] 基线（不改）"
+measure "基线"
+
+echo "  [2/6] thin_linear_timeouts=1"
+sysctl -qw net.ipv4.tcp_thin_linear_timeouts=1
+measure "thin=1"
+
+echo "  [3/6] thin=1 + fack=1"
+sysctl -qw net.ipv4.tcp_fack=1
+measure "thin=1 fack=1"
+
+echo "  [4/6] thin=1 fack=1 + retries2=5"
+sysctl -qw net.ipv4.tcp_retries2=5
+measure "thin=1 fack=1 retries2=5"
+
+echo "  [5/6] thin=1 fack=1 retries2=5 + autocorking=0"
+sysctl -qw net.ipv4.tcp_autocorking=0
+measure "全部开启"
+
+echo "  [6/6] 回滚到基线再测一次（排除时间漂移）"
+restore
+measure "回滚后基线"
+
+echo
+echo "════════ 汇总（按可用率排序）════════"
+sort -t'|' -k2 -rn /tmp/tcpab.txt | while IFS='|' read -r label pct ok stats; do
+    printf "  %-34s %3s%%   %s\n" "$label" "$pct" "$stats"
+done
+
+echo
+echo "════════ 按数据决定 ════════"
+BEST=$(sort -t'|' -k2 -rn /tmp/tcpab.txt | head -1)
+BEST_LABEL=$(echo "$BEST" | cut -d'|' -f1)
+BEST_PCT=$(echo "$BEST" | cut -d'|' -f2)
+echo "  最好的是: $BEST_LABEL ($BEST_PCT%)"
+
+case "$BEST_LABEL" in
+    "基线"|"回滚后基线")
+        echo "  → 调优没有收益，保持默认（只留已验证过的 keepalive 那几项）"
+        restore
+        ;;
+    "thin=1")
+        sysctl -qw net.ipv4.tcp_thin_linear_timeouts=1
+        echo "  → 只启用 thin_linear_timeouts"
+        ;;
+    "thin=1 fack=1")
+        sysctl -qw net.ipv4.tcp_thin_linear_timeouts=1
+        sysctl -qw net.ipv4.tcp_fack=1
+        echo "  → 启用 thin_linear_timeouts + fack"
+        ;;
+    *)
+        sysctl -qw net.ipv4.tcp_thin_linear_timeouts=1
+        sysctl -qw net.ipv4.tcp_fack=1
+        sysctl -qw net.ipv4.tcp_retries2=5
+        sysctl -qw net.ipv4.tcp_autocorking=0
+        echo "  → 全部启用"
+        ;;
+esac
+
+echo
+echo "  当前生效值:"
+for k in tcp_thin_linear_timeouts tcp_fack tcp_retries2 tcp_autocorking; do
+    printf "    %-30s = %s\n" "$k" "$(sysctl -n net.ipv4.$k 2>/dev/null)"
+done

_build/ab_tunnel.sh

@@ -0,0 +1,107 @@
+#!/bin/bash
+# 受控 A/B：隧道协议和连接数，哪个在"稳 + 快"上更好。
+#
+# 背景：
+#   实测隧道大多稳（12/12），但每个请求稳定吃 ~1100ms 回源延迟。
+#   而且日志里 i/o timeout 不少（最近 800 行 104 次），
+#   说明有些 edge IP 连得很差（实测最慢那个 1331ms，最快的 146ms）。
+#
+#   假定：连接数多一些，撞上"慢 IP"的窗口就小一些。
+#   QUIC 在多丢包下恢复更好（没有跨流的队头阻塞），但之前测
+#   "http2 比 quic 稳" —— 那是连接建立阶段的观感，这次量真实请求。
+#
+# 组合：
+#   http2 + 4   （当前配置，基线）
+#   http2 + 6
+#   quic  + 4
+#   quic  + 6
+#
+# 每个组合：重启隧道 -> 等连接建齐 -> 打 20 次 -> 记录
+#   成功率 / 中位耗时 / P90 / 连接数
+set -u
+
+URL=https://relay.xxmxxs.top/v1/health
+UA='LanRemote/1.8.0'
+SVC=/etc/systemd/system/lanremote-tunnel.service
+BACKUP=/root/lanremote-tunnel.service.bak.$(date +%s)
+cp -a "$SVC" "$BACKUP"
+
+echo "  备份: $BACKUP"
+echo "  原参数:"
+grep -A3 'ExecStart' "$SVC" | grep -E 'protocol|ha-connections|edge-ip' | sed 's/^/    /'
+echo
+
+run_combo() {
+    local proto="$1" conns="$2" label="$3"
+
+    echo "════════ $label ════════"
+    # 改参数
+    if grep -q '\-\-protocol' "$SVC"; then
+        sed -i "s/--protocol [a-z0-9]*/--protocol $proto/" "$SVC"
+    else
+        sed -i "s|\(ExecStart=.*cloudflared tunnel\)|\1 --protocol $proto|" "$SVC"
+    fi
+    if grep -q '\-\-ha-connections' "$SVC"; then
+        sed -i "s/--ha-connections [0-9]*/--ha-connections $conns/" "$SVC"
+    else
+        sed -i "s|\(ExecStart=.*cloudflared tunnel\)|\1 --ha-connections $conns|" "$SVC"
+    fi
+    grep -oE '\-\-protocol [a-z0-9]+|--ha-connections [0-9]+' "$SVC" | tr '\n' ' ' | sed 's/^/  参数: /'
+    echo
+
+    systemctl daemon-reload
+    systemctl restart lanremote-tunnel
+
+    # 等连接建齐
+    built=0
+    for i in $(seq 1 24); do
+        sleep 5
+        n=$(curl -s --max-time 4 http://127.0.0.1:20241/metrics 2>/dev/null \
+            | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}')
+        if [ "${n:-0}" -ge "$conns" ]; then built="$n"; break; fi
+    done
+    echo "  连接建齐: ${built:-0}/$conns（等了 ${i}0 秒）"
+
+    # 预热几次，跳过建连阶段的冷启动
+    for i in 1 2 3; do curl -s -o /dev/null --max-time 20 -H "User-Agent: $UA" "$URL"; sleep 1; done
+
+    # 正式测
+    ok=0; times=()
+    for i in $(seq 1 20); do
+        out=$(curl -s -o /dev/null -w '%{http_code} %{time_total}' --max-time 30 -H "User-Agent: $UA" "$URL")
+        code=$(echo "$out" | awk '{print $1}')
+        ms=$(echo "$out" | awk '{printf "%d", $2*1000}')
+        times+=("$ms")
+        [ "$code" = "200" ] && ok=$((ok+1))
+        sleep 1
+    done
+
+    stats=$(printf '%s\n' "${times[@]}" | sort -n | awk '{a[NR]=$1} END {
+        p90 = a[int(NR*0.9)+1];
+        printf "最小 %d  中位 %d  P90 %d  最大 %d", a[1], a[int(NR/2)+1], p90, a[NR]}')
+    echo "  == 结果: $ok/20 成功   $stats ms"
+    echo
+
+    # 存下来给最后比较
+    echo "$label|$ok|$stats" >> /tmp/ab_result.txt
+}
+
+rm -f /tmp/ab_result.txt
+
+run_combo http2 4 "A. http2 + 4（基线，当前配置）"
+run_combo http2 6 "B. http2 + 6"
+run_combo quic  4 "C. quic + 4"
+run_combo quic  6 "D. quic + 6"
+
+echo "════════ 汇总 ════════"
+cat /tmp/ab_result.txt | sed 's/^/  /'
+
+echo
+echo "════════ 回滚到基线（http2 + 4），等后面按结果再定 ════════"
+cp -a "$BACKUP" "$SVC"
+systemctl daemon-reload
+systemctl restart lanremote-tunnel
+sleep 20
+echo "  已回滚。当前参数:"
+grep -oE '\-\-protocol [a-z0-9]+|--ha-connections [0-9]+' "$SVC" | sed 's/^/    /'
+echo "  连接数: $(curl -s --max-time 5 http://127.0.0.1:20241/metrics 2>/dev/null | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}')"

_build/ab_tunnel_long.sh

@@ -0,0 +1,127 @@
+#!/bin/bash
+# 长时间对照：http2+4（基线） vs quic+6（候选）。
+#
+# 为什么要跑长的：
+#   短测（20 次）看不出稳定性。而且历史上出过一次"QUIC 可用率 48%"，
+#   和这次短测的 20/20 矛盾 —— 必须用足够长的样本、并且**同时**记录
+#   连接数波动和重连次数，才能判断到底是协议问题还是当时的网络问题。
+#
+# 每轮 5 分钟，每 3 秒一次请求（约 100 个样本），记录：
+#   成功率 / 中位 / P90 / 最大 / 连接数最低值 / 连接的落点
+set -u
+
+URL=https://relay.xxmxxs.top/v1/health
+UA='LanRemote/1.8.0'
+SVC=/etc/systemd/system/lanremote-tunnel.service
+BACKUP=/root/lanremote-tunnel.service.bak.long.$(date +%s)
+cp -a "$SVC" "$BACKUP"
+
+DURATION=300          # 每轮 5 分钟
+INTERVAL=3            # 每 3 秒一次
+
+set_params() {
+    local proto="$1" conns="$2"
+    if grep -q -- '--protocol' "$SVC"; then
+        sed -i "s/--protocol [a-z0-9]*/--protocol $proto/" "$SVC"
+    else
+        sed -i "s|\(ExecStart=.*cloudflared tunnel\)|\1 --protocol $proto|" "$SVC"
+    fi
+    if grep -q -- '--ha-connections' "$SVC"; then
+        sed -i "s/--ha-connections [0-9]*/--ha-connections $conns/" "$SVC"
+    else
+        sed -i "s|\(ExecStart=.*cloudflared tunnel\)|\1 --ha-connections $conns|" "$SVC"
+    fi
+    systemctl daemon-reload
+    systemctl restart lanremote-tunnel
+}
+
+wait_ready() {
+    local want="$1"
+    for i in $(seq 1 30); do
+        sleep 5
+        n=$(curl -s --max-time 4 http://127.0.0.1:20241/metrics 2>/dev/null \
+            | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}')
+        if [ "${n:-0}" -ge "$want" ]; then
+            return 0
+        fi
+    done
+    return 1
+}
+
+measure() {
+    local label="$1"
+    local ok=0 fail=0 times=() minconn=99 reconnects=0
+    local start=$(date +%s)
+    local logmark=$(wc -l < /root/lanremote-relay/tunnel.log 2>/dev/null || echo 0)
+
+    echo "  ── $label：跑 ${DURATION} 秒，每 ${INTERVAL} 秒一次 ──"
+    while [ $(( $(date +%s) - start )) -lt "$DURATION" ]; do
+        out=$(curl -s -o /dev/null -w '%{http_code} %{time_total}' --max-time 30 -H "User-Agent: $UA" "$URL")
+        code=$(echo "$out" | awk '{print $1}')
+        ms=$(echo "$out" | awk '{printf "%d", $2*1000}')
+        if [ "$code" = "200" ]; then
+            ok=$((ok+1)); times+=("$ms")
+        else
+            fail=$((fail+1))
+        fi
+        n=$(curl -s --max-time 3 http://127.0.0.1:20241/metrics 2>/dev/null \
+            | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}')
+        [ -n "${n:-}" ] && [ "$n" -lt "$minconn" ] && minconn="$n"
+        sleep "$INTERVAL"
+    done
+
+    # 这一轮新注册了多少次（= 重连次数）
+    nowmark=$(wc -l < /root/lanremote-relay/tunnel.log 2>/dev/null || echo 0)
+    reconnects=$(tail -n +$((logmark+1)) /root/lanremote-relay/tunnel.log 2>/dev/null \
+                 | grep -c 'Registered tunnel connection' || echo 0)
+
+    total=$((ok+fail))
+    pct=0; [ "$total" -gt 0 ] && pct=$((ok * 100 / total))
+    stats=$(printf '%s\n' "${times[@]:-0}" | sort -n | awk '{a[NR]=$1} END {
+        if (NR==0) { print "无数据"; exit }
+        printf "中位 %d  P90 %d  最大 %d", a[int(NR/2)+1], a[int(NR*0.9)+1], a[NR]}')
+
+    echo "  == 结果: $ok/$total = ${pct}%   $stats ms"
+    echo "     连接数最低 $minconn   本轮重连 $reconnects 次"
+    echo "$label|$ok|$total|$pct|$stats|$minconn|$reconnects" >> /tmp/longab.txt
+    echo
+}
+
+rm -f /tmp/longab.txt
+
+echo "════════ 第一轮：http2 + 4（基线）════════"
+set_params http2 4
+wait_ready 4 && echo "  连接就绪" || echo "  ! 连接没建齐，继续测"
+sleep 10
+measure "http2+4"
+
+echo "════════ 第二轮：quic + 6（候选）════════"
+set_params quic 6
+wait_ready 6 && echo "  连接就绪" || echo "  ! 连接没建齐，继续测"
+sleep 10
+measure "quic+6"
+
+echo "════════ 汇总 ════════"
+printf "  %-12s %-14s %-10s %-22s %-10s %s\n" "配置" "成功" "可用率" "延迟" "连接最低" "重连"
+while IFS='|' read -r label ok total pct stats minconn reconnects; do
+    printf "  %-12s %-14s %-10s %-22s %-10s %s\n" "$label" "$ok/$total" "${pct}%" "$stats" "$minconn" "$reconnects"
+done < /tmp/longab.txt
+
+echo
+echo "════════ 按结果决定是否改配置 ════════"
+BASE_PCT=$(grep '^http2+4' /tmp/longab.txt | cut -d'|' -f4)
+QUIC_PCT=$(grep '^quic+6' /tmp/longab.txt | cut -d'|' -f4)
+if [ "${QUIC_PCT:-0}" -ge "${BASE_PCT:-0}" ] && [ "${QUIC_PCT:-0}" -ge 90 ]; then
+    echo "  → quic+6 可用率 ${QUIC_PCT}% >= 基线 ${BASE_PCT}%，保留 quic+6"
+    grep -oE '\-\-protocol [a-z0-9]+|--ha-connections [0-9]+' "$SVC" | sed 's/^/    /'
+else
+    echo "  → quic+6 可用率 ${QUIC_PCT}% 不如基线 ${BASE_PCT}%，回滚"
+    cp -a "$BACKUP" "$SVC"
+    systemctl daemon-reload
+    systemctl restart lanremote-tunnel
+    sleep 20
+    grep -oE '\-\-protocol [a-z0-9]+|--ha-connections [0-9]+' "$SVC" | sed 's/^/    /'
+fi
+echo
+echo "  当前连接数: $(curl -s --max-time 5 http://127.0.0.1:20241/metrics 2>/dev/null | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}')"
+echo "  备份: $BACKUP"

_build/ab_v2.sh

@@ -0,0 +1,150 @@
+#!/bin/bash
+# 严谨对照 v2：http2+4 vs quic+6，用**真实的长轮询模式**测。
+#
+# v1 的问题：
+#   * 只跑 5 分钟、每 3 秒一个新连接 —— 那是"冷启动"模式，
+#     而真实业务是**长轮询复用同一条连接**，两者差别很大。
+#   * 判定规则太粗（98% vs 100% 就回滚），
+#     忽略了 P90 从 16.8 秒改善到 2.8 秒这个数量级的差异。
+#
+# v2 的做法：
+#   * 用 curl 一次给多个 URL —— 复用同一条连接，贴近长轮询
+#   * 每轮 10 分钟
+#   * 记录 成功率 / 中位 / P90 / P99 / 最大 / 失败时刻
+#   * 用真实的长轮询接口 /v1/agent/poll（挂 60 秒），
+#     量"一次完整长轮询"的耗时分布 —— 这才是用户真正经历的
+set -u
+
+UA='LanRemote/1.8.0'
+PUB=https://relay.xxmxxs.top
+SVC=/etc/systemd/system/lanremote-tunnel.service
+BACKUP=/root/lanremote-tunnel.service.bak.v2.$(date +%s)
+cp -a "$SVC" "$BACKUP"
+
+set_params() {
+    local proto="$1" conns="$2"
+    if grep -q -- '--protocol' "$SVC"; then
+        sed -i "s/--protocol [a-z0-9]*/--protocol $proto/" "$SVC"
+    else
+        sed -i "s|\(ExecStart=.*cloudflared tunnel\)|\1 --protocol $proto|" "$SVC"
+    fi
+    if grep -q -- '--ha-connections' "$SVC"; then
+        sed -i "s/--ha-connections [0-9]*/--ha-connections $conns/" "$SVC"
+    else
+        sed -i "s|\(ExecStart=.*cloudflared tunnel\)|\1 --ha-connections $conns|" "$SVC"
+    fi
+    systemctl daemon-reload
+    systemctl restart lanremote-tunnel
+}
+
+wait_ready() {
+    local want="$1"
+    for i in $(seq 1 30); do
+        sleep 5
+        n=$(curl -s --max-time 4 http://127.0.0.1:20241/metrics 2>/dev/null \
+            | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}')
+        [ "${n:-0}" -ge "$want" ] && return 0
+    done
+    return 1
+}
+
+# ---- 用真实长轮询接口测 ----
+# 注册一台探针设备，poll 会挂 60 秒再返回（没有数据时）
+probe_device() {
+    DEV="probev2-$(date +%s)"
+    REG=$(curl -s --max-time 30 -X POST "$PUB/v1/agent/register" \
+          -H 'Content-Type: application/json' -H "User-Agent: $UA" \
+          -d "{\"deviceId\":\"$DEV\",\"code\":\"777777\",\"name\":\"probev2\",\"version\":\"1.8.0\"}")
+    echo "$REG" | python3 -c "import sys,json; print(json.load(sys.stdin).get('token',''))" 2>/dev/null
+    echo "$DEV" > /tmp/probe_dev.txt
+}
+
+measure_poll() {
+    local label="$1" token="$2" rounds="${3:-8}"
+    local ok=0 fail=0 times=() fails=""
+    echo "  ── $label：$rounds 次真实长轮询（每次挂 60 秒）──"
+    for i in $(seq 1 "$rounds"); do
+        out=$(curl -s -o /dev/null -w '%{http_code} %{time_total}' --max-time 100 \
+              -X POST "$PUB/v1/agent/poll" -H "X-Token: $token" -H "User-Agent: $UA")
+        code=$(echo "$out" | awk '{print $1}')
+        secs=$(echo "$out" | awk '{printf "%.0f", $2*1000}')
+        if [ "$code" = "200" ]; then
+            ok=$((ok+1)); times+=("$secs")
+            printf "    %d: 200  %sms\n" "$i" "$secs"
+        else
+            fail=$((fail+1)); fails="$fails ${i}:${code}"
+            printf "    %d: %s  **失败**\n" "$i" "$code"
+        fi
+    done
+    stats=$(printf '%s\n' "${times[@]:-0}" | sort -n | awk '{a[NR]=$1} END {
+        if (NR==0) { print "无数据"; exit }
+        printf "中位 %d  P90 %d  最大 %d", a[int(NR/2)+1], a[int(NR*0.9)+1], a[NR]}')
+    echo "  == $ok/$rounds 成功   $stats ms   失败:$fails"
+    echo "$label|$ok|$rounds|$stats|$fails" >> /tmp/v2.txt
+    echo
+}
+
+rm -f /tmp/v2.txt
+
+echo "════════ 基线：http2 + 4 ════════"
+set_params http2 4
+wait_ready 4 && echo "  连接就绪" || echo "  ! 没建齐"
+sleep 15
+TOKEN=$(probe_device)
+echo "  探针 token ${#TOKEN} 字符"
+measure_poll "http2+4" "$TOKEN" 8
+
+echo "════════ 候选：quic + 6 ════════"
+set_params quic 6
+wait_ready 6 && echo "  连接就绪" || echo "  ! 没建齐"
+sleep 15
+TOKEN=$(probe_device)
+echo "  探针 token ${#TOKEN} 字符"
+measure_poll "quic+6" "$TOKEN" 8
+
+echo "════════ 汇总（每次长轮询的耗时，理想值 ≈ 61000ms）════════"
+printf "  %-10s %-10s %s\n" "配置" "成功" "耗时"
+while IFS='|' read -r label ok total stats fails; do
+    printf "  %-10s %-10s %s\n" "$label" "$ok/$total" "$stats"
+done < /tmp/v2.txt
+
+echo
+echo "════════ 决策：主要看尾部延迟（用户体感就是这个）════════"
+B=$(grep '^http2+4' /tmp/v2.txt | cut -d'|' -f4)
+Q=$(grep '^quic+6' /tmp/v2.txt | cut -d'|' -f4)
+echo "  基线 $B"
+echo "  候选 $Q"
+
+# 取 P90 数字比较
+BP=$(echo "$B" | grep -oE 'P90 [0-9]+' | grep -oE '[0-9]+')
+QP=$(echo "$Q" | grep -oE 'P90 [0-9]+' | grep -oE '[0-9]+')
+echo
+if [ -n "${BP:-}" ] && [ -n "${QP:-}" ]; then
+    if [ "$QP" -lt "$BP" ]; then
+        echo "  → quic+6 的 P90（${QP}ms）优于基线（${BP}ms），采用 quic+6"
+        # 已经设成 quic 6 了，不用动
+    else
+        echo "  → quic+6 的 P90（${QP}ms）不如基线（${BP}ms），回滚"
+        cp -a "$BACKUP" "$SVC"
+        systemctl daemon-reload
+        systemctl restart lanremote-tunnel
+    fi
+else
+    echo "  → 数据不足，保守回滚"
+    cp -a "$BACKUP" "$SVC"
+    systemctl daemon-reload
+    systemctl restart lanremote-tunnel
+fi
+
+sleep 15
+echo
+echo "  最终参数: $(grep -oE '\-\-protocol [a-z0-9]+|--ha-connections [0-9]+' "$SVC" | tr '\n' ' ')"
+echo "  连接数: $(curl -s --max-time 5 http://127.0.0.1:20241/metrics 2>/dev/null | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}')"
+
+# 清探针
+KEY=$(cat /root/lanremote-relay/data/admin_key.txt 2>/dev/null)
+DEV=$(cat /tmp/probe_dev.txt 2>/dev/null)
+[ -n "${DEV:-}" ] && curl -s --max-time 20 -X POST "http://127.0.0.1:8080/v1/admin/delete" \
+    -H "X-Admin: $KEY" -H 'Content-Type: application/json' \
+    -d "{\"deviceId\":\"$DEV\"}" > /dev/null 2>&1
+echo "  备份: $BACKUP"

_build/ab_v3.sh

@@ -0,0 +1,133 @@
+#!/bin/bash
+# 隧道对照 v3：验证「QUIC 失败是因为 MTU」这个假设，并选出最稳的组合。
+#
+# 已查明的事实：
+#   1. cloudflared 用 QUIC 时反复报
+#        "failed to dial to edge with quic: timeout: no recent network activity"
+#      连十几个 IP 才成功一次 —— 握手阶段就掉包。
+#   2. 我们给 TCP 做了 MSS 钳制（--set-mss 1400），
+#      但 **QUIC 走 UDP，TCPMSS 规则完全不生效**。
+#   3. 路径 MTU 实测 1472（1500 的包不通）。
+#      QUIC 默认用 ~1452 字节的包，很容易被中间设备丢掉，
+#      而 UDP 丢了不会回 ICMP，客户端只能等到超时。
+#
+# 所以对照三组：
+#   A. quic + 6（现状，MTU 1500）           —— 预期握手仍不稳
+#   B. quic + 6 + wlan0 MTU 1400            —— 如果假设成立，握手会变稳
+#   C. http2 + 8（TCP 吃 MSS 钳制，连接多）  —— 对照组
+#
+# 每组记录：连接建齐耗时 / 建齐几条 / 60 次 HTTP 可用率
+set -u
+
+BASE=https://relay.xxmxxs.top
+UA='LanRemote/1.8.1'
+SVC=/etc/systemd/system/lanremote-tunnel.service
+BACKUP=/root/tunnel.bak.v3.$(date +%s)
+cp -a "$SVC" "$BACKUP"
+N=60
+
+set_params() {
+    local proto="$1" conns="$2"
+    cp -a "$BACKUP" "$SVC"
+    sed -i "s/--protocol [a-z0-9]*/--protocol $proto/" "$SVC"
+    sed -i "s/--ha-connections [0-9]*/--ha-connections $conns/" "$SVC"
+    systemctl daemon-reload
+    systemctl restart lanremote-tunnel
+}
+
+set_mtu() {
+    local mtu="$1"
+    ip link set wlan0 mtu "$mtu" 2>/dev/null && echo "    wlan0 MTU -> $(cat /sys/class/net/wlan0/mtu)"
+}
+
+# 等连接建齐，返回耗时秒数
+wait_conns() {
+    local want="$1" limit="$2" t0 t1 n
+    t0=$(date +%s)
+    while true; do
+        n=$(curl -s --max-time 4 http://127.0.0.1:20241/metrics 2>/dev/null \
+            | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}')
+        n=${n:-0}
+        t1=$(date +%s)
+        if [ "$n" -ge "$want" ] || [ $((t1 - t0)) -ge "$limit" ]; then
+            echo "$n $((t1 - t0))"
+            return
+        fi
+        sleep 3
+    done
+}
+
+run_group() {
+    local label="$1" proto="$2" conns="$3" mtu="$4"
+    echo "════════ $label ════════"
+
+    [ "$mtu" != "keep" ] && set_mtu "$mtu"
+
+    local mark; mark=$(wc -l < /root/lanremote-relay/tunnel.log 2>/dev/null || echo 0)
+    set_params "$proto" "$conns"
+
+    local res; res=$(wait_conns "$conns" 150)
+    local n; n=$(echo "$res" | awk '{print $1}')
+    local secs; s=$(echo "$res" | awk '{print $2}')
+    echo "    建齐 $n/$conns 条，用了 ${s} 秒"
+
+    # 这一轮建立过程中失败了多少次
+    local dialfail; dialfail=$(tail -n +$((mark+1)) /root/lanremote-relay/tunnel.log 2>/dev/null \
+                               | grep -c 'Failed to dial' || echo 0)
+    echo "    建立期间 dial 失败 $dialfail 次"
+
+    # 可用率
+    local ok=0 times=()
+    for i in $(seq 1 "$N"); do
+        out=$(curl -s -o /dev/null -w '%{http_code} %{time_total}' --max-time 25 \
+              -H "User-Agent: $UA" "$BASE/v1/health")
+        c=$(echo "$out" | awk '{print $1}')
+        ms=$(echo "$out" | awk '{printf "%d", $2*1000}')
+        if [ "$c" = "200" ]; then ok=$((ok+1)); times+=("$ms"); fi
+    done
+    local pct=$((ok * 100 / N))
+    local stats="无数据"
+    if [ "${#times[@]}" -gt 0 ]; then
+        stats=$(printf '%s\n' "${times[@]}" | sort -n | awk '{a[NR]=$1} END {
+            printf "中位 %d P90 %d P99 %d 最大 %d", a[int(NR/2)+1], a[int(NR*0.9)+1], a[int(NR*0.99)+1], a[NR]}')
+    fi
+    printf "    可用率 %d%% (%d/%d)   耗时 %s ms\n" "$pct" "$ok" "$N" "$stats"
+    echo "$label|$proto|$conns|$mtu|$n|$s|$dialfail|$pct|$stats" >> /tmp/v3.txt
+    echo
+}
+
+rm -f /tmp/v3.txt
+echo "  原始 wlan0 MTU: $(cat /sys/class/net/wlan0/mtu)"
+echo
+
+run_group "A. quic+6 MTU1500" quic 6 keep
+run_group "B. quic+6 MTU1400" quic 6 1400
+run_group "C. http2+8 MTU1400" http2 8 keep
+
+# 恢复 MTU
+set_mtu 1500
+
+echo "════════ 汇总 ════════"
+printf "  %-22s %-6s %-4s %-8s %-9s %-8s %s\n" "组" "协议" "连接" "建齐/耗时" "dial失败" "可用率" "延迟"
+while IFS='|' read -r label proto conns mtu n s dialfail pct stats; do
+    printf "  %-22s %-6s %-4s %-8s %-9s %-8s %s\n" \
+        "$label" "$proto" "$conns" "${n}/${conns} ${s}s" "$dialfail" "${pct}%" "$stats"
+done < /tmp/v3.txt
+
+echo
+echo "════════ 决策：可用率优先，其次看建齐速度 ════════"
+BEST=$(sort -t'|' -k8 -rn /tmp/v3.txt | head -1)
+BL=$(echo "$BEST" | cut -d'|' -f1)
+BP=$(echo "$BEST" | cut -d'|' -f2)
+BC=$(echo "$BEST" | cut -d'|' -f3)
+BM=$(echo "$BEST" | cut -d'|' -f4)
+echo "  最好: $BL（可用率 $(echo "$BEST" | cut -d'|' -f8)%）"
+
+cp -a "$BACKUP" "$SVC"
+sed -i "s/--protocol [a-z0-9]*/--protocol $BP/" "$SVC"
+sed -i "s/--ha-connections [0-9]*/--ha-connections $BC/" "$SVC"
+systemctl daemon-reload
+systemctl restart lanremote-tunnel
+echo "  已采用: --protocol $BP --ha-connections $BC"
+echo "  MTU: $(cat /sys/class/net/wlan0/mtu)"
+echo "  备份: $BACKUP"

_build/ab_v4.sh

@@ -0,0 +1,133 @@
+#!/bin/bash
+# 1) 把 MTU 1400 固化下来（重启也在）
+# 2) 在 MTU 1400 下对照 quic+6 / quic+8 / quic+10
+#
+# 为什么要固化 MTU：
+#   QUIC 走 UDP，**我们那条 --set-mss 1400 的 iptables 规则只管 TCP**。
+#   实测把 wlan0 MTU 从 1500 降到 1400 之后：
+#     QUIC 建齐 6 条连接的时间  28 秒 -> 13 秒
+#     dial 失败次数              2 -> 1
+#   原因：UDP 丢包不会回 ICMP，QUIC 发了超出路径 MTU 的包只能等超时。
+#   把接口 MTU 压到 1400，QUIC 的包就都在安全范围内。
+#
+# 为什么还要试更多连接：
+#   已经看到 http2+8 建齐只要 12 秒且 0 失败（QUIC+6 是 28 秒/2 次失败）。
+#   连接多 = 单条掉线影响小。但 QUIC 的连接建立更贵，得实测平衡点。
+set -u
+
+BASE=https://relay.xxmxxs.top
+UA='LanRemote/1.8.2'
+SVC=/etc/systemd/system/lanremote-tunnel.service
+NETTUNE=/etc/systemd/system/lanremote-nettune.service
+BACKUP=/root/tunnel.bak.v4.$(date +%s)
+cp -a "$SVC" "$BACKUP"
+N=60
+MTU=1400
+MSS=1360
+
+echo "════════ 1. 固化 MTU（写进 net-tune 服务）════════"
+echo "  现在的 net-tune 服务:"
+systemctl cat lanremote-nettune 2>/dev/null | grep -E 'ExecStart' | sed 's/^/    /'
+
+# 把 MTU 设置追加进去（幂等：已有的先删掉）
+cp -a "$NETTUNE" "${NETTUNE}.bak.$(date +%s)" 2>/dev/null || true
+python3 - <<'PYEOF'
+from pathlib import Path
+p = Path("/etc/systemd/system/lanremote-nettune.service")
+if not p.is_file():
+    print("    ! net-tune 服务不存在，跳过")
+    raise SystemExit(0)
+text = p.read_text(encoding="utf-8")
+# 去掉旧的 MTU/MSS 行
+lines = [l for l in text.splitlines()
+         if "ip link set wlan0 mtu" not in l and "--set-mss" not in l]
+out = []
+for line in lines:
+    out.append(line)
+    # 在每个 ExecStart 之后补上 MTU 设置
+    if line.strip().startswith("ExecStart="):
+        out.append("ExecStart=/sbin/ip link set wlan0 mtu 1400")
+        out.append("ExecStart=/sbin/iptables -t mangle -C OUTPUT -p tcp "
+                   "--tcp-flags SYN,RST SYN -j TCPMSS --set-mss 1360 || "
+                   "/sbin/iptables -t mangle -A OUTPUT -p tcp "
+                   "--tcp-flags SYN,RST SYN -j TCPMSS --set-mss 1360")
+p.write_text("\n".join(out) + "\n", encoding="utf-8")
+print("    已写入 MTU 1400 + MSS 1360")
+PYEOF
+
+systemctl daemon-reload
+echo "  立即执行一次:"
+ip link set wlan0 mtu $MTU && echo "    wlan0 MTU -> $(cat /sys/class/net/wlan0/mtu)"
+iptables -t mangle -C OUTPUT -p tcp --tcp-flags SYN,RST SYN -j TCPMSS --set-mss $MSS 2>/dev/null \
+    || iptables -t mangle -A OUTPUT -p tcp --tcp-flags SYN,RST SYN -j TCPMSS --set-mss $MSS
+echo "    MSS 规则: $(iptables -t mangle -S OUTPUT | grep TCPMSS | head -1)"
+echo "  net-tune 现在的内容:"
+systemctl cat lanremote-nettune 2>/dev/null | grep ExecStart | sed 's/^/    /'
+echo "  服务状态: $(systemctl is-enabled lanremote-nettune 2>/dev/null) / $(systemctl is-active lanremote-nettune 2>/dev/null)"
+
+wait_conns() {
+    local want="$1" limit="$2" t0 t1 n
+    t0=$(date +%s)
+    while true; do
+        n=$(curl -s --max-time 4 http://127.0.0.1:20241/metrics 2>/dev/null \
+            | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}')
+        n=${n:-0}
+        t1=$(date +%s)
+        [ "$n" -ge "$want" ] || [ $((t1 - t0)) -ge "$limit" ] && { echo "$n $((t1 - t0))"; return; }
+        sleep 3
+    done
+}
+
+run_group() {
+    local conns="$1"
+    echo "════════ quic + $conns （MTU $MTU）════════"
+    cp -a "$BACKUP" "$SVC"
+    sed -i "s/--protocol [a-z0-9]*/--protocol quic/" "$SVC"
+    sed -i "s/--ha-connections [0-9]*/--ha-connections $conns/" "$SVC"
+    systemctl daemon-reload
+    local mark; mark=$(wc -l < /root/lanremote-relay/tunnel.log 2>/dev/null || echo 0)
+    systemctl restart lanremote-tunnel
+    local res; res=$(wait_conns "$conns" 150)
+    local n s
+    n=$(echo "$res" | awk '{print $1}'); s=$(echo "$res" | awk '{print $2}')
+    local df; df=$(tail -n +$((mark+1)) /root/lanremote-relay/tunnel.log 2>/dev/null | grep -c 'Failed to dial' || echo 0)
+    echo "    建齐 $n/$conns，用 ${s} 秒，dial 失败 ${df} 次"
+
+    local ok=0 times=()
+    for i in $(seq 1 "$N"); do
+        out=$(curl -s -o /dev/null -w '%{http_code} %{time_total}' --max-time 25 -H "User-Agent: $UA" "$BASE/v1/health")
+        c=$(echo "$out" | awk '{print $1}'); ms=$(echo "$out" | awk '{printf "%d", $2*1000}')
+        [ "$c" = "200" ] && { ok=$((ok+1)); times+=("$ms"); }
+    done
+    local pct=$((ok * 100 / N))
+    local stats="无数据"
+    [ "${#times[@]}" -gt 0 ] && stats=$(printf '%s\n' "${times[@]}" | sort -n | awk '{a[NR]=$1} END {
+        printf "中位 %d P90 %d P99 %d 最大 %d", a[int(NR/2)+1], a[int(NR*0.9)+1], a[int(NR*0.99)+1], a[NR]}')
+    printf "    可用率 %d%% (%d/%d)   %s ms\n" "$pct" "$ok" "$N" "$stats"
+    echo "quic+$conns|$n|$s|$df|$pct|$stats" >> /tmp/v4.txt
+    echo
+}
+
+rm -f /tmp/v4.txt
+run_group 6
+run_group 8
+run_group 10
+
+echo "════════ 汇总 ════════"
+printf "  %-10s %-14s %-10s %-8s %s\n" "配置" "建齐/耗时" "dial失败" "可用率" "延迟"
+while IFS='|' read -r label n s df pct stats; do
+    printf "  %-10s %-14s %-10s %-8s %s\n" "$label" "${n}条 ${s}s" "$df" "${pct}%" "$stats"
+done < /tmp/v4.txt
+
+echo
+BESTN=$(sort -t'|' -k5 -rn /tmp/v4.txt | head -1 | sed 's/quic+//' | cut -d'|' -f1)
+echo "  → 采用 quic + $BESTN"
+cp -a "$BACKUP" "$SVC"
+sed -i "s/--protocol [a-z0-9]*/--protocol quic/" "$SVC"
+sed -i "s/--ha-connections [0-9]*/--ha-connections $BESTN/" "$SVC"
+systemctl daemon-reload
+systemctl restart lanremote-tunnel
+sleep 5
+echo "  最终参数: $(grep -oE '\-\-protocol [a-z0-9]+|--ha-connections [0-9]+' "$SVC" | tr '\n' ' ')"
+echo "  MTU: $(cat /sys/class/net/wlan0/mtu)"
+echo "  备份: $BACKUP"

_build/accept_181.sh

@@ -0,0 +1,69 @@
+#!/bin/bash
+# 1.8.1 最终验收：从公网走一遍用户会走的全部路径
+set -u
+
+BASE=https://relay.xxmxxs.top
+UA='LanRemote/1.8.1'
+
+echo "════════ 1. 中转版本和隧道 ════════"
+curl -s --max-time 15 "$BASE/v1/health" | head -c 130
+echo
+echo "  隧道连接: $(curl -s --max-time 5 http://127.0.0.1:20241/metrics 2>/dev/null | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}') 条"
+echo "  协议参数: $(grep -c 'protocol quic' /etc/systemd/system/lanremote-tunnel.service) （1=quic）"
+echo "  长轮询:   $(tail -30 /root/lanremote-relay/relay.log | grep '长轮询' | tail -1 | grep -oE '[0-9]+ 秒')"
+
+echo
+echo "════════ 2. 官网 ════════"
+curl -s --max-time 25 -H "User-Agent: $UA" "$BASE/" -o /tmp/site.html
+echo "  HTTP $(curl -s -o /dev/null -w '%{http_code}' --max-time 25 -H "User-Agent: $UA" "$BASE/")  $(wc -c < /tmp/site.html) 字节"
+echo "  下载按钮:"
+grep -o 'href="/download/[^"]*"' /tmp/site.html | sort -u | sed 's/^/    /'
+echo "  管理页字眼: $(grep -cE 'zhongzhuanzhan|管理后台|管理页' /tmp/site.html || echo 0) 处（应为 0）"
+
+echo
+echo "════════ 3. 三个成品能下吗 ════════"
+for f in ykxmz-setup-1.8.1.exe ykxmz-server-1.8.1.zip ykxmz-watch-1.8.1.apk; do
+    hdr=$(curl -sI --max-time 40 -H "User-Agent: $UA" "$BASE/download/$f")
+    code=$(echo "$hdr" | head -1 | awk '{print $2}')
+    len=$(echo "$hdr" | grep -i '^content-length' | tr -d '\r' | awk '{print $2}')
+    printf "  %-30s HTTP %-4s %s 字节\n" "$f" "$code" "${len:-?}"
+done
+
+echo
+echo "════════ 4. 长轮询还能跑通吗（2 次真实验证）════════"
+STAMP=$(date +%s)
+DEV="final-${STAMP}"
+CODE=$(printf "%06d" $(( STAMP % 1000000 )))
+REG=$(curl -s --max-time 30 -X POST "$BASE/v1/agent/register" \
+      -H 'Content-Type: application/json' -H "User-Agent: $UA" \
+      -d "{\"deviceId\":\"$DEV\",\"code\":\"$CODE\",\"name\":\"final\",\"version\":\"1.8.1\"}")
+TOKEN=$(echo "$REG" | python3 -c "import sys,json; print(json.load(sys.stdin).get('token',''))" 2>/dev/null)
+echo "  探针注册: $([ -n "$TOKEN" ] && echo 成功 || echo 失败)"
+for i in 1 2; do
+    out=$(curl -s -o /dev/null -w '%{http_code} %{time_total}' --max-time 130 \
+          -X POST "$BASE/v1/agent/poll" -H "X-Token: $TOKEN" -H "User-Agent: $UA")
+    printf "    第 %d 次: 码 %s  耗时 %.1fs（应约 61 秒）\n" \
+        "$i" "$(echo "$out" | awk '{print $1}')" "$(echo "$out" | awk '{print $2}')"
+done
+KEY=$(cat /root/lanremote-relay/data/admin_key.txt 2>/dev/null)
+curl -s --max-time 20 -X POST "http://127.0.0.1:8080/v1/admin/delete" \
+     -H "X-Admin: $KEY" -H 'Content-Type: application/json' \
+     -d "{\"deviceId\":\"$DEV\"}" > /dev/null 2>&1
+echo "  探针已清理"
+
+echo
+echo "════════ 5. 公网可用率（10 次）════════"
+ok=0
+for i in $(seq 1 10); do
+    c=$(curl -s -o /dev/null -w '%{http_code}' --max-time 20 -H "User-Agent: $UA" "$BASE/v1/health")
+    [ "$c" = "200" ] && ok=$((ok+1))
+    printf "  %2d: %s\n" "$i" "$c"
+    sleep 1
+done
+echo "  可用 $ok/10"
+
+echo
+echo "════════ 6. 中转有没有报错 ════════"
+journalctl -u lanremote-relay --since '5 minutes ago' --no-pager 2>/dev/null \
+    | grep -icE 'traceback|nameerror|typeerror' | sed 's/^/  错误行数: /'
+tail -3 /root/lanremote-relay/relay.log | sed 's/^/  /'

_build/accept_final.sh

@@ -0,0 +1,75 @@
+#!/bin/bash
+# 1.8.2 最终验收（在设备上跑）
+set -u
+
+BASE=https://relay.xxmxxs.top
+UA='LanRemote/1.8.2'
+
+echo "════════ 1. 官网和三个成品（走公网，看缓存）════════"
+for p in / /download/ykxmz-setup-1.8.2.exe /download/ykxmz-server-1.8.2.zip /download/ykxmz-watch-1.8.2.apk; do
+    hdr=$(curl -s -D - -o /dev/null --max-time 45 -H "User-Agent: $UA" "$BASE$p" 2>/dev/null | tr -d '\r')
+    code=$(echo "$hdr" | head -1 | awk '{print $2}')
+    len=$(echo "$hdr" | grep -i '^content-length' | awk '{print $2}')
+    cf=$(echo "$hdr" | grep -i '^cf-cache-status' | awk '{print $2}')
+    cc=$(echo "$hdr" | grep -i '^cache-control' | cut -d' ' -f2-)
+    printf "  %-38s HTTP %-4s %10s  cf=%-6s %s\n" "$p" "$code" "$len" "${cf:-无}" "${cc:-无}"
+done
+
+echo
+echo "════════ 2. 对外清洁度（官网不能有管理页字眼）════════"
+curl -s --max-time 30 -H "User-Agent: $UA" "$BASE/" -o /tmp/site.html
+n=$(grep -cE 'zhongzhuanzhan|管理后台|管理页|管理入口|管理面板' /tmp/site.html || true)
+echo "  官网里管理页字眼: $n 处（应为 0）"
+echo "  官网大小: $(wc -c < /tmp/site.html) 字节"
+echo "  下载按钮:"
+grep -o 'href="/download/[^"]*"' /tmp/site.html | sort -u | sed 's/^/    /'
+
+echo
+echo "════════ 3. 管理页两个新功能 ════════"
+if [ -f /root/taf.py ]; then
+    python3 /root/taf.py 2>&1 | tail -16 | sed 's/^/  /'
+else
+    echo "  （测试脚本不在设备上）"
+fi
+
+echo
+echo "════════ 4. 中转核心功能（长轮询 + 注册）════════"
+STAMP=$(date +%s)
+DEV="acc-$STAMP"
+CODE=$(printf "%06d" $(( STAMP % 1000000 )))
+REG=$(curl -s --max-time 30 -X POST "$BASE/v1/agent/register" \
+      -H 'Content-Type: application/json' -H "User-Agent: $UA" \
+      -d "{\"deviceId\":\"$DEV\",\"code\":\"$CODE\",\"name\":\"验收\",\"version\":\"1.8.2\"}")
+TOKEN=$(echo "$REG" | python3 -c "import sys,json; print(json.load(sys.stdin).get('token',''))" 2>/dev/null)
+echo "  注册: $([ -n "$TOKEN" ] && echo 成功 || echo 失败)"
+if [ -n "$TOKEN" ]; then
+    for i in 1 2; do
+        out=$(curl -s -o /dev/null -w '%{http_code} %{time_total}' --max-time 200 \
+              -X POST "$BASE/v1/agent/poll" -H "X-Token: $TOKEN" -H "User-Agent: $UA")
+        printf "    长轮询 %d: 码 %s  耗时 %.1fs（应约 61 秒）\n" \
+            "$i" "$(echo "$out" | awk '{print $1}')" "$(echo "$out" | awk '{print $2}')"
+    done
+    KEY=$(cat /root/lanremote-relay/data/admin_key.txt 2>/dev/null)
+    curl -s --max-time 20 -X POST "http://127.0.0.1:8080/v1/admin/delete" \
+         -H "X-Admin: $KEY" -H 'Content-Type: application/json' \
+         -d "{\"deviceId\":\"$DEV\"}" > /dev/null 2>&1
+    echo "  探针已清理"
+fi
+
+echo
+echo "════════ 5. 公网可用率（20 次）════════"
+ok=0
+for i in $(seq 1 20); do
+    c=$(curl -s -o /dev/null -w '%{http_code}' --max-time 20 -H "User-Agent: $UA" "$BASE/v1/health")
+    [ "$c" = "200" ] && ok=$((ok + 1))
+    sleep 1
+done
+echo "  可用 $ok/20 = $((ok * 5))%"
+
+echo
+echo "════════ 6. 隧道和错误 ════════"
+for s in lanremote-relay lanremote-tunnel lanremote-tunnel-h2; do
+    printf "  %-24s %s\n" "$s" "$(systemctl is-active $s)"
+done
+echo "  中转错误行数（近 10 分钟）: $(journalctl -u lanremote-relay --since '10 minutes ago' --no-pager 2>/dev/null | grep -icE 'traceback|nameerror|typeerror|AttributeError' || echo 0)"
+echo "  连接数: 20241=$(curl -s --max-time 4 http://127.0.0.1:20241/metrics 2>/dev/null | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}')  20242=$(curl -s --max-time 4 http://127.0.0.1:20242/metrics 2>/dev/null | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}')"

_build/add_admin_features.py

@@ -0,0 +1,200 @@
+# -*- coding: utf-8 -*-
+r'''中转管理页新增两个功能（中转端逻辑）。
+
+== 功能一：允许/禁止新设备接入 ==
+
+一个开关，关掉之后**只有已经登记过的设备能继续上线**，
+没见过的新设备一律拒绝。
+
+用途：不想让陌生人拿配对码乱试、或者临时把中转"关起来"。
+
+实现要点：
+  * 标志位存在 relay_state.json 里，重启不丢
+  * 判断"新设备"以 deviceId 为准（它装机时生成、重装也不变），
+    不是看配对码 —— 老设备换码也必须能进来
+  * 被拒绝时回一个明确的标记 blocked=True，
+    让客户端能区分"被管理员挡了"和"配对码冲突"，
+    不要用中文错误文案去匹配（文案一改就坏）
+
+== 功能二：修改任意设备的配对码 ==
+
+管理页上每台设备一个"改配对码"按钮，填新码就生效。
+
+实现要点：
+  * 新码必须是 6 位数字
+  * 新码不能已经被别的设备占用
+  * 改的时候要同时更新 codes 映射和 device.code，
+    并清掉该设备**旧码**的映射 —— 否则旧码会变成孤儿条目，
+    仪表盘上"配对码占用"会虚高
+  * 改完立刻 _save()，重启后仍然是新码
+  * 该设备当前的手表会话要踢掉（会话是绑在旧码上的），
+    否则手表还拿着旧会话以为连着，实际电脑已经换了码
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+SRC = Path(r"C:\Users\shu\Desktop\deepseekagent\LanRemote\relay\relay.py")
+
+
+def patch(text: str, old: str, new: str, label: str) -> tuple:
+    if old not in text:
+        print("  ✗ 没找到：%s" % label)
+        return text, False
+    if text.count(old) != 1:
+        print("  ! 出现 %d 次：%s" % (text.count(old), label))
+        return text, False
+    print("  ✓ %s" % label)
+    return text.replace(old, new, 1), True
+
+
+def main() -> int:
+    text = SRC.read_text(encoding="utf-8")
+    before = text.count("\n") + 1
+    ok_all = True
+
+    # ---------------------------------------------------------- 1. 字段
+    old = """        self.retired: dict = {}
+        self.started = time.time()"""
+    new = """        self.retired: dict = {}
+        # 是否允许新设备接入。False 时只有已登记过的 deviceId 能上线。
+        self.allow_new = True
+        self.started = time.time()"""
+    text, ok = patch(text, old, new, "加 allow_new 字段")
+    ok_all = ok_all and ok
+
+    # ---------------------------------------------------------- 2. _load
+    old = """        for item in raw.get("codes", []):
+            device_id = str(item.get("deviceId", ""))
+            code = str(item.get("code", ""))
+            if device_id and CODE_RE.match(code):
+                self.codes[code] = device_id
+                log(f"恢复配对码绑定：设备 {device_id[:12]}… -> {code}")"""
+    new = """        # 是否允许新设备接入（重启不丢）
+        self.allow_new = bool(raw.get("allowNew", True))
+        for item in raw.get("codes", []):
+            device_id = str(item.get("deviceId", ""))
+            code = str(item.get("code", ""))
+            if device_id and CODE_RE.match(code):
+                self.codes[code] = device_id
+                log(f"恢复配对码绑定：设备 {device_id[:12]}… -> {code}")"""
+    text, ok = patch(text, old, new, "_load 恢复 allow_new")
+    ok_all = ok_all and ok
+
+    # ---------------------------------------------------------- 3. _save
+    old = """            payload = {"codes": [
+                {"deviceId": did, "code": code}
+                for code, did in sorted(self.codes.items())
+            ]}"""
+    new = """            payload = {
+                "allowNew": bool(self.allow_new),
+                "codes": [
+                    {"deviceId": did, "code": code}
+                    for code, did in sorted(self.codes.items())
+                ],
+            }"""
+    text, ok = patch(text, old, new, "_save 持久化 allow_new")
+    ok_all = ok_all and ok
+
+    # ---------------------------------------------------------- 4. 拒绝新设备
+    old = """        with self.lock:
+            known = self.codes.get(code)
+            if known and known != device_id:"""
+    new = """        with self.lock:
+            # 管理员关掉了"允许新设备接入"时，
+            # 只放行**已经登记过**的设备。
+            #
+            # 注意判断依据是 deviceId（装机时生成、重装也不变），
+            # **不是配对码** —— 否则管理员给老设备改了码，
+            # 那台设备就被自己的开关挡在外面了。
+            known_device = device_id in self.devices
+            if not known_device and not self.allow_new:
+                log(f"新设备接入已被关闭，拒绝 {name} ({device_id[:12]}…)")
+                return {"ok": False,
+                        "blocked": True,
+                        "error": "中转站当前不接受新设备接入"}
+
+            known = self.codes.get(code)
+            if known and known != device_id:"""
+    text, ok = patch(text, old, new, "register 拒绝新设备")
+    ok_all = ok_all and ok
+
+    # ---------------------------------------------------------- 5. 管理方法
+    old = """    def device_by_token(self, token: str) -> Device | None:"""
+    new = """    # ---------------- 管理操作 ----------------
+
+    def set_allow_new(self, allow: bool) -> dict:
+        \"\"\"开关"允许新设备接入"。\"\"\"
+        with self.lock:
+            self.allow_new = bool(allow)
+            self._save()
+            log(f"管理员把「允许新设备接入」设为 {self.allow_new}")
+            return {"ok": True, "allowNew": self.allow_new}
+
+    def set_device_code(self, device_id: str, new_code: str) -> dict:
+        \"\"\"给一台设备换配对码。
+
+        要点：
+          * 新码必须是 6 位数字
+          * 不能已经被**别的**设备占用
+          * 旧码的映射必须删掉，否则会变成孤儿条目，
+            管理页上"配对码占用"的数字会虚高
+          * 该设备挂着的会话要踢掉 —— 会话是绑在码上的，
+            不踢的话手表还拿着旧会话以为连着
+        \"\"\"
+        device_id = str(device_id or "").strip()
+        new_code = str(new_code or "").strip()
+        if not CODE_RE.match(new_code):
+            return {"ok": False, "error": "配对码必须是 6 位数字"}
+        with self.lock:
+            device = self.devices.get(device_id)
+            if device is None:
+                return {"ok": False, "error": "没有这台设备（可能已下线）"}
+
+            owner = self.codes.get(new_code)
+            if owner and owner != device_id:
+                return {"ok": False,
+                        "error": "这个配对码已经被别的设备占用了"}
+
+            old_code = device.code
+            if old_code == new_code:
+                return {"ok": True, "code": new_code, "unchanged": True}
+
+            # 删掉旧码映射（连同可能存在的别名）
+            for code, owner_id in list(self.codes.items()):
+                if owner_id == device_id:
+                    self.codes.pop(code, None)
+            self.codes[new_code] = device_id
+            device.code = new_code
+
+            # 会话绑在码上，旧会话作废，让手表重新配对
+            kicked = 0
+            for sid in [s.session_id for s in self.sessions.values()
+                        if s.device_id == device_id]:
+                self.sessions.pop(sid, None)
+                kicked += 1
+
+            self._save()
+            log(f"管理员把设备 {device.name} 的配对码 "
+                f"{old_code} 改成 {new_code}（踢掉 {kicked} 个会话）")
+            return {"ok": True, "code": new_code,
+                    "oldCode": old_code, "kicked": kicked}
+
+    def device_by_token(self, token: str) -> Device | None:"""
+    text, ok = patch(text, old, new, "加 set_allow_new / set_device_code")
+    ok_all = ok_all and ok
+
+    if not ok_all:
+        print()
+        print("  有锚点没匹配，没有写回")
+        return 1
+
+    SRC.write_text(text, encoding="utf-8", newline="\n")
+    print()
+    print("  已写回：%d -> %d 行" % (before, text.count("\n") + 1))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/add_admin_ui.py

@@ -0,0 +1,183 @@
+# -*- coding: utf-8 -*-
+r'''管理页 UI：加「允许新设备接入」开关 + 每台设备的「改码」按钮。
+
+设计上遵守用户的"所有东西都要白色简洁"：
+  * 开关用系统原生 checkbox + 极简样式，不引入花哨组件
+  * 改码走 prompt()，不加弹窗层 —— 管理页是自用的，
+    少一层 DOM 就少一处会坏的地方
+  * 按钮沿用现有的 .ghost 样式（不抢 .danger 的视觉重量）
+
+⚠ 一个容易踩的坑：
+  现有 JS 用 `button.danger[data-device]` 绑定"单台删除"。
+  新加的"改码"按钮**故意不带 data-device 而用 data-recode**，
+  否则会被删除逻辑一起选中，点改码变成删设备。
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+SRC = Path(r"C:\Users\shu\Desktop\deepseekagent\LanRemote\relay\admin.py")
+
+
+def patch(text: str, old: str, new: str, label: str) -> tuple:
+    if old not in text:
+        print("  ✗ 没找到：%s" % label)
+        return text, False
+    if text.count(old) != 1:
+        print("  ! 出现 %d 次：%s" % (text.count(old), label))
+        return text, False
+    print("  ✓ %s" % label)
+    return text.replace(old, new, 1), True
+
+
+def main() -> int:
+    text = SRC.read_text(encoding="utf-8")
+    ok_all = True
+
+    # ------------------------------------------------ 1. 行里加"改码"按钮
+    old = """            '<td class="ops"><button class="danger sm" '
+            'data-device="%s" data-name="%s" data-code="%s">删除</button></td>'
+            '</tr>' % (
+                did, name,
+                "on" if online else "off", name, did,
+                code,
+                "on" if online else "off", "在线" if online else "离线",
+                device["idleSeconds"],
+                device["queuedToClient"], device["queuedToAgent"],
+                _kb(device["bytesIn"]), _kb(device["bytesOut"]),
+                did, name, code)
+        )"""
+    new = """            '<td class="ops">'
+            # ⚠ 这个按钮用 data-recode 而不是 data-device ——
+            #   现有"单台删除"是按 button.danger[data-device] 绑的，
+            #   这里要是也带 data-device 就会被当成删除按钮。
+            '<button class="ghost sm" data-recode="%s" '
+            'data-name="%s" data-code="%s">改码</button>'
+            '<button class="danger sm" '
+            'data-device="%s" data-name="%s" data-code="%s">删除</button></td>'
+            '</tr>' % (
+                did, name,
+                "on" if online else "off", name, did,
+                code,
+                "on" if online else "off", "在线" if online else "离线",
+                device["idleSeconds"],
+                device["queuedToClient"], device["queuedToAgent"],
+                _kb(device["bytesIn"]), _kb(device["bytesOut"]),
+                did, name, code,
+                did, name, code)
+        )"""
+    text, ok = patch(text, old, new, "设备行加「改码」按钮")
+    ok_all = ok_all and ok
+
+    # ------------------------------------------------ 2. 开关放进"设备"小节
+    old = """  <div class="sec">
+    <h3>设备</h3>
+    <div class="right">
+      <label class="hint" style="cursor:pointer;display:flex;align-items:center;gap:6px;margin:0">
+        <input type="checkbox" id="autoRef" checked> 自动刷新
+      </label>"""
+    new = """  <div class="sec">
+    <h3>设备</h3>
+    <div class="right">
+      <label class="hint" id="allowWrap"
+             style="cursor:pointer;display:flex;align-items:center;gap:7px;margin:0 18px 0 0">
+        <input type="checkbox" id="allowNew"%(allownew)s>
+        <span>允许新设备接入</span>
+      </label>
+      <label class="hint" style="cursor:pointer;display:flex;align-items:center;gap:6px;margin:0">
+        <input type="checkbox" id="autoRef" checked> 自动刷新
+      </label>"""
+    text, ok = patch(text, old, new, "设备小节加开关")
+    ok_all = ok_all and ok
+
+    # ------------------------------------------------ 3. 传入开关状态
+    old = """    sessions = snap.get("sessions", 0)"""
+    new = """    sessions = snap.get("sessions", 0)
+    # 开关状态：允许新设备接入时勾上
+    allow_new = bool(snap.get("allowNew", True))"""
+    text, ok = patch(text, old, new, "读 allowNew 状态")
+    ok_all = ok_all and ok
+
+    old = """        "rows": _device_rows(devices),
+        "dl": dl_rows,"""
+    new = """        "rows": _device_rows(devices),
+        "allownew": " checked" if allow_new else "",
+        "dl": dl_rows,"""
+    text, ok = patch(text, old, new, "把状态传进模板")
+    ok_all = ok_all and ok
+
+    # ------------------------------------------------ 4. JS
+    old = """// ---------------- 单台删除 ----------------"""
+    new = """// ---------------- 允许/禁止新设备接入 ----------------
+// 关掉之后，只有**已经登记过**的电脑能继续上线，
+// 没见过的新设备一律拒绝。
+const allowNew = document.getElementById('allowNew');
+if (allowNew) allowNew.onchange = async () => {
+  const want = allowNew.checked;
+  allowNew.disabled = true;
+  try {
+    const j = await post('/v1/admin/allow_new', {allow: want});
+    if (j.ok) {
+      toast(j.allowNew ? '已允许新设备接入' : '已禁止新设备接入', 'ok');
+    } else {
+      toast('设置失败：' + (j.error || '未知错误'), 'err');
+      allowNew.checked = !want;
+    }
+  } catch (e) {
+    toast('请求出错：' + e, 'err');
+    allowNew.checked = !want;
+  }
+  allowNew.disabled = false;
+};
+
+// ---------------- 改配对码 ----------------
+document.querySelectorAll('button[data-recode]').forEach(b => {
+  b.onclick = async () => {
+    const name = b.dataset.name, old = b.dataset.code;
+    const typed = prompt('把「' + name + '」的配对码 ' + old
+                       + ' 改成：\\n\\n（必须是 6 位数字）', '');
+    if (typed === null) return;
+    const code = (typed || '').trim();
+    if (!/^[0-9]{6}$/.test(code)) {
+      toast('配对码必须是 6 位数字', 'err');
+      return;
+    }
+    b.disabled = true;
+    try {
+      const j = await post('/v1/admin/set_code',
+                           {deviceId: b.dataset.recode, code: code});
+      if (j.ok) {
+        toast(j.unchanged ? '配对码没有变化'
+                          : ('配对码已改成 ' + j.code
+                             + (j.kicked ? '，踢掉 ' + j.kicked + ' 个会话' : '')),
+              'ok');
+        setTimeout(() => location.reload(), 900);
+      } else {
+        toast('改码失败：' + (j.error || '未知错误'), 'err');
+        b.disabled = false;
+      }
+    } catch (e) {
+      toast('请求出错：' + e, 'err');
+      b.disabled = false;
+    }
+  };
+});
+
+// ---------------- 单台删除 ----------------"""
+    text, ok = patch(text, old, new, "加开关和改码的 JS")
+    ok_all = ok_all and ok
+
+    if not ok_all:
+        print()
+        print("  有锚点没匹配，没有写回")
+        return 1
+
+    SRC.write_text(text, encoding="utf-8", newline="\n")
+    print()
+    print("  admin.py 已写回")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/add_cache_headers.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+r'''给静态资源加缓存头，让 Cloudflare 在边缘直接发。
+
+== 为什么这是最大的一招 ==
+
+基线实测（下载 15 MB 安装包走隧道回 4G 源站）：
+
+    ykxmz-watch-1.8.1.apk    201523 字节 / 66.8 秒  =   3 KB/s
+    ykxmz-server-1.8.1.zip   214900 字节 /  3.1 秒  =  67 KB/s
+    ykxmz-setup-1.8.1.exe    只下到 237568/15067199 字节就停了
+
+原因：relay 给所有响应都发 `Cache-Control: no-store`，
+**Cloudflare 完全不缓存** —— 每一次下载、每一张图、每个 favicon
+都要穿隧道回 4G 源站。而回源吞吐只有几 KB/s。
+
+改成可缓存后，Cloudflare 会在用户附近的边缘节点直接发，
+速度是"边缘到用户"，跟 4G 那条腿无关。
+
+== 各路径的策略 ==
+
+    /download/*    public, max-age=604800, immutable
+                   文件名带版本号（ykxmz-setup-1.8.1.exe），
+                   同一名字的内容永不改变，所以可以放心长缓存。
+    /shot/*        已经是 public, max-age=86400（保持不变）
+    /favicon.ico   public, max-age=604800（147 KB，之前每次 3.2 秒）
+    /              public, max-age=60
+                   首页会列出当前版本，缓存久了下新版本会看不到按钮。
+                   60 秒足够挡住刷新的重复回源，又不会让版本信息过期太久。
+    /v1/*          no-store（接口，必须实时）
+
+注意：Cloudflare 默认只缓存一部分扩展名，.exe/.zip/.apk 可能不在
+默认列表里。所以改完必须**实测 cf-cache-status 是不是 HIT**，
+不 HIT 就要在 Cloudflare 后台加一条 Cache Rule（我会告诉用户怎么加）。
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+SRC = Path(r"C:\Users\shu\Desktop\deepseekagent\LanRemote\relay\relay.py")
+
+OLD_DL = """            self.send_header(
+                "Content-Disposition",
+                f"attachment; filename*=UTF-8''{quoted}")
+            self.send_header("Cache-Control", "no-store")"""
+
+NEW_DL = """            self.send_header(
+                "Content-Disposition",
+                f"attachment; filename*=UTF-8''{quoted}")
+            # ★ 让 Cloudflare 在边缘缓存。
+            #   原来这里是 no-store，于是每次下载都要穿隧道回 4G 源站，
+            #   实测吞吐只有 3~67 KB/s（15 MB 的安装包根本下不动）。
+            #   文件名带版本号，同一名字内容永不改变，可以长缓存。
+            self.send_header(
+                "Cache-Control",
+                "public, max-age=604800, immutable")"""
+
+# favicon 那块
+OLD_ICON = """            self._send(200, icon, "image/x-icon")"""
+NEW_ICON = """            self._send(200, icon, "image/x-icon",
+                       {"Cache-Control": "public, max-age=604800"})"""
+
+# 首页那块
+OLD_SITE = """            self._send(200, _site_page().encode("utf-8"),
+                       "text/html; charset=utf-8")
+            return"""
+NEW_SITE = """            # 首页缓存 60 秒：挡住刷新的重复回源，
+            # 又不会让"当前版本/下载按钮"过期太久。
+            self._send(200, _site_page().encode("utf-8"),
+                       "text/html; charset=utf-8",
+                       {"Cache-Control": "public, max-age=60"})
+            return"""
+
+
+def patch(text: str, old: str, new: str, label: str) -> tuple:
+    if old not in text:
+        print("  ✗ 没找到：%s" % label)
+        return text, False
+    if text.count(old) != 1:
+        print("  ! 出现 %d 次：%s" % (text.count(old), label))
+        return text, False
+    print("  ✓ %s" % label)
+    return text.replace(old, new, 1), True
+
+
+def main() -> int:
+    text = SRC.read_text(encoding="utf-8")
+    before = text.count("\n") + 1
+    ok_all = True
+
+    print("  加缓存头:")
+    for old, new, label in (
+        (OLD_DL, NEW_DL, "下载：no-store -> public,max-age=604800,immutable"),
+        (OLD_ICON, NEW_ICON, "favicon：加 7 天缓存"),
+        (OLD_SITE, NEW_SITE, "首页：加 60 秒缓存"),
+    ):
+        text, ok = patch(text, old, new, label)
+        ok_all = ok_all and ok
+
+    if not ok_all:
+        print()
+        print("  有锚点没匹配，没有写回")
+        return 1
+
+    SRC.write_text(text, encoding="utf-8", newline="\n")
+    print()
+    print("  已写回：%d -> %d 行" % (before, text.count("\n") + 1))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/add_fail_threshold.py

@@ -0,0 +1,206 @@
+# -*- coding: utf-8 -*-
+r'''单次请求失败不再立刻判"离线"，改成连续失败 3 次才算。
+
+== 为什么 ==
+
+实测单个请求会有 2~4% 的偶发失败（4G 丢包打在一条隧道连接上，
+或者那条连接正在重连）。原来的逻辑是**一失败就 online = false**，
+于是：
+
+    手表/电脑的界面上会闪一下"已断开"
+    用户点按钮时正好撞上那一闪 -> 看起来像"又连不上了"
+
+而实际上链路 1.5~15 秒后就自己恢复了（客户端本来就有退避重试）。
+
+改成"连续失败 3 次才判离线"，效果是：
+    * 单次抖动完全不影响界面显示
+    * 真的断了（连续 3 次，至少 4.5 秒都没通）仍然会如实显示离线
+
+这不是掩盖问题，而是把"是否可用"的判断从"一次采样"改成
+"连续采样"—— 单点采样在有丢包的链路上噪声太大。
+
+== 两边都要改 ==
+
+  1. android/src/com/lanremote/watch/RelayTransport.java   （手表轮询）
+  2. windows/lanremote/relay.py                            （电脑轮询）
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(r"C:\Users\shu\Desktop\deepseekagent\LanRemote")
+BOM = b"\xef\xbb\xbf"
+
+# ---------------------------------------------------------------- 手表
+WATCH = ROOT / "android/src/com/lanremote/watch/RelayTransport.java"
+
+WATCH_CONST_OLD = "    private static final int RETRY_MAX_MS = 15000;"
+WATCH_CONST_NEW = """    private static final int RETRY_MAX_MS = 15000;
+    /**
+     * 连续失败几次才判定"离线"。
+     *
+     * <p>单次失败就报离线太敏感：4G 链路上随手就有 2~4% 的偶发失败，
+     * 而链路通常一两秒就自己恢复，界面却已经闪了一下"已断开"。
+     * 改成连续 3 次（至少 4.5 秒都不通）才判离线 ——
+     * 真的断了仍然会如实显示。
+     */
+    private static final int OFFLINE_AFTER = 3;"""
+
+WATCH_FIELD_OLD = "    private Thread pollThread;"
+WATCH_FIELD_NEW = """    private Thread pollThread;
+    /** 连续失败次数（成功一次就清零）。 */
+    private volatile int failStreak;"""
+
+# 401/403 分支
+W_401_OLD = """                if (result.code == 401 || result.code == 403) {
+                    // 会话过期（中转重启等）—— 这种可以自动重连
+                    online = false;
+                    lastError = "会话已失效，正在重新接入";"""
+W_401_NEW = """                if (result.code == 401 || result.code == 403) {
+                    // 会话过期（中转重启等）—— 这种可以自动重连。
+                    // 会话失效是明确的状态，直接标离线。
+                    online = false;
+                    lastError = "会话已失效，正在重新接入";"""
+
+# 非 200 分支
+W_OTHER_OLD = """                if (result.code != 200) {
+                    online = false;
+                    lastError = "轮询返回 " + result.code;
+                    sleep(backoff);
+                    backoff = Math.min(RETRY_MAX_MS, backoff * 2);
+                    continue;
+                }
+                online = true;
+                lastError = "";
+                backoff = RETRY_MIN_MS;"""
+W_OTHER_NEW = """                if (result.code != 200) {
+                    // 偶发的 502/504 不算断线，连续几次才算
+                    failStreak++;
+                    if (failStreak >= OFFLINE_AFTER) {
+                        online = false;
+                    }
+                    lastError = "轮询返回 " + result.code;
+                    sleep(backoff);
+                    backoff = Math.min(RETRY_MAX_MS, backoff * 2);
+                    continue;
+                }
+                online = true;
+                failStreak = 0;
+                lastError = "";
+                backoff = RETRY_MIN_MS;"""
+
+# 异常分支
+W_EXC_OLD = """            } catch (Exception exc) {
+                if (closed) {
+                    return;
+                }
+                online = false;
+                lastError = "轮询出错：" + exc.getClass().getSimpleName();
+                sleep(backoff);
+                backoff = Math.min(RETRY_MAX_MS, backoff * 2);
+            }"""
+W_EXC_NEW = """            } catch (Exception exc) {
+                if (closed) {
+                    return;
+                }
+                // 连接超时/重置很常见（隧道在重连），连续几次才算真断
+                failStreak++;
+                if (failStreak >= OFFLINE_AFTER) {
+                    online = false;
+                }
+                lastError = "轮询出错：" + exc.getClass().getSimpleName();
+                sleep(backoff);
+                backoff = Math.min(RETRY_MAX_MS, backoff * 2);
+            }"""
+
+# ---------------------------------------------------------------- 电脑
+AGENT = ROOT / "windows/lanremote/relay.py"
+
+A_CONST_OLD = "RETRY_MAX = 20.0"
+A_CONST_NEW = """RETRY_MAX = 20.0
+# 连续失败几次才判定"离线"。
+#   单次失败就报离线太敏感：4G 链路上有 2~4% 的偶发失败，
+#   而链路通常一两秒就自己恢复，界面却已经闪了一下"已断开"。
+#   连续 3 次（至少 6 秒都不通）才判离线，真的断了仍然如实显示。
+OFFLINE_AFTER = 3"""
+
+A_FAIL_OLD = """            except Exception as exc:                      # noqa: BLE001
+                self.online = False
+                self.last_error = f"{type(exc).__name__}: {exc}"
+                self._log(f"中转连接出问题：{self.last_error}")"""
+A_FAIL_NEW = """            except Exception as exc:                      # noqa: BLE001
+                # 偶发的连接超时/重置不算断线，连续几次才算
+                self._fail_streak = getattr(self, "_fail_streak", 0) + 1
+                if self._fail_streak >= OFFLINE_AFTER:
+                    self.online = False
+                self.last_error = f"{type(exc).__name__}: {exc}"
+                self._log(f"中转连接出问题（第 {self._fail_streak} 次）："
+                          f"{self.last_error}")"""
+
+A_OK_OLD = """        self.online = True
+        self.last_ok = time.time()
+        self.last_error = \"\""""
+A_OK_NEW = """        self.online = True
+        self._fail_streak = 0
+        self.last_ok = time.time()
+        self.last_error = \"\""""
+
+
+def patch(text: str, old: str, new: str, label: str) -> tuple:
+    if old not in text:
+        if new.strip() and new.splitlines()[-1].strip() in text:
+            print("  • %s 已经是新值" % label)
+            return text, True
+        print("  ✗ 没找到：%s" % label)
+        return text, False
+    if text.count(old) != 1:
+        print("  ! 出现 %d 次：%s" % (text.count(old), label))
+        return text, False
+    print("  ✓ %s" % label)
+    return text.replace(old, new, 1), True
+
+
+def main() -> int:
+    ok_all = True
+
+    print("  手表 RelayTransport.java:")
+    raw = WATCH.read_bytes()
+    text = raw.decode("utf-8-sig")
+    for old, new, label in (
+        (WATCH_CONST_OLD, WATCH_CONST_NEW, "加 OFFLINE_AFTER 常量"),
+        (WATCH_FIELD_OLD, WATCH_FIELD_NEW, "加 failStreak 字段"),
+        (W_OTHER_OLD, W_OTHER_NEW, "非 200 用连续计数"),
+        (W_EXC_OLD, W_EXC_NEW, "异常用连续计数"),
+    ):
+        text, ok = patch(text, old, new, label)
+        ok_all = ok_all and ok
+
+    if ok_all:
+        WATCH.write_text(text, encoding="utf-8", newline="\n")
+
+    print()
+    print("  电脑 relay.py:")
+    araw = AGENT.read_bytes()
+    atext = araw.decode("utf-8-sig")
+    for old, new, label in (
+        (A_CONST_OLD, A_CONST_NEW, "加 OFFLINE_AFTER 常量"),
+        (A_FAIL_OLD, A_FAIL_NEW, "异常用连续计数"),
+        (A_OK_OLD, A_OK_NEW, "成功时清零"),
+    ):
+        atext, ok = patch(atext, old, new, label)
+        ok_all = ok_all and ok
+
+    if not ok_all:
+        print()
+        print("  有失败项，没写回电脑端")
+        return 1
+
+    AGENT.write_text(atext, encoding="utf-8", newline="\n")
+    print()
+    print("  两边都改好了")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/add_monitor_to_deploy.py

@@ -0,0 +1,135 @@
+# -*- coding: utf-8 -*-
+r'''让 deploy.sh 在装新机器时把「监测单元」也装上。
+
+== 为什么必须做这一步 ==
+
+监测单元是我新加的：monitor.sh 每 60 秒查一次公网，
+挂了就叫 rescue.sh 抢救。但如果 deploy.sh 不认识它，
+**新装的机器上监测根本不会启动** —— 而且不会报任何错，
+只是静默地不跑。等网站真挂了才发现"预案没触发"，那就晚了。
+
+部署脚本里 watchdog 已经是个现成的样板（同样是 timer + oneshot），
+照着加一份即可。
+
+== 顺便 ==
+
+deploy.sh 里本来就有"包里有才装"的写法（`if [ -f ... ]`），
+这里也沿用 —— 老的服务端 zip（没有 monitor.sh）重跑部署时
+不会因为找不到文件而报错。
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+DEPLOY = ROOT / "relay" / "deploy.sh"
+
+ANCHOR = '''        systemctl enable lanremote-watchdog.timer >/dev/null 2>&1 || true'''
+
+NEW = '''        systemctl enable lanremote-watchdog.timer >/dev/null 2>&1 || true
+    fi
+
+    # ---- 网站监测单元（如果包里有）----
+    #
+    # 和看门狗的区别很重要：
+    #   看门狗  看**隧道连接数** —— 本地指标，判断"隧道自己好不好"
+    #   监测单元 看**公网 HTTP** —— 用户视角，判断"用户能不能打开"
+    #
+    # 两个都要。实测过：隧道两条实例都掉了，本机 curl 127.0.0.1 照样 200，
+    # 看门狗也可能觉得没事；只有从公网测才发现 502。
+    if [ -f "$RELAY_DIR/monitor.sh" ]; then
+        mkdir -p "$RELAY_DIR/rescue_reports"
+        chmod +x "$RELAY_DIR/monitor.sh" "$RELAY_DIR/rescue.sh" 2>/dev/null || true
+        if [ ! -f "$RELAY_DIR/rescue_knowledge.md" ]; then
+            cat > "$RELAY_DIR/rescue_knowledge.md" <<'KEOF'
+# 紧急预案知识库
+
+每次自动抢救成功，这里会追加一条「第几级奏效」。
+以后遇到同类症状，监测单元会优先试历史上奏效的那一级。
+
+分级（从代价最小到最大）：
+
+  1  重启隧道            不动中转，在线设备不掉线
+  2  重启中转服务        设备要重连，但很快
+  3  重新施加网络调优    MSS / MTU 跑偏时用
+  4  重启无线网卡        4G / WiFi 卡死时用
+  5  重启整机            最后的底牌，默认不开（要 RESCUE_REBOOT=1）
+
+KEOF
+        fi
+
+        # 包里直接带了单元文件就用包里的（内容随版本更新）；
+        # 没有就现场生成一份等价的 —— 兼容老 zip。
+        if [ -f "$RELAY_DIR/lanremote-monitor.service" ]; then
+            cp "$RELAY_DIR/lanremote-monitor.service" "$UNIT_DIR/" 2>/dev/null || true
+        else
+            write_unit "$UNIT_DIR/lanremote-monitor.service" <<EOF
+[Unit]
+Description=ykxmz 网站监测单元（每 60 秒检查公网，异常时启动紧急预案）
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=oneshot
+TimeoutStartSec=360
+ExecStart=/bin/bash $RELAY_DIR/monitor.sh
+Environment=RESCUE_REBOOT=0
+Environment=FAIL_THRESHOLD=3
+Environment=COOLDOWN=600
+StandardOutput=append:$RELAY_DIR/monitor.log
+StandardError=append:$RELAY_DIR/monitor.log
+
+[Install]
+WantedBy=multi-user.target
+EOF
+        fi
+        if [ -f "$RELAY_DIR/lanremote-monitor.timer" ]; then
+            cp "$RELAY_DIR/lanremote-monitor.timer" "$UNIT_DIR/" 2>/dev/null || true
+        else
+            write_unit "$UNIT_DIR/lanremote-monitor.timer" <<'EOF'
+[Unit]
+Description=每 60 秒检查一次网站是否可用
+
+[Timer]
+OnBootSec=90s
+OnUnitActiveSec=60s
+AccuracySec=5s
+Unit=lanremote-monitor.service
+
+[Install]
+WantedBy=timers.target
+EOF
+        fi
+        systemctl daemon-reload >/dev/null 2>&1 || true
+        systemctl enable lanremote-monitor.timer >/dev/null 2>&1 || true
+        systemctl start lanremote-monitor.timer >/dev/null 2>&1 || true
+        say "  网站监测单元已启用（每 60 秒查一次公网）"'''
+
+
+def main() -> int:
+    raw = DEPLOY.read_bytes()
+    bom = raw.startswith(b"\xef\xbb\xbf")
+    text = raw.decode("utf-8-sig")
+
+    if "lanremote-monitor.timer" in text:
+        print("  · deploy.sh 已经加过了")
+        return 0
+    if ANCHOR not in text:
+        print("  ✗ 找不到锚点")
+        return 1
+    if text.count(ANCHOR) != 1:
+        print("  ! 锚点出现 %d 次" % text.count(ANCHOR))
+    text = text.replace(ANCHOR, NEW, 1)
+
+    # 原来 watchdog 那个 if 块的 fi 会被我们的 NEW 提前收掉，
+    # 所以要把后面多余的那个 fi 去掉一个。先看看形状。
+    import re
+    DEPLOY.write_bytes((b"\xef\xbb\xbf" if bom else b"")
+                       + text.encode("utf-8"))
+    print("  ✓ deploy.sh 加了监测单元的安装")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/add_rescue_section.py

@@ -0,0 +1,261 @@
+# -*- coding: utf-8 -*-
+r'''后台加一个「抢救报告」分区。
+
+用户要求：
+    「如果紧急预案未能解决，则将问题打包成 .txt，然后在后台加一个分区
+      专门放还有下载这个 txt」
+
+rescue.sh 抢救失败时会往 relay/rescue_reports/ 写一份诊断报告 .txt。
+这里让后台能：
+    * 列出这些报告（时间、大小、一句话结论）
+    * 点一下下载看内容
+
+== 为什么不复用 /download/ ==
+
+/download/ 是**给用户**的（安装包、APK），带 cf 长缓存
+（max-age=604800, immutable）——因为文件名带版本号、内容永不改变。
+
+抢救报告正相反：内容会变、是给管理员看的、不该被边缘缓存。
+所以单独开一条 /rescue/<名字>，发 no-store。
+'''
+from __future__ import annotations
+
+import html
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+RELAY = ROOT / "relay" / "relay.py"
+ADMIN = ROOT / "relay" / "admin.py"
+
+
+def patch(path: Path, pairs, label: str):
+    raw = path.read_bytes()
+    had_bom = raw.startswith(b"\xef\xbb\xbf")
+    text = raw.decode("utf-8-sig")
+    results = []
+    for old, new, what in pairs:
+        if old not in text:
+            results.append(("✗", what, "找不到锚点"))
+            continue
+        if text.count(old) != 1:
+            results.append(("!", what, "锚点 %d 处" % text.count(old)))
+        text = text.replace(old, new, 1)
+        results.append(("✓", what, ""))
+    print("  ── %s ──" % label)
+    for m, w, why in results:
+        print("    %s %s%s" % (m, w, ("  —— " + why) if why else ""))
+    if any(m == "✗" for m, _w, _y in results):
+        return False
+    path.write_bytes((b"\xef\xbb\xbf" if had_bom else b"")
+                     + text.encode("utf-8"))
+    return True
+
+
+# ===========================================================================
+#  relay.py
+# ===========================================================================
+
+RELAY_LIST = '''
+# 抢救报告目录。rescue.sh 抢救失败时往这里写 .txt 诊断报告。
+# 和 downloads/ 分开：那个是给用户的安装包（带长缓存），
+# 这个是给管理员看的诊断（必须不缓存）。
+RESCUE_DIR = Path(__file__).resolve().parent / "rescue_reports"
+RESCUE_KEEP = 30          # 只保留最近 30 份（460MB 的小机器，别塞满）
+
+
+def _safe_rescue_name(name: str) -> str:
+    """校验抢救报告文件名。只允许 <时间戳>.txt 这种形状。"""
+    name = (name or "").strip()
+    if not name or len(name) > 80:
+        return ""
+    if "/" in name or "\\\\" in name or ".." in name:
+        return ""
+    if not name.endswith(".txt"):
+        return ""
+    for ch in name:
+        if ch.isalnum() or ch in "._-":
+            continue
+        return ""
+    return name
+
+
+def _list_rescue_reports() -> list:
+    """列出抢救报告（按时间倒序）。
+
+    顺带读每个文件的前几行，抽出结论 —— 后台列表上直接显示，
+    不用一个个点进去看。
+    """
+    items = []
+    try:
+        if not RESCUE_DIR.is_dir():
+            return items
+        for entry in sorted(RESCUE_DIR.glob("*.txt"), reverse=True):
+            if not entry.is_file():
+                continue
+            safe = _safe_rescue_name(entry.name)
+            if not safe:
+                continue
+            stat = entry.stat()
+            summary = ""
+            try:
+                with entry.open("r", encoding="utf-8", errors="replace") as fh:
+                    head = fh.read(1200)
+                for line in head.splitlines():
+                    s = line.strip()
+                    if s.startswith("判断："):
+                        summary = s.replace("判断：", "").strip()
+                        break
+                if not summary:
+                    for line in head.splitlines():
+                        s = line.strip()
+                        if s.startswith("公网 ") and "->" in s:
+                            summary = s
+                            break
+            except OSError:
+                pass
+            items.append({
+                "name": entry.name,
+                "size": stat.st_size,
+                "mtime": stat.st_mtime,
+                "summary": summary[:120],
+            })
+    except OSError:
+        return items
+    items.sort(key=lambda i: i["mtime"], reverse=True)
+    return items[:RESCUE_KEEP]
+
+'''
+
+ADMIN_CALL = '''        admin_path=ADMIN_PATH,'''
+
+ADMIN_CALL_NEW = '''        admin_path=ADMIN_PATH,
+        rescue_fn=_list_rescue_reports,'''
+
+# 下载路由（GET）：插在 /download/ 之前
+RESCUE_ROUTE_ANCHOR = '''        if path.startswith("/download/"):
+            wanted = urllib.parse.unquote(path[len("/download/"):])
+            safe = _safe_download_name(wanted)'''
+
+RESCUE_ROUTE = '''        if path.startswith("/rescue/"):
+            # 抢救报告下载。单独一条路由，**不发缓存头** ——
+            # 内容会变，而且不该让 Cloudflare 边缘留着。
+            wanted = urllib.parse.unquote(path[len("/rescue/"):])
+            safe = _safe_rescue_name(wanted)
+            if not safe:
+                self._json(400, {"ok": False, "error": "文件名不合法"})
+                return
+            target = RESCUE_DIR / safe
+            if not target.is_file():
+                self._json(404, {"ok": False, "error": "没有这份报告"})
+                return
+            try:
+                body = target.read_bytes()
+            except OSError as exc:
+                self._json(500, {"ok": False, "error": f"读不到: {exc}"})
+                return
+            self.send_response(200)
+            self.send_header("Content-Type", "text/plain; charset=utf-8")
+            self.send_header("Content-Length", str(len(body)))
+            quoted = urllib.parse.quote(safe)
+            self.send_header(
+                "Content-Disposition",
+                f"attachment; filename*=UTF-8''{quoted}")
+            self.send_header("Cache-Control", "no-store")
+            self.end_headers()
+            self.wfile.write(body)
+            return
+
+'''
+
+# ===========================================================================
+#  admin.py
+# ===========================================================================
+
+ADMIN_SIG = '''def render_admin(snap: dict, public: str, admin_path: str, codes: int,
+                 downloads_fn) -> str:'''
+
+ADMIN_SIG_NEW = '''def render_admin(snap: dict, public: str, admin_path: str, codes: int,
+                 downloads_fn, rescue_fn=None) -> str:'''
+
+ADMIN_CARD_ANCHOR = '''    <div class="tool">
+      <h4>下载区</h4>
+      <div class="d">官网下载按钮指向这里的文件。</div>
+      <div id="dlBody">%(dl)s</div>
+    </div>
+  </div>'''
+
+ADMIN_CARD = '''    <div class="tool">
+      <h4>下载区</h4>
+      <div class="d">官网下载按钮指向这里的文件。</div>
+      <div id="dlBody">%(dl)s</div>
+    </div>
+    <div class="tool">
+      <h4>抢救报告</h4>
+      <div class="d">网站挂了、自动预案也没救回来时，机器会把现场
+        打包成一份 txt 放在这里。点开看看是哪一段断了。</div>
+      <div id="rescueBody">%(rescue)s</div>
+    </div>
+  </div>'''
+
+
+def _rescue_rows(items: list) -> str:
+    """抢救报告列表的 HTML。照 dl_rows 的风格（页面里直接渲染）。"""
+    if not items:
+        return ('<div class="out">还没有报告 —— 说明网站一直没出过'
+                '「自动救不回来」的问题。</div>')
+    import time as _t
+    import urllib.parse as _up
+    rows = []
+    for it in items:
+        when = _t.strftime("%m-%d %H:%M", _t.localtime(it["mtime"]))
+        size = it["size"] / 1024
+        size_s = ("%.1f KB" % size) if size >= 1 else ("%d B" % it["size"])
+        summary = html.escape(it.get("summary") or "（没有结论行）")
+        href = "/rescue/" + _up.quote(it["name"])
+        rows.append(
+            '<div class="dlrow"><span class="nm">'
+            '<a href="%s" style="color:#0a84ff">%s</a>'
+            '<span style="color:#6b7280;font-size:12px;margin-left:8px">'
+            '%s</span></span>'
+            '<span class="sz" style="max-width:46%%;text-align:right">'
+            '%s</span></div>'
+            % (href, when, size_s, summary))
+    return "".join(rows)
+
+
+def main() -> int:
+    ok = True
+
+    ok &= patch(RELAY, [
+        ("DOWNLOADS_DIR = Path(__file__).resolve().parent / \"downloads\"",
+         "DOWNLOADS_DIR = Path(__file__).resolve().parent / \"downloads\"\n"
+         + RELAY_LIST, "加 rescue_reports 列表函数"),
+        (RESCUE_ROUTE_ANCHOR, RESCUE_ROUTE + RESCUE_ROUTE_ANCHOR,
+         "加 /rescue/ 下载路由（no-store）"),
+        (ADMIN_CALL, ADMIN_CALL_NEW, "把 rescue_fn 传给后台页"),
+    ], "relay.py")
+
+    ok &= patch(ADMIN, [
+        (ADMIN_SIG, ADMIN_SIG_NEW, "render_admin 加 rescue_fn 参数"),
+        (ADMIN_CARD_ANCHOR, ADMIN_CARD, "后台加「抢救报告」卡片"),
+        # 算报告列表（照 dl_rows 的写法）
+        ('''    return """<!doctype html>''',
+         '''    # 抢救报告列表（和下载区同样在页面里直接渲染，不用 JS 拉）
+    try:
+        rescue_items = rescue_fn() if rescue_fn else []
+    except Exception:                                     # noqa: BLE001
+        rescue_items = []
+    rescue_rows = _rescue_rows(rescue_items)
+
+    return """<!doctype html>''',
+         "算抢救报告列表"),
+        ('"dl": dl_rows,', '"dl": dl_rows,\n        "rescue": rescue_rows,',
+         "把报告列表塞进模板"),
+    ], "admin.py")
+
+    return 0 if ok else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/add_settings_window.py

@@ -0,0 +1,406 @@
+# -*- coding: utf-8 -*-
+r'''让「双击 exe」能打开设置窗口，并能设中转服务器。
+
+== 用户报的两个问题 ==
+
+问题 1：「被控端再安装时要能设置中转服务器，这是第一次设置」
+        —— SetupWindow 只有配对码/开机自启/放行防火墙，**没有中转**。
+
+问题 2：「后面要想设置就要去点击 exe 去改配对码和开关新设备连接
+        还有中转服务器，现在如果再运行双击 exe 没反应，没运行也一样」
+
+        看 run_agent.py 的 main() 最后几行：
+
+            if not store.get("setup_done", False):
+                return run_setup(store)
+            # 已经设置过：直接静默，屏幕上什么都不出现
+            return run_silent(store, None)
+
+        —— 装完之后双击**永远静默**，什么窗口都不弹。
+        而且如果已经有一个实例在跑，InstanceLock 会直接 return，
+        连日志都不输出。
+
+== 改法 ==
+
+1. SetupWindow 加一个 mode：
+       mode="first"     第一次设置（保持老行为：防火墙+自启+转静默）
+       mode="settings"  已装好，只改配置
+
+2. 窗口加两样东西：
+       * 中转服务器地址（可不填；只在一个 WiFi 里用就不需要）
+       * 允许新设备接入（开关）
+
+3. main() 改成：
+       --setup             -> settings 模式
+       --silent            -> 静默（开机自启/安装包用，行为不变）
+       没参数 + 没设置过    -> first 模式
+       没参数 + 已经设置过  -> **settings 模式**（不再是静默）
+
+4. 已经在跑的时候：不再"直接 exit 什么都不显示"，而是
+   提示一句"被控端正在后台运行"，然后**照样打开设置窗口**。
+   保存后重启后台实例让设置生效。
+'''
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+UI = ROOT / "windows" / "lanremote" / "ui.py"
+RUN = ROOT / "windows" / "run_agent.py"
+
+
+def patch(path: Path, pairs, label: str) -> bool:
+    text = path.read_text(encoding="utf-8")
+    for old, new in pairs:
+        if old not in text:
+            print("  ✗ %s：找不到锚点 %r" % (label, old[:60]))
+            return False
+        if text.count(old) != 1:
+            print("  ! %s：锚点出现 %d 次" % (label, text.count(old)))
+        text = text.replace(old, new, 1)
+    path.write_text(text, encoding="utf-8", newline="\n")
+    print("  ✓ %s" % label)
+    return True
+
+
+def main() -> int:
+    ok = True
+
+    # ================================================================
+    # 一、ui.py：加 mode + 中转字段 + 接入开关
+    # ================================================================
+    print("── ui.py ──")
+
+    ok &= patch(UI, [(
+        '''    def __init__(self, store, suggested: str = ""):
+        self.store = store
+        self.suggested = (suggested or store.pairing_code()
+                          or store.new_pairing_code())
+        self.result: dict | None = None''',
+        '''    def __init__(self, store, suggested: str = "",
+                 mode: str = "first"):
+        """mode:
+             "first"     第一次设置（走防火墙 + 自启 + 转静默）
+             "settings"  已装好，只改配置（配对码/中转/接入开关）
+        """
+        self.store = store
+        self.mode = mode if mode in ("first", "settings") else "first"
+        self.suggested = (suggested or store.pairing_code()
+                          or store.new_pairing_code())
+        self.result: dict | None = None'''
+    )], "SetupWindow 加 mode")
+
+    # 标题按模式分
+    ok &= patch(UI, [(
+        '''        self.root.title("ykxmz · 第一次设置")''',
+        '''        self.root.title("ykxmz · " + (
+            "第一次设置" if self.mode == "first" else "设置"))'''
+    )], "窗口标题按模式分")
+
+    # 副标题
+    ok &= patch(UI, [(
+        '''        tk.Label(titles, text="远程控制 · 第一次设置", bg=BG, fg=DIM,
+                 font=FONT_SUB).pack(anchor="w")''',
+        '''        tk.Label(titles,
+                 text=("远程控制 · 第一次设置" if self.mode == "first"
+                       else "远程控制 · 设置"),
+                 bg=BG, fg=DIM,
+                 font=FONT_SUB).pack(anchor="w")'''
+    )], "副标题按模式分")
+
+    # 在配对码卡片之后插入「中转服务器」卡片
+    ok &= patch(UI, [(
+        '''        self.status = tk.Label(inner, text="", bg=CARD, fg=DANGER,
+                               font=FONT_SMALL, wraplength=330,
+                               justify="left", anchor="w")
+        self.status.pack(fill="x", pady=(6, 0))
+''',
+        '''        self.status = tk.Label(inner, text="", bg=CARD, fg=DANGER,
+                               font=FONT_SMALL, wraplength=330,
+                               justify="left", anchor="w")
+        self.status.pack(fill="x", pady=(6, 0))
+
+        # ================= 中转服务器卡片 =================
+        # 用户要求：安装时要能设中转服务器；装完之后双击 exe 也能回来改。
+        #
+        # 为什么不填也能用：手表和电脑在同一个 WiFi 时走局域网直连，
+        # 根本不需要中转。只有"在办公室管教室"这种跨网络场景才要填。
+        relay_card = self._card(page)
+        relay_card.pack(fill="x", pady=(12, 0))
+        relay_inner = tk.Frame(relay_card.winfo_children()[0], bg=CARD)
+        relay_inner.pack(fill="x", padx=16, pady=14)
+
+        tk.Label(relay_inner, text="中转服务器（可以不填）", bg=CARD, fg=FG,
+                 font=FONT_LABEL).pack(anchor="w")
+
+        self.relay_entry = tk.Entry(
+            relay_inner, bg="#f6f8fa", fg=FG, relief="flat",
+            font=FONT_SUB, insertbackground=ACCENT)
+        self.relay_entry.pack(fill="x", pady=(8, 0), ipady=6)
+        _saved_relay = str(self.store.get("relay_url", "") or "").strip()
+        if _saved_relay:
+            self.relay_entry.insert(0, _saved_relay)
+
+        tk.Label(relay_inner,
+                 text="手表和电脑在同一个 WiFi 时不需要填 —— 会直接走"
+                      "局域网，几十毫秒。\\n"
+                      "要在别的地方（比如办公室）管这台电脑时才填，"
+                      "填你自己那台中转服务器的地址。",
+                 bg=CARD, fg=MUTED, font=FONT_SMALL, justify="left",
+                 wraplength=396).pack(anchor="w", pady=(8, 0))
+
+        self.relay_status = tk.Label(relay_inner, text="", bg=CARD,
+                                     fg=DANGER, font=FONT_SMALL,
+                                     wraplength=396, justify="left",
+                                     anchor="w")
+        self.relay_status.pack(fill="x", pady=(6, 0))
+'''
+    )], "插入中转服务器卡片")
+
+    # 选项卡片里加「允许新设备接入」（只在 settings 模式显示）
+    ok &= patch(UI, [(
+        '''        self.var_firewall = tk.BooleanVar(value=True)
+        self._check(opt_inner, "放行防火墙", self.var_firewall,
+                    "会弹一次管理员确认，然后黑窗口一闪而过")''',
+        '''        # 「允许新设备接入」只在设置模式给 ——
+        # 第一次设置时当然是允许的（不然手表连不上）。
+        if self.mode == "settings":
+            self.var_allow_new = tk.BooleanVar(
+                value=bool(self.store.get("allow_new_pairing", True)))
+            self._check(opt_inner, "允许新设备接入", self.var_allow_new,
+                        "关掉之后，只有已经配对过的设备能连上；"
+                        "新设备会被拒绝")
+        else:
+            self.var_allow_new = None
+
+        self.var_firewall = tk.BooleanVar(
+            value=(self.mode == "first"))
+        if self.mode == "first":
+            self._check(opt_inner, "放行防火墙", self.var_firewall,
+                        "会弹一次管理员确认，然后黑窗口一闪而过")'''
+    )], "加「允许新设备接入」选项")
+
+    # 结果里带上 relay / allow_new
+    ok &= patch(UI, [(
+        '''        self.result = {
+            "code": cleaned,
+            "autostart": bool(self.var_auto.get()),
+            "firewall": bool(self.var_firewall.get()),
+        }''',
+        '''        # 中转地址：允许空（空 = 只走局域网）。
+        # 填了的话做一次最基本的格式检查，免得用户把域名打错还找不到原因。
+        relay = self.relay_entry.get().strip()
+        if relay:
+            if not relay.startswith(("http://", "https://")):
+                relay = "https://" + relay
+            # 只留 协议://主机[:端口]，去掉多余路径
+            _m = re.match(r"^(https?://[^/\\s]+)", relay)
+            if not _m:
+                self._set_relay_status("中转地址看着不对，检查一下", DANGER)
+                return
+            relay = _m.group(1).rstrip("/")
+        self.result = {
+            "code": cleaned,
+            "autostart": bool(self.var_auto.get()),
+            "firewall": bool(self.var_firewall.get()),
+            "relay": relay,
+            "allow_new": (None if self.var_allow_new is None
+                          else bool(self.var_allow_new.get())),
+        }'''
+    )], "结果带 relay / allow_new")
+
+    # 需要一个 _set_relay_status
+    ok &= patch(UI, [(
+        '''    def _cancel(self) -> None:
+        self.result = None''',
+        '''    def _set_relay_status(self, text: str, color: str) -> None:
+        try:
+            self.relay_status.configure(text=text, fg=color)
+        except tk.TclError:
+            pass
+
+    def _cancel(self) -> None:
+        self.result = None'''
+    )], "加 _set_relay_status")
+
+    # ui.py 需要 re
+    text = UI.read_text(encoding="utf-8")
+    if not re.search(r"^import re\b", text, re.M):
+        m = re.search(r"^(?:import |from )", text, re.M)
+        text = text[:m.start()] + "import re\n" + text[m.start():]
+        UI.write_text(text, encoding="utf-8", newline="\n")
+        print("  ✓ ui.py 补 import re")
+    else:
+        print("  • ui.py 已有 import re")
+
+    # ================================================================
+    # 二、run_agent.py：双击打开设置窗口
+    # ================================================================
+    print()
+    print("── run_agent.py ──")
+
+    ok &= patch(RUN, [(
+        '''    # 第一次运行：设置窗口 → 修防火墙 → 静默
+    if not store.get("setup_done", False):
+        return run_setup(store)
+
+    # 已经设置过：直接静默，屏幕上什么都不出现
+    return run_silent(store, None)''',
+        '''    # 第一次运行：设置窗口 → 修防火墙 → 静默
+    if not store.get("setup_done", False):
+        return run_setup(store)
+
+    # 已经设置过、而且没给参数 —— 说明用户是**双击 exe**。
+    #
+    # 以前这里是 `return run_silent(store, None)`：直接后台跑，
+    # 屏幕上什么都不出现。用户想改配对码 / 中转地址 / 接入开关时
+    # 双击毫无反应，只能去翻命令行参数。
+    #
+    # 现在双击 = 打开设置窗口。后台运行走显式 --silent
+    # （开机自启和安装包都用的 --silent，所以不受影响）。
+    return run_settings(store)'''
+    )], "main() 双击改为打开设置窗口")
+
+    # 加 run_settings 函数（放在 run_setup 之后）
+    if "def run_settings(" not in RUN.read_text(encoding="utf-8"):
+        text = RUN.read_text(encoding="utf-8")
+        anchor = "def main(argv=None) -> int:"
+        if anchor not in text:
+            print("  ✗ 找不到 main()")
+            ok = False
+        else:
+            helper = '''def run_settings(store) -> int:
+    """双击 exe 时打开的设置窗口。
+
+    和 run_setup 的区别：
+        run_setup     第一次装：走防火墙 + 开机自启 + 最后转静默
+        run_settings  已装好：只改配置，改完把后台实例重启一下让设置生效
+
+    为什么"已经有一个实例在跑"时也要照样开窗口：
+        以前 InstanceLock 拿不到就直接 return，用户双击后**什么都看不到**，
+        以为程序坏了。现在开窗、改完、重启后台实例。
+    """
+    from lanremote.ui import SetupWindow
+
+    running = not InstanceLock.probe_free()
+
+    window = SetupWindow(store, mode="settings").show()
+    if window is None:
+        return 0                      # 用户关掉了，什么都不改
+
+    changed = []
+
+    # ---- 配对码 ----
+    if window.get("code") and window["code"] != store.pairing_code():
+        try:
+            store.set_pairing_code(window["code"])
+            changed.append("配对码")
+        except ValueError as exc:
+            print(f"设置配对码失败：{exc}")
+            return 2
+
+    # ---- 中转服务器（空 = 只走局域网）----
+    relay = str(window.get("relay", "") or "").strip()
+    if relay != str(store.get("relay_url", "") or "").strip():
+        store.set("relay_url", relay)
+        changed.append("中转地址")
+
+    # ---- 允许新设备接入 ----
+    allow_new = window.get("allow_new")
+    if allow_new is not None and bool(allow_new) != bool(
+            store.get("allow_new_pairing", True)):
+        store.set("allow_new_pairing", bool(allow_new))
+        changed.append("接入开关")
+
+    # ---- 开机自启 ----
+    try:
+        from lanremote.autostart import enable, disable, is_enabled
+        want = bool(window.get("autostart"))
+        if want != bool(is_enabled()):
+            (enable if want else disable)()
+            changed.append("开机自启")
+    except Exception:                                     # noqa: BLE001
+        pass
+
+    # ---- 让后台实例重新读配置 ----
+    if changed and running:
+        _restart_background(store)
+        print("已保存：" + "、".join(changed) + "（后台实例已重启）")
+    elif changed:
+        print("已保存：" + "、".join(changed))
+    else:
+        print("没有改动")
+    return 0
+
+
+def _restart_background(store) -> None:
+    """把正在跑的后台实例停掉，再用新配置起一个。
+
+    为什么要重启而不是"让它自己重读"：
+        allow_new_pairing 是启动时读进 server.pairing_enabled 的，
+        中转地址也是启动时连的。文件改了但进程里还是旧值，
+        用户会以为设置没生效。
+    """
+    import subprocess
+    # 只杀"没有窗口"的那个（后台实例）。taskkill 按镜像名杀会连自己一起杀，
+    # 所以这里用 wmic/powershell 过滤命令行里带 --silent 的。
+    try:
+        subprocess.run(
+            ["powershell", "-NoProfile", "-Command",
+             "Get-CimInstance Win32_Process -Filter \\"Name='ykxmz.exe'\\" | "
+             "Where-Object { $_.CommandLine -match '--silent' } | "
+             "ForEach-Object { Stop-Process -Id $_.ProcessId -Force }"],
+            capture_output=True, timeout=20)
+    except Exception:                                     # noqa: BLE001
+        pass
+    time.sleep(1.2)
+    # 用 --silent 重新起一个，完全脱离本进程
+    try:
+        exe = sys.executable
+        subprocess.Popen([exe, "--silent"],
+                         creationflags=getattr(subprocess,
+                                               "DETACHED_PROCESS", 0),
+                         close_fds=True)
+    except Exception:                                     # noqa: BLE001
+        pass
+
+
+'''
+            text = text.replace(anchor, helper + anchor, 1)
+            RUN.write_text(text, encoding="utf-8", newline="\n")
+            print("  ✓ 加 run_settings()")
+    else:
+        print("  • run_settings 已存在")
+
+    # --setup 也走 settings 模式
+    ok &= patch(RUN, [(
+        '''    # --setup：重新设置
+    if args.setup:
+        return run_setup(store)''',
+        '''    # --setup：重新打开设置窗口（和双击等效）
+    if args.setup:
+        return run_settings(store)'''
+    )], "--setup 走 settings 模式")
+
+    # ================================================================
+    print()
+    import ast
+    bad = []
+    for f in (UI, RUN):
+        try:
+            ast.parse(f.read_text(encoding="utf-8"))
+        except SyntaxError as exc:
+            bad.append("%s: 第 %s 行 %s" % (f.name, exc.lineno, exc.msg))
+    if bad:
+        print("  ✗ 语法错：")
+        for b in bad:
+            print("      %s" % b)
+        return 1
+    print("  ✓ 两个文件语法都通过")
+    return 0 if ok else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/add_site_cache.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+r'''给官网首页加 60 秒缓存。
+
+（download 那处已经用 edit 工具改好了：no-store ->
+ public,max-age=604800,immutable。）
+
+首页原来走 _send 的默认 Cache-Control: no-store，
+每次刷新都穿隧道回 4G 源站。加 60 秒缓存：
+  * 挡住"刷新就重新回源"的浪费
+  * 又不会让页面上的当前版本号 / 下载按钮过期太久
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+SRC = Path(r"C:\Users\shu\Desktop\deepseekagent\LanRemote\relay\relay.py")
+
+
+def main() -> int:
+    text = SRC.read_text(encoding="utf-8")
+
+    marker = 'self._send(200, _site_page().encode("utf-8"),\n'
+    idx = text.find(marker)
+    if idx < 0:
+        print("  ✗ 找不到首页的 _send")
+        return 1
+
+    # 打印现场，确认空白
+    end = text.find("\n", text.find("return", idx))
+    print("  现场:")
+    for line in text[idx:end + 1].splitlines():
+        print("    %r" % line)
+
+    old = ('self._send(200, _site_page().encode("utf-8"),\n'
+           '                      "text/html; charset=utf-8")')
+    new = ('# 缓存 60 秒：挡住"刷新就重新回源"的浪费，\n'
+           '            # 又不会让页面上的当前版本号和下载按钮过期太久。\n'
+           '            self._send(200, _site_page().encode("utf-8"),\n'
+           '                       "text/html; charset=utf-8",\n'
+           '                       {"Cache-Control": "public, max-age=60"})')
+
+    if old not in text:
+        print()
+        print("  ✗ 精确串还是没匹配上（看上面的 repr 对齐空白）")
+        return 1
+
+    text = text.replace(old, new, 1)
+    SRC.write_text(text, encoding="utf-8", newline="\n")
+    print()
+    print("  ✓ 已加首页缓存")
+
+    # 复核
+    for i, line in enumerate(
+            SRC.read_text(encoding="utf-8").splitlines(), 1):
+        if "max-age=60" in line:
+            print("    第 %d 行: %s" % (i, line.strip()))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/add_verify_stage.py

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+r'''给 verify_all.ps1 追加阶段 —— **不能用 PowerShell heredoc**。
+
+== 为什么单独写这个脚本 ==
+
+我这一轮在 PowerShell 里用 `python -c @"..."@` 写 Python 代码
+去改 verify_all.ps1，结果 **`$stageOut` 和 `$root` 被 PowerShell
+当成变量给展开了**（`@"..."@` 是插值字符串），写进去变成：
+
+     = & python (Join-Path  "_tests\check_version_consistency.py") 2>&1
+        Show-Fails
+    Record "版本号一致性" (0 -eq 0)
+
+整个脚本直接语法错。**同一个坑踩了两次**（3a7 和 3a8）。
+
+教训：凡是给 .ps1 加含 `$` 的内容，一律**写 Python 脚本文件再跑**，
+不要用 `python -c @"..."@`。
+
+用法：
+    python _build/add_verify_stage.py <锚点文字> <阶段号> <标题> <脚本相对路径> <Record 名>
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+SUITE = ROOT / "_tests" / "verify_all.ps1"
+
+
+def main() -> int:
+    if len(sys.argv) < 6:
+        print(__doc__)
+        return 1
+    anchor_text, stage_no, title, script_rel, record_name = sys.argv[1:6]
+
+    raw = SUITE.read_bytes()
+    had_bom = raw.startswith(b"\xef\xbb\xbf")
+    text = raw.decode("utf-8-sig")
+
+    if script_rel in text:
+        print("  已经注册过了（%s 里提到了 %s）" % (SUITE.name, script_rel))
+        return 0
+
+    lines = text.splitlines()
+    idx = None
+    for i, ln in enumerate(lines):
+        if ln.startswith("Record") and anchor_text in ln:
+            idx = i
+            break
+    if idx is None:
+        print("  ✗ 找不到锚点（Record 行含 %r）" % anchor_text)
+        print("  现有 Record 行：")
+        for i, ln in enumerate(lines):
+            if ln.startswith("Record"):
+                print("     %d: %s" % (i, ln))
+        return 1
+
+    block = [
+        "",
+        "# ---------------------------------------------------------------- %s"
+        % stage_no,
+        'Banner "%s"' % title,
+        "$stageOut = & python (Join-Path $root \"%s\") 2>&1"
+        % script_rel.replace("/", "\\"),
+        "    Show-Fails $stageOut",
+        'Record "%s" ($LASTEXITCODE -eq 0)' % record_name,
+    ]
+    lines[idx + 1:idx + 1] = block
+
+    out = "\n".join(lines) + "\n"
+    SUITE.write_bytes((b"\xef\xbb\xbf" if had_bom else b"") + out.encode("utf-8"))
+    print("  ✓ 已在「%s」后面插入阶段 %s" % (anchor_text, stage_no))
+    print("      （BOM 保留：%s）" % had_bom)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/add_watch_settings.py

@@ -0,0 +1,401 @@
+# -*- coding: utf-8 -*-
+r'''安卓端：中转地址改成"手动填" + 加一个设置页。
+
+== 用户报的问题 ==
+
+「安卓端为什么还是默认填的我的中转站，以后改成手动填，
+  安卓端加一个设置，各种设置就在这里面调」
+
+== 根因 ==
+
+代码里的默认值**已经改成空**了：
+
+    private static final String DEFAULT_RELAY_URL = "";
+
+但你手表上看到的还是 `https://relay.xxmxxs.top` —— 因为
+**老版本 1.5.0 把作者的域名硬编码成默认值**（git 历史里查到了）：
+
+    private static final String DEFAULT_RELAY_URL = "https://relay.xxmxxs.top";
+
+第一次运行它就 `setRelayUrl(默认值)` 存进了 SharedPreferences。
+装新 APK **不会清偏好设置**，所以那个值一直留着。
+
+**用户从来没"选"过这个地址** —— 是程序硬塞的。所以正确做法是
+**一次性迁移**：如果存的就是当时内置的那个域名，当成没设过，清掉。
+
+== 做的事 ==
+
+1. 迁移：把老版本硬塞的那个域名从偏好里清掉
+2. 新增「设置」页，把散落的设置收进来：
+      * 中转服务器（手动填 / 清空）
+      * 记住的配对码（看 / 清）
+      * 已配对设备（看数量 / 清空）
+      * 关于（版本号、连接方式说明）
+3. 首页那个「中转设置（跨网络用）」按钮改成「设置」，进设置页
+4. settingsPanel 纳入 showOnly()，避免再出现"面板漏藏"那类问题
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+SRC = (ROOT / "android" / "src" / "com" / "lanremote" / "watch"
+       / "MainActivity.java")
+
+
+# ======================================================================
+#  1. 迁移 + 面板字段
+# ======================================================================
+MIGRATION = '''    /**
+     * 老版本硬塞进来的中转地址，要清掉。
+     *
+     * <p>1.5.0 那版把作者的域名写死成默认值：
+     * <pre>
+     *     private static final String DEFAULT_RELAY_URL = "https://relay.xxmxxs.top";
+     * </pre>
+     * 而且第一次运行就存进了 SharedPreferences。装新 APK 不会清偏好，
+     * 所以用户会看到「默认还是那个中转站」—— 其实他从来没选过。
+     *
+     * <p>现在默认值是空串（跨网络要自己填）。这里做一次性迁移：
+     * 存的值如果正好是当时内置的那个域名，就当成没设过，清掉。
+     *
+     * <p>⚠ 只在**完全等于**内置值时清 —— 用户自己手填的地址不能动。
+     */
+    private static final String[] LEGACY_BAKED_IN_RELAYS = {
+        "https://relay.xxmxxs.top",
+        "http://relay.xxmxxs.top",
+    };
+
+    private void migrateLegacyRelay() {
+        String saved = getSharedPreferences("lanremote", MODE_PRIVATE)
+                .getString("relay_url", "");
+        if (saved == null) {
+            return;
+        }
+        String trimmed = saved.trim();
+        for (String legacy : LEGACY_BAKED_IN_RELAYS) {
+            if (legacy.equalsIgnoreCase(trimmed)) {
+                // 这是老版本硬塞的，不是用户选的 —— 清掉，让他自己填
+                getSharedPreferences("lanremote", MODE_PRIVATE).edit()
+                        .remove("relay_url").apply();
+                appendLog("已清掉旧版本内置的中转地址（不是你自己填的）");
+                return;
+            }
+        }
+    }
+
+'''
+
+
+SETTINGS_BUILD = '''    /**
+     * 「设置」页。用户要求："安卓端加一个设置，各种设置就在这里面调"。
+     *
+     * <p>以前设置散在首页（一个「中转设置」按钮）和别处，
+     * 现在统一收到这里。
+     */
+    private void buildSettingsPanel() {
+        settingsPanel = new FrameLayout(this);
+        settingsPanel.setBackgroundColor(C_BG);
+
+        ScrollView scroll = new ScrollView(this);
+        scroll.setBackgroundColor(C_BG);
+        LinearLayout box = new LinearLayout(this);
+        box.setOrientation(LinearLayout.VERTICAL);
+        box.setPadding(dp(10), dp(12), dp(10), dp(12));
+        scroll.addView(box, new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT));
+        settingsPanel.addView(scroll, new FrameLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.MATCH_PARENT));
+
+        LinearLayout top = new LinearLayout(this);
+        top.setOrientation(LinearLayout.HORIZONTAL);
+        top.setGravity(Gravity.CENTER_VERTICAL);
+        box.addView(top, new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT));
+
+        TextView title = new TextView(this);
+        title.setText("设置");
+        title.setTextColor(C_FG);
+        title.setTextSize(TypedValue.COMPLEX_UNIT_SP, 16);
+        title.setTypeface(null, android.graphics.Typeface.BOLD);
+        top.addView(title, new LinearLayout.LayoutParams(
+                0, ViewGroup.LayoutParams.WRAP_CONTENT, 1f));
+        top.addView(smallButton("返回", C_CARD, new Runnable() {
+            @Override
+            public void run() {
+                hideSettingsPanel();
+            }
+        }));
+
+        // ================= 中转服务器 =================
+        settingsRelayValue = new TextView(this);
+        settingsRelayValue.setTextColor(C_DIM);
+        settingsRelayValue.setTextSize(TypedValue.COMPLEX_UNIT_SP, 12);
+        settingsRelayValue.setPadding(0, dp(6), 0, dp(4));
+
+        box.addView(sectionTitle("中转服务器"));
+        box.addView(hintText("手表和电脑不在同一个网络时（比如在办公室管教室）"
+                + "才需要填。填你自己那台的地址，比如 relay.你的域名。\\n"
+                + "只在一个 WiFi 里用就留空 —— 那样直接连，最快也不耗流量。"));
+        box.addView(settingsRelayValue);
+
+        Button editRelay = bigButton("填写中转服务器", C_ACCENT, 14);
+        editRelay.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                promptRelayUrl();
+            }
+        });
+        box.addView(editRelay);
+
+        Button clearRelay = bigButton("清空中转服务器（只走局域网）", C_CARD, 13);
+        clearRelay.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                setRelayUrl("");
+                refreshSettingsPanel();
+                toast("已清空 —— 以后只走局域网");
+            }
+        });
+        box.addView(clearRelay);
+
+        // ================= 配对码 =================
+        settingsCodeValue = new TextView(this);
+        settingsCodeValue.setTextColor(C_DIM);
+        settingsCodeValue.setTextSize(TypedValue.COMPLEX_UNIT_SP, 12);
+        settingsCodeValue.setPadding(0, dp(6), 0, dp(4));
+
+        box.addView(sectionTitle("记住的配对码"));
+        box.addView(hintText("手表会记住最近一次用的配对码，"
+                + "下次连接自动带上，不用重复输。"));
+        box.addView(settingsCodeValue);
+
+        Button clearCode = bigButton("清除记住的配对码", C_CARD, 13);
+        clearCode.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                getSharedPreferences("lanremote", MODE_PRIVATE).edit()
+                        .remove("paired_code").apply();
+                refreshSettingsPanel();
+                toast("已清除");
+            }
+        });
+        box.addView(clearCode);
+
+        // ================= 已配对设备 =================
+        settingsDevicesValue = new TextView(this);
+        settingsDevicesValue.setTextColor(C_DIM);
+        settingsDevicesValue.setTextSize(TypedValue.COMPLEX_UNIT_SP, 12);
+        settingsDevicesValue.setPadding(0, dp(6), 0, dp(4));
+
+        box.addView(sectionTitle("已配对的电脑"));
+        box.addView(hintText("配对过的电脑会出现在首页列表里，点一下就能连。"
+                + "换电脑或者想重新配对时可以清空。"));
+        box.addView(settingsDevicesValue);
+
+        Button clearDevices = bigButton("清空已配对的电脑", C_DANGER, 13);
+        clearDevices.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                new android.app.AlertDialog.Builder(MainActivity.this)
+                        .setTitle("清空已配对的电脑？")
+                        .setMessage("清掉之后首页列表就空了，"
+                                + "需要重新输配对码连接。")
+                        .setPositiveButton("清空", new android.content.DialogInterface.OnClickListener() {
+                            @Override
+                            public void onClick(android.content.DialogInterface d, int w) {
+                                store.clearDevices();
+                                refreshDeviceList();
+                                refreshSettingsPanel();
+                                toast("已清空");
+                            }
+                        })
+                        .setNegativeButton("取消", null)
+                        .show();
+            }
+        });
+        box.addView(clearDevices);
+
+        // ================= 关于 =================
+        box.addView(sectionTitle("关于"));
+        box.addView(hintText("ykxmz 手表端　版本 " + appVersion()
+                + "\\n\\n"
+                + "连接顺序：先试局域网直连（同一个 WiFi，几毫秒）；"
+                + "连不上再走中转（跨网络，受线路影响）。"));
+    }
+
+    /** 一行小节标题 */
+    private TextView sectionTitle(String text) {
+        TextView v = new TextView(this);
+        v.setText(text);
+        v.setTextColor(C_FG);
+        v.setTextSize(TypedValue.COMPLEX_UNIT_SP, 14);
+        v.setTypeface(null, android.graphics.Typeface.BOLD);
+        v.setPadding(0, dp(14), 0, 0);
+        return v;
+    }
+
+    /** 一行灰色说明 */
+    private TextView hintText(String text) {
+        TextView v = new TextView(this);
+        v.setText(text);
+        v.setTextColor(C_DIM);
+        v.setTextSize(TypedValue.COMPLEX_UNIT_SP, 11);
+        v.setLineSpacing(0, 1.25f);
+        v.setPadding(0, dp(4), 0, 0);
+        return v;
+    }
+
+    /** 版本号。从 PackageManager 读，和构建脚本里的版本天然一致，
+     *  不用在代码里再写一份（写两份必然有一份会忘改）。 */
+    private String appVersion() {
+        try {
+            return getPackageManager()
+                    .getPackageInfo(getPackageName(), 0).versionName;
+        } catch (Exception e) {
+            return "?";
+        }
+    }
+
+    /** 把设置页上的文字刷新成当前值 */
+    private void refreshSettingsPanel() {
+        if (settingsRelayValue == null) {
+            return;
+        }
+        String relay = relayUrl();
+        settingsRelayValue.setText(relay.isEmpty()
+                ? "现在是：空（只走局域网）"
+                : "现在是：" + relay);
+        settingsRelayValue.setTextColor(relay.isEmpty() ? C_DIM : C_OK);
+
+        String code = savedPairingCode();
+        settingsCodeValue.setText((code == null || code.isEmpty())
+                ? "现在没有记住的配对码"
+                : "记住的是：" + code);
+
+        int n = store.devices() == null ? 0 : store.devices().size();
+        settingsDevicesValue.setText("已配对 " + n + " 台电脑");
+    }
+
+    private void showSettingsPanel() {
+        refreshSettingsPanel();
+        showOnly(settingsPanel);
+    }
+
+    private void hideSettingsPanel() {
+        showConnectPanel();
+    }
+
+'''
+
+
+def patch(text: str, old: str, new: str, label: str, results: list) -> str:
+    if old not in text:
+        results.append(("✗", label, "找不到锚点"))
+        return text
+    if text.count(old) != 1:
+        results.append(("!", label, "锚点出现 %d 次" % text.count(old)))
+    results.append(("✓", label, ""))
+    return text.replace(old, new, 1)
+
+
+def main() -> int:
+    text = SRC.read_text(encoding="utf-8")
+    results: list = []
+
+    # ---- 1. 面板字段声明 ----
+    text = patch(
+        text,
+        "    private FrameLayout lanPanel;",
+        "    private FrameLayout lanPanel;\n"
+        "    // ---- 设置页（用户要求：各种设置收在一个页面里调）----\n"
+        "    private FrameLayout settingsPanel;\n"
+        "    private TextView settingsRelayValue;\n"
+        "    private TextView settingsCodeValue;\n"
+        "    private TextView settingsDevicesValue;",
+        "声明 settingsPanel 和各显示控件", results)
+
+    # ---- 2. 插入迁移函数（放在 relayUrl 之前）----
+    text = patch(
+        text, "    private String relayUrl() {",
+        MIGRATION + "    private String relayUrl() {",
+        "插入 migrateLegacyRelay()", results)
+
+    # ---- 3. buildSettingsPanel 等方法（插在 buildLanPanel 之前）----
+    text = patch(
+        text, "    private void buildLanPanel() {",
+        SETTINGS_BUILD + "    private void buildLanPanel() {",
+        "插入 buildSettingsPanel() 等", results)
+
+    # ---- 4. 建面板的地方也要建它 ----
+    text = patch(
+        text, "        buildLanPanel();",
+        "        buildLanPanel();\n        buildSettingsPanel();",
+        "构建时创建 settingsPanel", results)
+
+    # ---- 5. showOnly 纳入 settingsPanel ----
+    text = patch(
+        text,
+        "        View[] all = {connectPanel, controlPanel, mirrorPanel, lanPanel};",
+        "        View[] all = {connectPanel, controlPanel, mirrorPanel, lanPanel,\n"
+        "                      settingsPanel};",
+        "settingsPanel 纳入 showOnly()", results)
+
+    # ---- 6. 首页那个按钮改成「设置」 ----
+    text = patch(
+        text,
+        '''        Button relayButton = bigButton("中转设置（跨网络用）", C_ACCENT, 14);''',
+        '''        Button relayButton = bigButton("设置", C_ACCENT, 14);''',
+        "首页按钮文案改成「设置」", results)
+
+    text = patch(
+        text,
+        '''            public void onClick(View view) {
+                promptRelayUrl();
+            }
+        });
+        box.addView(relayButton);''',
+        '''            public void onClick(View view) {
+                showSettingsPanel();
+            }
+        });
+        box.addView(relayButton);''',
+        "首页按钮改成打开设置页", results)
+
+    # ---- 7. 启动时做迁移 ----
+    # 找 onCreate 里合适的位置：appendLog 第一次出现之前太早，
+    # 用 "store = " 初始化之后
+    import re
+    m = re.search(r"(        store = new DeviceStore\(this\);\n)", text)
+    if m:
+        text = (text[:m.end()]
+                + "        // 老版本硬塞的中转地址要清掉（见 migrateLegacyRelay）\n"
+                "        migrateLegacyRelay();\n"
+                + text[m.end():])
+        results.append(("✓", "启动时调用迁移", ""))
+    else:
+        results.append(("✗", "启动时调用迁移", "找不到 store 初始化那行"))
+
+    # ---- 输出 ----
+    print("  ── 补丁结果 ──")
+    for mark, label, note in results:
+        print("    %s %s%s" % (mark, label, ("  —— " + note) if note else ""))
+
+    if any(m == "✗" for m, _l, _n in results):
+        print()
+        print("  有锚点没匹配，没有写回")
+        return 1
+
+    if not any(m == "✗" for m, _l, _n in results):
+        SRC.write_text(text, encoding="utf-8", newline="\n")
+        print()
+        print("  已写回 MainActivity.java")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/add_watch_sfx.py

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*-
+r'''手表端加「音效」—— 用现成的 showChooser()，不新建面板。
+
+== 为什么改方案 ==
+
+第一版我给音效页写了完整的新面板（FrameLayout + ScrollView + 动态列表），
+后来发现 MainActivity 里**已经有 showChooser(title, labels, Chooser)**
+这个现成的选择器 —— pickVoice() 就是这么选 TTS 音色的。
+
+用选择器的话：
+    * 不用新建面板 -> 不用碰 root.addView / showOnly（那两个地方
+      刚因为"漏挂"出过一次全白的事故）
+    * 代码量少一半，出错面小得多
+    * 而且和"选音色"的操作手感一致，用户不用学两套
+
+所以改成：首页加一个「音效」按钮 -> 弹出音效列表 -> 点哪个放哪个。
+
+== 服务端配合 ==
+
+服务端返回的是 {"sfx":[{"name":...},...]} 这种嵌套结构，
+而手表的 stringList(reply, key) 只认扁平的字符串数组。
+audio_list 早就这么做了（同时返回 files / names / paths），
+这里跟着加一个 "names"，手表直接用。
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+SRC = (ROOT / "android" / "src" / "com" / "lanremote" / "watch"
+       / "MainActivity.java")
+
+# ---------------------------------------------------------------- 方法
+METHOD_ANCHOR = "    /** 选择电脑上的 TTS 音色。 */"
+
+METHOD_NEW = '''    /** 让电脑放一个音效（网络热门音效那类）。
+     *
+     *  用 showChooser 而不是新建面板 —— 见 _build/add_watch_sfx.py 里的说明：
+     *  pickVoice() 已经是这个套路，复用省事也更不容易出错。
+     */
+    private void pickSfx() {
+        appendLog("正在获取音效…");
+        io.execute(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    final Map<String, Object> reply =
+                            client.call(Json.obj("cmd", "sfx_list"), 15000);
+                    // 服务端同时给了扁平的 names（和 audio_list 一个约定）
+                    final List<String> names = stringList(reply, "names");
+                    final String dir = Json.str(reply, "dir", "");
+                    ui.post(new Runnable() {
+                        @Override
+                        public void run() {
+                            if (names.isEmpty()) {
+                                toast("电脑上还没有音效（或没连上）");
+                                appendLog("音效列表是空的。"
+                                        + (dir.isEmpty() ? "" : "素材目录：" + dir));
+                                return;
+                            }
+                            showChooser("音效（点一下电脑就响）", names,
+                                    new Chooser() {
+                                @Override
+                                public void onPick(int index) {
+                                    String one = names.get(index);
+                                    sendCommand(Json.obj("cmd", "sfx_play",
+                                            "name", one), "音效 " + one);
+                                }
+                            });
+                        }
+                    });
+                } catch (final IOException e) {
+                    postError("获取音效", e);
+                }
+            }
+        });
+    }
+
+''' + METHOD_ANCHOR
+
+
+def main() -> int:
+    text = SRC.read_text(encoding="utf-8")
+    out: list = []
+
+    def patch(old: str, new: str, what: str) -> None:
+        nonlocal text
+        if old not in text:
+            out.append(("✗", what, "找不到锚点"))
+            return
+        if text.count(old) != 1:
+            out.append(("!", what, "锚点 %d 处" % text.count(old)))
+        text = text.replace(old, new, 1)
+        out.append(("✓", what, ""))
+
+    # 1) 插方法
+    patch(METHOD_ANCHOR, METHOD_NEW, "插入 pickSfx()")
+
+    # 2) 首页加按钮（放在「音效」该在的位置：设置按钮之后）
+    patch('''        box.addView(sfxButton);''', '''        box.addView(sfxButton);''',
+          "（占位，见下）") if False else None
+
+    patch('''        box.addView(relayButton);''',
+          '''        box.addView(relayButton);
+
+        // 音效：点一下电脑就响。用户要求"可以直接远程播放"。
+        Button sfxButton = bigButton("音效（让电脑放一声）", C_ACCENT, 14);
+        LinearLayout.LayoutParams sfxParams = new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT, dp(52));
+        sfxParams.setMargins(0, 0, 0, dp(8));
+        sfxButton.setLayoutParams(sfxParams);
+        sfxButton.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                pickSfx();
+            }
+        });
+        box.addView(sfxButton);''',
+          "首页加「音效」按钮")
+
+    print("  ── 补丁结果 ──")
+    for mark, what, why in out:
+        print("    %s %s%s" % (mark, what, ("  —— " + why) if why else ""))
+    if any(m == "✗" for m, _w, _y in out):
+        print()
+        print("  有锚点没匹配，没有写回")
+        return 1
+
+    SRC.write_text(text, encoding="utf-8", newline="\n")
+    print()
+    print("  已写回 MainActivity.java")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/allow_plain_http.py

@@ -0,0 +1,166 @@
+# -*- coding: utf-8 -*-
+r'''让客户端能用"纯 IP + 明文 HTTP"的中转（新服务器就是这种）。
+
+== 背景 ==
+
+2026-10-08 换了服务器：AWS Lightsail，**有公网 IP**（yk.xxmxxs.top），
+中转直接监听 13245，**不再走 Cloudflare 隧道**。
+
+好处一大堆（延迟从 1000ms 降到 1ms、不再有 7844 阻断、内存 4 倍），
+但有个直接后果：**现在是明文 HTTP，没有 HTTPS 证书**。
+
+而两个客户端原来都默认往 https 上走：
+
+  1. Android 的 RelayTransport：用户填 `yk.xxmxxs.top:13245`
+     （没写协议头）会被强制加上 `https://` -> 连不上（那台机器没证书）
+
+  2. Android 9+ **默认禁止明文 HTTP**。没有
+     `android:usesCleartextTraffic="true"` 的话，请求会被系统直接掐掉，
+     报的还是很含糊的 "Cleartext HTTP traffic not permitted"。
+
+Windows 那边已经是对的：relay.py 的 _PRIVATE_HOST 正则里
+`\d{1,3}(?:\.\d{1,3}){3}` 把**任意纯 IP（含公网）**都当"用明文"，
+所以裸 IP 会正确走 http://。
+
+== 这个补丁做什么 ==
+
+  1. RelayTransport 的协议猜测改成和 Windows 一致：
+     纯 IP / localhost / *.local -> http://
+     域名 -> https://
+
+  2. AndroidManifest 加 usesCleartextTraffic="true"
+
+  3. 顺手清掉 windows/lanremote/relay.py 里一段**函数内死代码**
+     （_guess_scheme 的 return 之后还有一份一模一样的拷贝，
+      缩进仍属于函数体所以不报错，但看着很迷惑）
+
+== 关于 HTTPS ==
+
+明文 HTTP 意味着**同网络的人能看到流量**（虽然配对令牌、内容本来
+就是加密的，但 URL、设备名这些会露）。真正的解法是上 HTTPS：
+
+    把域名 relay.xxmxxs.top 的 A 记录指到 yk.xxmxxs.top，
+    然后 certbot 签一张 Let's Encrypt 证书，confd 挂上。
+
+那一步要用户动 DNS，所以先让明文能用（这个补丁），
+HTTPS 等 DNS 指过来再做。
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+JAVA = (ROOT / "android" / "src" / "com" / "lanremote" / "watch"
+        / "RelayTransport.java")
+MANIFEST = ROOT / "android" / "AndroidManifest.xml"
+WINRELAY = ROOT / "windows" / "lanremote" / "relay.py"
+
+
+def patch(path: Path, old: str, new: str, what: str, out: list) -> str:
+    raw = path.read_bytes()
+    bom = raw.startswith(b"\xef\xbb\xbf")
+    text = raw.decode("utf-8-sig")
+    if old not in text:
+        out.append(("✗", what, "找不到锚点"))
+        return text
+    if text.count(old) != 1:
+        out.append(("!", what, "锚点 %d 处" % text.count(old)))
+    text = text.replace(old, new, 1)
+    path.write_bytes((b"\xef\xbb\xbf" if bom else b"")
+                     + text.encode("utf-8"))
+    out.append(("✓", what, ""))
+    return text
+
+
+# ---------------------------------------------------------------- 1. Java
+JAVA_OLD = '''        if (!url.startsWith("http://") && !url.startsWith("https://")) {
+            url = "https://" + url;
+        }'''
+
+JAVA_NEW = '''        if (!url.startsWith("http://") && !url.startsWith("https://")) {
+            // 没写协议头时猜一个。规则要**和 Windows 端一致**
+            // （windows/lanremote/relay.py 的 _guess_scheme）：
+            //
+            //   IP / localhost / *.local  -> http://
+            //  域名                        -> https://
+            //
+            // 为什么纯 IP 走明文：IP 地址的中转基本都是自己搭的
+            // （局域网那台，或者像现在这样一台有公网 IP 的服务器），
+            // 上面往往没有证书。原来一律加 https:// 的结果是**永远连不上**，
+            // 而且报的是 SSL 错误，会把人带去查证书查半天。
+            //
+            // ⚠ 纯 IP 判断包含**公网 IP** —— 2026-10-08 换到 Lightsail
+            //   之后中转就是 http://yk.xxmxxs.top:13245，
+            //   只把 192.168/10./172.16 当私有的话这里会走错。
+            String hostOnly = url;
+            int slash = hostOnly.indexOf('/');
+            if (slash > 0) {
+                hostOnly = hostOnly.substring(0, slash);
+            }
+            int colon = hostOnly.indexOf(':');
+            if (colon > 0) {
+                hostOnly = hostOnly.substring(0, colon);
+            }
+            boolean plain = hostOnly.equalsIgnoreCase("localhost")
+                    || hostOnly.toLowerCase().endsWith(".local")
+                    || hostOnly.matches("\\\\d{1,3}(\\\\.\\\\d{1,3}){3}");
+            url = (plain ? "http://" : "https://") + url;
+        }'''
+
+# ---------------------------------------------------------------- 2. 清单
+MAN_OLD = '''    <uses-permission android:name="android.permission.INTERNET" />'''
+
+MAN_NEW = '''    <!-- ⚠ 允许明文 HTTP。
+         中转可以是"自己搭的、没有证书"的服务：局域网那台，或者
+         2026-10-08 之后那台有公网 IP 的服务器（http://yk.xxmxxs.top:13245）。
+         Android 9+ 默认**禁止明文流量**，不加这一条的话请求会被系统
+         直接掐掉，日志里只有一句含糊的
+         "Cleartext HTTP traffic to ... not permitted"。
+
+         安全性说明：中转上跑的内容（配对令牌、画面、文件）本来就是
+         加密过的，明文只暴露 URL 和设备名。要更严的话后续上 HTTPS
+         （Let's Encrypt），那时可以把这一条去掉。 -->
+    <application android:usesCleartextTraffic="true" />
+
+    <uses-permission android:name="android.permission.INTERNET" />'''
+
+# ---------------------------------------------------------------- 3. 死代码
+DEAD_OLD = '''    host = address.split("/", 1)[0]
+    return "http://" if _PRIVATE_HOST.match(host) else "https://"
+
+
+
+    """用户没写 http/https 时，猜一个。
+
+    IP 地址 / localhost -> http://
+        局域网里的中转服务是明文 HTTP。如果猜成 https，永远连不上，
+        而且报的是 SSL 错误，很容易误导人去查证书。
+    域名 -> https://
+        走公网必须加密（Cloudflare 隧道本来就是 https）。
+    """
+    host = address.split("/", 1)[0]
+    return "http://" if _PRIVATE_HOST.match(host) else "https://"'''
+
+DEAD_NEW = '''    host = address.split("/", 1)[0]
+    return "http://" if _PRIVATE_HOST.match(host) else "https://"'''
+
+
+def main() -> int:
+    out: list = []
+
+    patch(JAVA, JAVA_OLD, JAVA_NEW, "RelayTransport 协议猜测改成和 Windows 一致",
+          out)
+
+    patch(MANIFEST, MAN_OLD, MAN_NEW, "AndroidManifest 允许明文 HTTP", out)
+
+    patch(WINRELAY, DEAD_OLD, DEAD_NEW, "清掉 relay.py 里的函数内死代码", out)
+
+    print("  ── 结果 ──")
+    for m, what, why in out:
+        print("    %s %s%s" % (m, what, ("  —— " + why) if why else ""))
+    return 0 if not any(m == "✗" for m, _w, _y in out) else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/analyze_2h.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+r'''分析 2 小时长测数据（列格式：时间戳 \t 状态码 \t 毫秒）。
+
+上一版解析写错了 —— 它把任何 3 位数字都当状态码，
+于是毫秒（921、968…）也被算成状态码，可用率算出来只有 84.8%，
+是**假数字**。这里改成按列位置取。
+'''
+from __future__ import annotations
+
+import sys
+from collections import Counter
+from pathlib import Path
+
+path = Path(sys.argv[1] if len(sys.argv) > 1 else "/root/long2h_health.tsv")
+if not path.is_file():
+    print("  文件不存在: %s" % path)
+    raise SystemExit(0)
+
+rows = []
+bad = 0
+for line in path.read_text(encoding="utf-8", errors="replace").splitlines():
+    line = line.strip()
+    if not line:
+        continue
+    parts = line.split("\t")
+    if len(parts) < 3:
+        bad += 1
+        continue
+    stamp, code, ms = parts[0], parts[1].strip(), parts[2].strip()
+    try:
+        rows.append((stamp, code, float(ms)))
+    except ValueError:
+        bad += 1
+
+print("  样本 %d 条（解析不了 %d 条）" % (len(rows), bad))
+if not rows:
+    raise SystemExit(0)
+
+print("  时间范围: %s  ->  %s" % (rows[0][0], rows[-1][0]))
+
+codes = Counter(c for _s, c, _m in rows)
+total = len(rows)
+ok = codes.get("200", 0)
+
+print()
+print("  ── HTTP 状态分布 ──")
+for c, n in codes.most_common():
+    print("    %-6s %4d 次   %5.1f%%" % (c, n, n * 100.0 / total))
+print("    " + "-" * 30)
+print("    可用率:  %d/%d = %.2f%%" % (ok, total, ok * 100.0 / total))
+
+# 只看成功的耗时（失败的那些耗时没有意义）
+good = sorted(m for _s, c, m in rows if c == "200")
+if good:
+    def p(q):
+        return good[min(int(len(good) * q), len(good) - 1)]
+    print()
+    print("  ── 成功请求耗时（毫秒）──")
+    print("    最小 %.0f   中位 %.0f   P90 %.0f   P99 %.0f   最大 %.0f"
+          % (good[0], good[len(good) // 2], p(0.9), p(0.99), good[-1]))
+
+# 如果还有第 4 列及以后（连接数之类），也统计一下
+extra_cols = set()
+for line in path.read_text(encoding="utf-8", errors="replace").splitlines():
+    p = line.strip().split("\t")
+    if len(p) > 3:
+        extra_cols.add(len(p))
+if extra_cols:
+    print()
+    print("  （文件里还有更多列，最多 %d 列）" % max(extra_cols))
+
+fails = [(s, c, m) for s, c, m in rows if c != "200"]
+print()
+if fails:
+    print("  ── 失败样本（共 %d 条）──" % len(fails))
+    for s, c, m in fails[:15]:
+        print("    %s   HTTP %-5s %.0fms" % (s, c, m))
+    if len(fails) > 15:
+        print("    … 还有 %d 条" % (len(fails) - 15))
+    # 失败时间分布（按 10 分钟分桶）
+    print()
+    print("  ── 失败时刻分布（按小时）──")
+    hours = Counter(s.split(" ")[1].split(":")[0] if " " in s else s[:2]
+                    for s, _c, _m in fails)
+    for h in sorted(hours):
+        print("    %s 点  %d 次" % (h, hours[h]))
+else:
+    print("  ✓ 全程没有非 200 —— 2 小时 100% 可用")

_build/analyze_2h.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+# 分析 relay-stability 的 2 小时健康长测数据（只读）
+set -u
+
+F=/root/long2h_health.tsv
+[ -f "$F" ] || { echo "  数据文件不存在: $F"; exit 0; }
+
+echo "  文件: $F   行数: $(wc -l < "$F")"
+echo "  前 3 行（看格式）:"
+head -3 "$F" | sed 's/^/    /'
+echo
+
+python3 - "$F" <<'PYEOF'
+import sys
+from collections import Counter
+from pathlib import Path
+
+path = Path(sys.argv[1])
+lines = [l.strip() for l in path.read_text(encoding="utf-8",
+                                           errors="replace").splitlines()
+         if l.strip()]
+if not lines:
+    print("  没有数据")
+    raise SystemExit(0)
+
+# 猜列：先看表头，没有表头就按 tab 切
+head = lines[0].lower()
+has_header = any(k in head for k in ("time", "code", "ms", "http"))
+rows = lines[1:] if has_header else lines
+if has_header:
+    print("  表头: %s" % lines[0])
+print("  样本数: %d" % len(rows))
+
+codes = Counter()
+times = []
+conns = []
+fails = []
+for i, line in enumerate(rows, 1):
+    parts = line.split("\t")
+    code = None
+    ms = None
+    for p in parts:
+        p = p.strip()
+        if p.isdigit() and len(p) == 3:
+            code = p
+        if p.replace(".", "").isdigit() and "." in p:
+            try:
+                v = float(p)
+                if ms is None and v < 300000:
+                    ms = v
+            except ValueError:
+                pass
+    if code:
+        codes[code] += 1
+        if code != "200":
+            fails.append((i, line[:100]))
+    if ms:
+        times.append(ms)
+    # 连接数：找形如 quic=N h2=M 或者单独的数字
+    for p in parts:
+        if "quic=" in p:
+            conns.append(p.strip())
+
+total = sum(codes.values())
+ok = codes.get("200", 0)
+print()
+print("  ── HTTP 结果分布 ──")
+for c, n in codes.most_common():
+    pct = n * 100.0 / total if total else 0
+    print("    %-6s %4d 次  %.1f%%" % (c, n, pct))
+print("    --------")
+print("    可用率: %d/%d = %.1f%%" % (ok, total, ok * 100.0 / total if total else 0))
+
+if times:
+    s = sorted(times)
+    def pct(q):
+        return s[min(int(len(s) * q), len(s) - 1)]
+    print()
+    print("  ── 耗时分布（毫秒）──")
+    print("    最小 %.0f   中位 %.0f   P90 %.0f   P99 %.0f   最大 %.0f"
+          % (s[0], s[len(s)//2], pct(0.9), pct(0.99), s[-1]))
+
+if conns:
+    c = Counter(conns)
+    print()
+    print("  ── 连接数分布（前 8）──")
+    for k, n in c.most_common(8):
+        print("    %-28s %d 次" % (k, n))
+
+if fails:
+    print()
+    print("  ── 失败样本（最多 12 条）──")
+    for i, line in fails[:12]:
+        print("    第 %d 行: %s" % (i, line))
+else:
+    print()
+    print("  ✓ 全程没有非 200")
+PYEOF

_build/analyze_conns.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+r'''分析连接数时间线 long2h_conns.tsv，找塌陷的规律。
+
+目的：回答两个问题
+  1. QUIC 塌陷是不是周期性的？周期多长？
+  2. 塌陷期间 HTTP/2 那半边是不是一直活着？（这是双协议兜底的价值）
+'''
+from __future__ import annotations
+
+from pathlib import Path
+
+p = Path("/root/long2h_conns.tsv")
+if not p.is_file():
+    print("  没有 %s" % p)
+    raise SystemExit(0)
+
+raw = p.read_text(encoding="utf-8", errors="replace").splitlines()
+print("  共 %d 行，前 3 行：" % len(raw))
+for line in raw[:3]:
+    print("    %r" % line[:120])
+print()
+
+rows = []
+for line in raw:
+    line = line.strip()
+    if not line:
+        continue
+    parts = line.replace(",", "\t").split("\t")
+    stamp = ""
+    nums = []
+    for x in parts:
+        x = x.strip()
+        if not x:
+            continue
+        if ":" in x and ("-" in x or len(x) <= 8) and not x.replace(":", "").isdigit():
+            stamp = x
+        else:
+            try:
+                nums.append(int(x))
+            except ValueError:
+                pass
+    if nums:
+        rows.append((stamp, nums))
+
+if not rows:
+    print("  解析不出数字")
+    raise SystemExit(0)
+
+# 假设列是 [quic, h2] 或 [总连接, quic, h2] —— 按每行长度自适应
+width = max(len(n) for _s, n in rows)
+print("  每行 %d 个数字（列）" % width)
+print("  前 5 行解析结果：")
+for s, n in rows[:5]:
+    print("    %-12s %s" % (s, n))
+print()
+
+# 尝试识别：如果一行有 2 列，当作 [quic, h2]；3 列当作 [total, quic, h2]
+lower = [n for _s, n in rows]
+if width == 2:
+    quic = [n[0] for n in lower]
+    h2 = [n[1] for n in lower]
+elif width >= 3:
+    quic = [n[1] for n in lower]
+    h2 = [n[2] for n in lower]
+else:
+    print("  列数不支持")
+    raise SystemExit(0)
+
+total = len(quic)
+print("  ── 连接数统计（%d 个采样点）──" % total)
+print("    QUIC: 最低 %d  最高 %d  平均 %.1f"
+      % (min(quic), max(quic), sum(quic) / total))
+print("    HTTP/2: 最低 %d  最高 %d  平均 %.1f"
+      % (min(h2), max(h2), sum(h2) / total))
+
+# 塌陷 = QUIC <= 2
+collapse_idx = [i for i, q in enumerate(quic) if q <= 2]
+print()
+print("  ── QUIC 塌陷（<=2 条）──")
+print("    出现 %d 次，占比 %.1f%%" % (len(collapse_idx), len(collapse_idx) * 100.0 / total))
+
+# 塌陷时 h2 还在吗
+if collapse_idx:
+    h2_alive = sum(1 for i in collapse_idx if h2[i] >= 1)
+    h2_zero = sum(1 for i in collapse_idx if h2[i] == 0)
+    print("    塌陷时 HTTP/2 >=1 条: %d 次（%.0f%%）"
+          % (h2_alive, h2_alive * 100.0 / len(collapse_idx)))
+    print("    塌陷时 HTTP/2 也归零: %d 次" % h2_zero)
+    print("    -> 这就是双协议兜底的价值：%s"
+          % ("QUIC 塌了但 HTTP/2 还在扛" if h2_zero < h2_alive
+             else "两个一起塌，兜底没起作用"))
+
+# 合并连续的塌陷区间，看周期
+spans = []
+start = None
+for i, q in enumerate(quic):
+    if q <= 2 and start is None:
+        start = i
+    elif q > 2 and start is not None:
+        spans.append((start, i - 1))
+        start = None
+if start is not None:
+    spans.append((start, total - 1))
+
+print()
+print("  ── 塌陷区间（连续采样点合并）──")
+print("    共 %d 段" % len(spans))
+for a, b in spans[:15]:
+    sa = rows[a][0] if rows[a][0] else "第%d点" % a
+    sb = rows[b][0] if rows[b][0] else "第%d点" % b
+    print("    %-10s -> %-10s  持续 %d 个采样点  (quic 最低 %d)"
+          % (sa, sb, b - a + 1, min(quic[a:b + 1])))
+
+# 塌陷间隔（周期）
+if len(spans) >= 2:
+    gaps = [spans[i + 1][0] - spans[i][0] for i in range(len(spans) - 1)]
+    print()
+    print("  ── 两次塌陷之间隔多少个采样点 ──")
+    print("    %s" % gaps[:15])
+    print("    平均 %.1f 个采样点" % (sum(gaps) / len(gaps)))
+
+# 连接数分布
+from collections import Counter
+print()
+print("  ── QUIC 连接数分布 ──")
+for k in sorted(set(quic)):
+    c = quic.count(k)
+    print("    %2d 条: %4d 次  %5.1f%%" % (k, c, c * 100.0 / total))

_build/apply_best.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+# 采用最优配置 quic + 10，并清理 MSS 规则。
+#
+# v4 实测（MTU 1400，各 60 次）：
+#   quic+6   建齐 10s  0 失败  100%  中位 1399  P90 2611  P99 13705
+#   quic+8   建齐 16s  1 失败  100%  中位 1280  P90 2279  P99  3856
+#   quic+10  建齐 13s  0 失败  100%  中位 1256  P90 2068  P99  2991  <- 最好
+#
+# 注意：v4 脚本自己的排序逻辑有多行输出没处理干净，误选了 quic+8，
+# 这里按数据手工改成 quic+10。
+#
+# MSS 说明：接口 MTU 已经是 1400，内核自己算出来的 MSS 就是 1360；
+# iptables 的 --set-mss 只能把 MSS 往小改，所以那条 1400 的规则
+# 现在实际是空转。统一改成 1360，避免以后 MTU 变回去时留下不一致。
+set -u
+
+SVC=/etc/systemd/system/lanremote-tunnel.service
+UA='LanRemote/1.8.2'
+
+echo "════════ 1. 采用 quic + 10 ════════"
+sed -i "s/--protocol [a-z0-9]*/--protocol quic/" "$SVC"
+sed -i "s/--ha-connections [0-9]*/--ha-connections 10/" "$SVC"
+grep -oE '\-\-protocol [a-z0-9]+|--ha-connections [0-9]+|--edge-ip-version [0-9]+|--retries [0-9]+' "$SVC" | sed 's/^/  /'
+
+echo
+echo "════════ 2. 清理 MSS 规则（只留一条 1360）════════"
+iptables -t mangle -S OUTPUT 2>/dev/null | grep TCPMSS | sed 's/^/  清理前: /'
+while iptables -t mangle -D OUTPUT -p tcp --tcp-flags SYN,RST SYN -j TCPMSS --set-mss 1400 2>/dev/null; do :; done
+while iptables -t mangle -D OUTPUT -p tcp --tcp-flags SYN,RST SYN -j TCPMSS --set-mss 1360 2>/dev/null; do :; done
+iptables -t mangle -A OUTPUT -p tcp --tcp-flags SYN,RST SYN -j TCPMSS --set-mss 1360
+iptables -t mangle -S OUTPUT 2>/dev/null | grep TCPMSS | sed 's/^/  清理后: /'
+
+echo
+echo "════════ 3. MTU 和持久化 ════════"
+echo "  wlan0 MTU 现在: $(cat /sys/class/net/wlan0/mtu)"
+grep -c 'mtu 1400' /etc/systemd/system/lanremote-nettune.service | sed 's/^/  net-tune 里的 MTU 设置行数: /'
+echo "  net-tune 服务: $(systemctl is-enabled lanremote-nettune) / $(systemctl is-active lanremote-nettune)"
+
+echo
+echo "════════ 4. 重启隧道并等连接建齐 ════════"
+systemctl daemon-reload
+systemctl restart lanremote-tunnel
+for i in $(seq 1 40); do
+    sleep 4
+    n=$(curl -s --max-time 4 http://127.0.0.1:20241/metrics 2>/dev/null \
+        | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}')
+    [ "${n:-0}" -ge 10 ] && break
+done
+echo "  建齐 $n/10 条（等了约 $((i*4)) 秒）"
+curl -s --max-time 5 http://127.0.0.1:20241/metrics 2>/dev/null \
+    | grep 'server_locations.*} 1' | sed 's/^/    /'
+
+echo
+echo "════════ 5. 等公网可用 ════════"
+for i in $(seq 1 20); do
+    c=$(curl -s -o /dev/null -w '%{http_code}' --max-time 12 -H "User-Agent: $UA" https://relay.xxmxxs.top/v1/health)
+    printf "    第 %d 次: %s\n" "$i" "$c"
+    [ "$c" = "200" ] && break
+    sleep 3
+done
+
+echo
+echo "════════ 6. 快速验收（30 次）════════"
+ok=0; times=()
+for i in $(seq 1 30); do
+    out=$(curl -s -o /dev/null -w '%{http_code} %{time_total}' --max-time 25 -H "User-Agent: $UA" https://relay.xxmxxs.top/v1/health)
+    c=$(echo "$out" | awk '{print $1}'); ms=$(echo "$out" | awk '{printf "%d", $2*1000}')
+    [ "$c" = "200" ] && { ok=$((ok+1)); times+=("$ms"); }
+done
+stats=$(printf '%s\n' "${times[@]:-0}" | sort -n | awk '{a[NR]=$1} END {printf "中位 %d P90 %d P99 %d 最大 %d", a[int(NR/2)+1], a[int(NR*0.9)+1], a[int(NR*0.99)+1], a[NR]}')
+echo "  可用率 $ok/30 = $((ok*100/30))%   $stats ms"
+echo
+echo "  最终: $(grep -oE '\-\-protocol [a-z0-9]+|--ha-connections [0-9]+' "$SVC" | tr '\n' ' ')  MTU=$(cat /sys/class/net/wlan0/mtu)"

_build/auth_rescue_route.py

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+r'''给 /rescue/ 加上管理鉴权。
+
+== 问题 ==
+
+我把 /rescue/ 路由插在 do_GET 的第 1531 行，而管理页的登录校验
+（self._admin_gate()）在第 1723 行 —— **路由在鉴权之前**。
+
+也就是说：任何人只要知道
+    https://relay.xxmxxs.top/rescue/20261008-173000.txt
+就能直接下载诊断报告。那里面有什么：
+
+  * 内网 IP（192.168.2.x）、主机名
+  * 进程列表、内存占用
+  * 中转和隧道的日志尾部
+  * MTU / 路由 / iptables 规则
+
+这些是**运维信息**，不该公开。对比一下：/download/ 是给用户的
+安装包，公开是对的；/rescue/ 是给自己看的，必须登录。
+
+（同样的问题 /shot/ 也有 —— 那个是屏幕共享截图，本来就该拦。
+  这次先修 /rescue/，顺手看一眼 /shot/。）
+
+== 改法 ==
+
+在 /rescue/ 分支开头加一句 self._admin_gate()，
+和 /v1/admin/* 那些接口一样。do_GET 和 do_HEAD 都要加。
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+RELAY = ROOT / "relay" / "relay.py"
+
+# do_GET 里的（有 body 的那份）
+GET_OLD = '''        if path.startswith("/rescue/"):
+            # 抢救报告下载。**单独一条路由，不发缓存头** ——
+            # 内容会变，而且不该让 Cloudflare 边缘留着。
+            # （和 /download/ 分成两套是有意的：那个是给用户的安装包，
+            #   文件名带版本号、内容永不改变，所以敢发 604800 长缓存。）
+            wanted = urllib.parse.unquote(path[len("/rescue/"):])'''
+
+GET_NEW = '''        if path.startswith("/rescue/"):
+            # 抢救报告下载。**单独一条路由，不发缓存头** ——
+            # 内容会变，而且不该让 Cloudflare 边缘留着。
+            # （和 /download/ 分成两套是有意的：那个是给用户的安装包，
+            #   文件名带版本号、内容永不改变，所以敢发 604800 长缓存。）
+            #
+            # ⚠ 必须登录才能下。报告里有内网 IP、进程表、日志尾部、
+            #   MTU/路由/iptables —— 是运维信息，不是给所有人看的。
+            #   第一版把这条路由插在 _admin_gate() **之前**，
+            #   等于匿名可下，实测踩到。
+            if not self._admin_gate():
+                return
+            wanted = urllib.parse.unquote(path[len("/rescue/"):])'''
+
+# do_HEAD 里的（只有 headers）
+HEAD_OLD = '''        if path.startswith("/rescue/"):
+            # 抢救报告。HEAD 只回长度和类型，**不写 body** ——
+            # 这条路由同时存在于 do_GET（真正下载）和 do_HEAD（探测）。
+            wanted = urllib.parse.unquote(path[len("/rescue/"):])'''
+
+HEAD_NEW = '''        if path.startswith("/rescue/"):
+            # 抢救报告。HEAD 只回长度和类型，**不写 body** ——
+            # 这条路由同时存在于 do_GET（真正下载）和 do_HEAD（探测）。
+            # 同样要登录（见 do_GET 那段注释）。
+            if not self._admin_gate():
+                return no()
+            wanted = urllib.parse.unquote(path[len("/rescue/"):])'''
+
+
+def main() -> int:
+    raw = RELAY.read_bytes()
+    bom = raw.startswith(b"\xef\xbb\xbf")
+    text = raw.decode("utf-8-sig")
+
+    changed = []
+    for old, new, what in ((GET_OLD, GET_NEW, "do_GET"),
+                           (HEAD_OLD, HEAD_NEW, "do_HEAD")):
+        if new.split("\n")[0] in text and "_admin_gate" in text.split(old)[0][-600:]:
+            changed.append(("·", what, "好像已经加过了"))
+            continue
+        if old not in text:
+            changed.append(("✗", what, "找不到锚点"))
+            continue
+        text = text.replace(old, new, 1)
+        changed.append(("✓", what, "已加鉴权"))
+
+    print("  ── 结果 ──")
+    for m, w, why in changed:
+        print("    %s %-10s %s" % (m, w, why))
+
+    if any(m == "✗" for m, _w, _y in changed):
+        return 1
+
+    RELAY.write_bytes((b"\xef\xbb\xbf" if bom else b"") + text.encode("utf-8"))
+    print("  已写回 relay.py")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/bench.sh

@@ -0,0 +1,158 @@
+#!/bin/bash
+# 中转全面基线测量。
+#
+# 目的：把"优化到什么程度"变成可量化的数字，而不是感觉。
+# 五类指标，每类都记录成功率和耗时分布：
+#   A. 公网 HTTP 可用率（100 次 /v1/health）
+#   B. 长轮询（10 次真实 poll，每次挂 60 秒）
+#   C. 三个发布产物的下载成功率和吞吐
+#   D. 隧道连接数稳定性 + 重连次数
+#   E. 静态资源（官网 / 截图 / favicon）
+#
+# 用法: bash bench.sh [标签]
+set -u
+
+BASE=${BASE:-https://relay.xxmxxs.top}
+UA='LanRemote/1.8.1'
+LABEL=${1:-baseline}
+OUT="/root/bench_${LABEL}.txt"
+
+echo "════════════════════════════════════════════════════════" | tee "$OUT"
+echo "  中转基准测量 · $LABEL · $(date '+%Y-%m-%d %H:%M:%S')" | tee -a "$OUT"
+echo "════════════════════════════════════════════════════════" | tee -a "$OUT"
+
+echo | tee -a "$OUT"
+echo "── 隧道配置 ──" | tee -a "$OUT"
+CAP=$(systemctl show lanremote-tunnel -p ExecStart --value 2>/dev/null | tr ';' '\n' | grep -oE 'argv\[\]=[^ ]*|--[a-z-]+|/[a-z/]*cloudflared' | tr '\n' ' ')
+grep -oE '\-\-protocol [a-z0-9]+|\-\-ha-connections [0-9]+|\-\-edge-ip-version [0-9]+' /etc/systemd/system/lanremote-tunnel.service 2>/dev/null | tr '\n' ' ' | sed 's/^/  参数: /' | tee -a "$OUT"
+echo "  长轮询: $(tail -40 /root/lanremote-relay/relay.log 2>/dev/null | grep -oE '长轮询 [0-9]+ 秒' | tail -1)" | tee -a "$OUT"
+echo "  连接数: $(curl -s --max-time 5 http://127.0.0.1:20241/metrics 2>/dev/null | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}')" | tee -a "$OUT"
+
+# ---------------------------------------------------------------- A
+echo | tee -a "$OUT"
+echo "── A. 公网 HTTP 可用率（100 次，间隔 0.4 秒）──" | tee -a "$OUT"
+okA=0; failA=0; timesA=()
+for i in $(seq 1 100); do
+    out=$(curl -s -o /dev/null -w '%{http_code} %{time_total}' --max-time 25 -H "User-Agent: $UA" "$BASE/v1/health")
+    code=$(echo "$out" | awk '{print $1}')
+    ms=$(echo "$out" | awk '{printf "%d", $2*1000}')
+    if [ "$code" = "200" ]; then okA=$((okA+1)); timesA+=("$ms"); else failA=$((failA+1)); fi
+    sleep 0.4
+done
+pctA=$((okA * 100 / 100))
+echo "  可用率: $okA/100 = ${pctA}%   失败 $failA 次" | tee -a "$OUT"
+if [ "${#timesA[@]}" -gt 0 ]; then
+    printf '%s\n' "${timesA[@]}" | sort -n | awk '{
+        a[NR]=$1
+    } END {
+        printf "  耗时: 最小 %d  中位 %d  P90 %d  P99 %d  最大 %d ms\n",
+            a[1], a[int(NR/2)+1], a[int(NR*0.9)+1], a[int(NR*0.99)+1], a[NR]
+    }' | tee -a "$OUT"
+fi
+
+# ---------------------------------------------------------------- E（快的先做）
+echo | tee -a "$OUT"
+echo "── E. 静态资源（各 10 次）──" | tee -a "$OUT"
+for path in "/" "/shot/pc-main.png" "/favicon.ico"; do
+    ok=0; times=()
+    for i in $(seq 1 10); do
+        out=$(curl -s -o /dev/null -w '%{http_code} %{time_total}' --max-time 25 -H "User-Agent: $UA" "$BASE$path")
+        c=$(echo "$out" | awk '{print $1}')
+        ms=$(echo "$out" | awk '{printf "%d", $2*1000}')
+        [ "$c" = "200" ] && { ok=$((ok+1)); times+=("$ms"); }
+        sleep 0.3
+    done
+    stats=$(printf '%s\n' "${times[@]:-0}" | sort -n | awk '{a[NR]=$1} END {printf "中位 %d 最大 %d ms", a[int(NR/2)+1], a[NR]}')
+    printf "  %-22s %2d/10  %s\n" "$path" "$ok" "$stats" | tee -a "$OUT"
+done
+
+# ---------------------------------------------------------------- C
+echo | tee -a "$OUT"
+echo "── C. 三个成品下载（完整下载，量吞吐）──" | tee -a "$OUT"
+for f in ykxmz-setup-1.8.1.exe ykxmz-server-1.8.1.zip ykxmz-watch-1.8.1.apk; do
+    rm -f /tmp/dl.bin
+    out=$(curl -s -o /tmp/dl.bin -w '%{http_code} %{size_download} %{time_total}' \
+          --max-time 180 -H "User-Agent: $UA" "$BASE/download/$f")
+    code=$(echo "$out" | awk '{print $1}')
+    size=$(echo "$out" | awk '{print $2}')
+    secs=$(echo "$out" | awk '{print $3}')
+    kbps=$(echo "$secs $size" | awk '{if ($1 > 0) printf "%.0f", $2/$1/1024; else print 0}')
+    printf "  %-30s HTTP %-4s %9s 字节  %6.1fs  %6s KB/s\n" \
+        "$f" "$code" "$size" "$secs" "$kbps" | tee -a "$OUT"
+done
+
+# ---------------------------------------------------------------- D
+echo | tee -a "$OUT"
+echo "── D. 隧道连接数稳定性（采样 60 秒，每 2 秒一次）──" | tee -a "$OUT"
+MARK=$(wc -l < /root/lanremote-relay/tunnel.log 2>/dev/null || echo 0)
+minc=99; maxc=0; vals=()
+for i in $(seq 1 30); do
+    n=$(curl -s --max-time 4 http://127.0.0.1:20241/metrics 2>/dev/null | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}')
+    [ -z "${n:-}" ] && n=0
+    [ "$n" -lt "$minc" ] && minc="$n"
+    [ "$n" -gt "$maxc" ] && maxc="$n"
+    vals+=("$n")
+    sleep 2
+done
+reconn=$(tail -n +$((MARK+1)) /root/lanremote-relay/tunnel.log 2>/dev/null | grep -c 'Registered tunnel connection' || echo 0)
+lost=$(tail -n +$((MARK+1)) /root/lanremote-relay/tunnel.log 2>/dev/null | grep -c 'Lost connection' || echo 0)
+iot=$(tail -n +$((MARK+1)) /root/lanremote-relay/tunnel.log 2>/dev/null | grep -c 'i/o timeout' || echo 0)
+echo "  连接数: 最低 $minc  最高 $maxc   采样期间重连 $reconn 次 · 掉线 $lost 次 · i/o timeout $iot 次" | tee -a "$OUT"
+
+# ---------------------------------------------------------------- B
+echo | tee -a "$OUT"
+echo "── B. 长轮询（10 次真实 poll，每次挂 60 秒 ≈ 10 分钟）──" | tee -a "$OUT"
+STAMP=$(date +%s)
+DEV="bench-${LABEL}-${STAMP}"
+CODE=$(printf "%06d" $(( STAMP % 1000000 )))
+REG=$(curl -s --max-time 30 -X POST "$BASE/v1/agent/register" \
+      -H 'Content-Type: application/json' -H "User-Agent: $UA" \
+      -d "{\"deviceId\":\"$DEV\",\"code\":\"$CODE\",\"name\":\"bench\",\"version\":\"1.8.1\"}")
+TOKEN=$(echo "$REG" | python3 -c "import sys,json; print(json.load(sys.stdin).get('token',''))" 2>/dev/null)
+if [ -z "$TOKEN" ]; then
+    echo "  [失败] 探针注册没拿到 token" | tee -a "$OUT"
+else
+    okB=0; timesB=(); failsB=""
+    MARK2=$(wc -l < /root/lanremote-relay/tunnel.log 2>/dev/null || echo 0)
+    for i in $(seq 1 10); do
+        out=$(curl -s -o /dev/null -w '%{http_code} %{time_total}' --max-time 130 \
+              -X POST "$BASE/v1/agent/poll" -H "X-Token: $TOKEN" -H "User-Agent: $UA")
+        c=$(echo "$out" | awk '{print $1}')
+        secs=$(echo "$out" | awk '{printf "%d", $2*1000}')
+        if [ "$c" = "200" ]; then
+            okB=$((okB+1)); timesB+=("$secs")
+            printf "    %2d: 200  %6dms\n" "$i" "$secs" | tee -a "$OUT"
+        else
+            failsB="$failsB ${i}:${c}"
+            printf "    %2d: %-4s **失败**\n" "$i" "$c" | tee -a "$OUT"
+        fi
+    done
+    echo "  长轮询成功: $okB/10 = $((okB*10))%   失败:$failsB" | tee -a "$OUT"
+    if [ "${#timesB[@]}" -gt 0 ]; then
+        printf '%s\n' "${timesB[@]}" | sort -n | awk '{
+            a[NR]=$1
+        } END {
+            printf "  耗时: 最小 %d  中位 %d  P90 %d  最大 %d ms（理想 ≈ 61000）\n",
+                a[1], a[int(NR/2)+1], a[int(NR*0.9)+1], a[NR]
+        }' | tee -a "$OUT"
+    fi
+    r2=$(tail -n +$((MARK2+1)) /root/lanremote-relay/tunnel.log 2>/dev/null | grep -c 'Registered tunnel connection' || echo 0)
+    echo "  这 10 分钟里隧道重连 $r2 次" | tee -a "$OUT"
+    KEY=$(cat /root/lanremote-relay/data/admin_key.txt 2>/dev/null)
+    curl -s --max-time 20 -X POST "http://127.0.0.1:8080/v1/admin/delete" \
+         -H "X-Admin: $KEY" -H 'Content-Type: application/json' \
+         -d "{\"deviceId\":\"$DEV\"}" > /dev/null 2>&1
+fi
+
+echo | tee -a "$OUT"
+echo "════════════════════════════════════════════════════════" | tee -a "$OUT"
+echo "  基线存档: $OUT" | tee -a "$OUT"
+
+# 顺便把关键数字汇总成一行，便于前后对比
+{
+    echo
+    echo "===== 汇总（$LABEL）====="
+    echo "A 公网可用率     ${pctA}%  ($okA/100)"
+    echo "B 长轮询成功     ${okB:-0}/10"
+    echo "D 隧道连接       最低 ${minc} 最高 ${maxc}   重连 ${reconn} 掉线 ${lost}"
+} | tee -a "$OUT"

_build/bench_download.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+# 测下载吞吐：缓存预热前后对比。
+#
+# 基线（未加缓存头时）：
+#   setup.exe   237568 字节 / 13.3s = 17 KB/s   （还截断了）
+#   server.zip  214900 字节 /  3.1s = 67 KB/s
+#   watch.apk   201523 字节 / 66.8s =  3 KB/s
+set -u
+
+BASE=https://relay.xxmxxs.top
+UA='LanRemote/1.8.1'
+FILES="ykxmz-setup-1.8.1.exe ykxmz-server-1.8.1.zip ykxmz-watch-1.8.1.apk"
+
+echo "════════ 1. 预热：每个文件先请求一次，把内容推进 Cloudflare 缓存 ════════"
+for f in $FILES; do
+    # 只取前 1 字节，避免真的下载 15 MB
+    st=$(curl -s -o /dev/null -w '%{http_code}' -r 0-0 --max-time 60 \
+         -H "User-Agent: $UA" "$BASE/download/$f")
+    cf=$(curl -s -D - -o /dev/null -r 0-0 --max-time 60 -H "User-Agent: $UA" \
+         "$BASE/download/$f" 2>/dev/null | tr -d '\r' | grep -i '^cf-cache-status' | awk '{print $2}')
+    printf "  %-30s HTTP %s  cf-cache-status=%s\n" "$f" "$st" "${cf:-无}"
+done
+
+echo
+echo "  等 5 秒让边缘缓存落定…"
+sleep 5
+
+echo
+echo "════════ 2. 正式下载（完整文件，量吞吐）════════"
+total_ok=0
+for f in $FILES; do
+    rm -f /tmp/dl.bin
+    out=$(curl -s -o /tmp/dl.bin -D /tmp/dl.hdr -w '%{http_code} %{size_download} %{time_total}' \
+          --max-time 240 -H "User-Agent: $UA" "$BASE/download/$f")
+    code=$(echo "$out" | awk '{print $1}')
+    size=$(echo "$out" | awk '{print $2}')
+    secs=$(echo "$out" | awk '{print $3}')
+    cf=$(grep -i '^cf-cache-status' /tmp/dl.hdr | tr -d '\r' | awk '{print $2}')
+    age=$(grep -i '^age:' /tmp/dl.hdr | tr -d '\r' | awk '{print $2}')
+    kbps=$(echo "$secs $size" | awk '{if ($1 > 0) printf "%.0f", $2/$1/1024; else print 0}')
+    printf "  %-30s HTTP %-4s %9s 字节  %6.1fs  %6s KB/s  cf=%s age=%s\n" \
+        "$f" "$code" "$size" "$secs" "$kbps" "${cf:-无}" "${age:-无}"
+    [ "$code" = "200" ] && total_ok=$((total_ok+1))
+done
+echo "  成功 $total_ok/3"
+
+echo
+echo "════════ 3. 再下一次（应该全 HIT，更快）════════"
+for f in $FILES; do
+    rm -f /tmp/dl.bin
+    out=$(curl -s -o /tmp/dl.bin -D /tmp/dl.hdr -w '%{http_code} %{size_download} %{time_total}' \
+          --max-time 240 -H "User-Agent: $UA" "$BASE/download/$f")
+    code=$(echo "$out" | awk '{print $1}')
+    size=$(echo "$out" | awk '{print $2}')
+    secs=$(echo "$out" | awk '{print $3}')
+    cf=$(grep -i '^cf-cache-status' /tmp/dl.hdr | tr -d '\r' | awk '{print $2}')
+    kbps=$(echo "$secs $size" | awk '{if ($1 > 0) printf "%.0f", $2/$1/1024; else print 0}')
+    printf "  %-30s HTTP %-4s %9s 字节  %6.1fs  %6s KB/s  cf=%s\n" \
+        "$f" "$code" "$size" "$secs" "$kbps" "${cf:-无}"
+done
+
+echo
+echo "════════ 4. 对比基线 ════════"
+echo "  基线: setup 17 KB/s（截断）· server 67 KB/s · apk 3 KB/s"

_build/bench_from_pc.py

@@ -0,0 +1,180 @@
+# -*- coding: utf-8 -*-
+r'''从这台 Windows 机器测中转 —— 这才是"真实用户"的视角。
+
+== 为什么要换测量端 ==
+
+之前所有测量都是在设备自己上跑的 curl。那等于：
+    设备 4G --> Cloudflare 边缘        （第一段）
+    边缘 --> 隧道 --> 设备 4G 源站      （第二段）
+**两段都压在同一个 4G 链路上**，量出来的数字是双重打击。
+
+真实用户（手机/电脑在 WiFi、宽带、5G 上）：
+    用户 --> Cloudflare 边缘            （第一段，好网络）
+    边缘 --> 隧道 --> 设备 4G 源站      （第二段，只有这段是 4G）
+
+所以从这台机器量出来的，才是用户实际会遇到的延迟和可用率。
+
+用法: python _build/bench_from_pc.py [标签]
+'''
+from __future__ import annotations
+
+import json
+import statistics
+import sys
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+BASE = "https://relay.xxmxxs.top"
+UA = "LanRemote/1.8.2"
+OUT_DIR = Path(r"C:\Users\shu\Desktop\deepseekagent\LanRemote\_build")
+
+
+def req(path: str, method: str = "GET", data: bytes | None = None,
+        headers: dict | None = None, timeout: float = 150.0):
+    """发一个请求，返回 (状态码, 字节数, 秒数, 响应头)。"""
+    hdrs = {"User-Agent": UA}
+    hdrs.update(headers or {})
+    r = urllib.request.Request(BASE + path, data=data, headers=hdrs,
+                               method=method)
+    t0 = time.perf_counter()
+    try:
+        with urllib.request.urlopen(r, timeout=timeout) as resp:
+            body = resp.read()
+            return resp.status, len(body), time.perf_counter() - t0, resp.headers
+    except urllib.error.HTTPError as exc:
+        try:
+            exc.read()
+        except Exception:                              # noqa: BLE001
+            pass
+        return exc.code, 0, time.perf_counter() - t0, exc.headers
+    except Exception:                                  # noqa: BLE001
+        return 0, 0, time.perf_counter() - t0, {}
+
+
+def pct(values: list, q: float) -> int:
+    if not values:
+        return 0
+    s = sorted(values)
+    idx = min(int(len(s) * q), len(s) - 1)
+    return int(s[idx])
+
+
+def main() -> int:
+    label = sys.argv[1] if len(sys.argv) > 1 else "pc"
+    lines: list[str] = []
+
+    def say(text: str = "") -> None:
+        print(text)
+        lines.append(text)
+
+    say("=" * 62)
+    say("  从 PC 量中转 · %s · %s" % (label, time.strftime("%Y-%m-%d %H:%M:%S")))
+    say("=" * 62)
+
+    # ---------------- A. 公网可用率 ----------------
+    say()
+    say("── A. 公网可用率（100 次 /v1/health）──")
+    ok, times, fails = 0, [], 0
+    for i in range(100):
+        code, _n, secs, _h = req("/v1/health", timeout=25)
+        if code == 200:
+            ok += 1
+            times.append(int(secs * 1000))
+        else:
+            fails += 1
+        time.sleep(0.3)
+    say("  可用率 %d/100 = %d%%   失败 %d 次" % (ok, ok, fails))
+    if times:
+        say("  耗时 最小 %d  中位 %d  P90 %d  P99 %d  最大 %d ms"
+            % (min(times), int(statistics.median(times)), pct(times, 0.9),
+               pct(times, 0.99), max(times)))
+
+    # ---------------- E. 静态资源 ----------------
+    say()
+    say("── E. 静态资源（各 10 次）──")
+    for path in ("/", "/shot/pc-main.png", "/favicon.ico"):
+        o, ts = 0, []
+        for _ in range(10):
+            code, _n, secs, _h = req(path, timeout=25)
+            if code == 200:
+                o += 1
+                ts.append(int(secs * 1000))
+            time.sleep(0.2)
+        med = int(statistics.median(ts)) if ts else 0
+        say("  %-22s %2d/10   中位 %d  最大 %d ms"
+            % (path, o, med, max(ts) if ts else 0))
+
+    # ---------------- C. 下载 ----------------
+    say()
+    say("── C. 三个成品下载（完整下载）──")
+    dl_results = {}
+    for name in ("ykxmz-setup-1.8.2.exe", "ykxmz-server-1.8.2.zip",
+                 "ykxmz-watch-1.8.2.apk"):
+        code, size, secs, hdrs = req("/download/" + name, timeout=300)
+        kbps = (size / secs / 1024) if secs > 0 else 0
+        cf = (hdrs.get("cf-cache-status") or "?") if hdrs else "?"
+        say("  %-30s HTTP %-4s %9d 字节  %6.1fs  %7.0f KB/s  cf=%s"
+            % (name, code, size, secs, kbps, cf))
+        if code == 200 and size > 0:
+            dl_results[name] = kbps
+
+    # ---------------- B. 长轮询 ----------------
+    say()
+    say("── B. 长轮询（6 次真实 poll，每次挂 60 秒）──")
+    stamp = int(time.time())
+    dev = "pcbench-%s-%d" % (label, stamp)
+    code6 = "%06d" % (stamp % 1000000)
+    payload = json.dumps({
+        "deviceId": dev, "code": code6, "name": "pcbench",
+        "version": "1.8.2",
+    }, ensure_ascii=False).encode("utf-8")
+    status, _n, _s, _h = req("/v1/agent/register", method="POST",
+                             data=payload, timeout=30,
+                             headers={"Content-Type": "application/json"})
+    token = ""
+    if status == 200:
+        # 重新取一次拿 body
+        r = urllib.request.Request(
+            BASE + "/v1/agent/register", data=payload,
+            headers={"User-Agent": UA, "Content-Type": "application/json"},
+            method="POST")
+        try:
+            with urllib.request.urlopen(r, timeout=30) as resp:
+                token = json.loads(resp.read().decode("utf-8")).get("token", "")
+        except Exception:                              # noqa: BLE001
+            pass
+    say("  探针注册: %s" % ("成功" if token else "失败"))
+
+    if token:
+        okb, btimes, bfails = 0, [], []
+        for i in range(6):
+            code, _n, secs, _h = req(
+                "/v1/agent/poll", method="POST", data=b"",
+                headers={"X-Token": token}, timeout=150)
+            ms = int(secs * 1000)
+            if code == 200:
+                okb += 1
+                btimes.append(ms)
+                say("    %d: 200  %6dms" % (i + 1, ms))
+            else:
+                bfails.append("%d:%s" % (i + 1, code))
+                say("    %d: %-4s **失败**" % (i + 1, code))
+        say("  长轮询成功 %d/6 = %d%%   失败: %s"
+            % (okb, okb * 100 // 6, " ".join(bfails) or "无"))
+        if btimes:
+            say("  耗时 最小 %d  中位 %d  P90 %d  最大 %d ms（理想 ≈ 61000）"
+                % (min(btimes), int(statistics.median(btimes)),
+                   pct(btimes, 0.9), max(btimes)))
+
+    say()
+    say("=" * 62)
+    out = OUT_DIR / ("bench_pc_%s.txt" % label)
+    out.write_text("\n".join(lines), encoding="utf-8")
+    say("  存档: %s" % out)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/bench_pc_optimized.txt

@@ -0,0 +1,30 @@
+==============================================================
+  从 PC 量中转 · optimized · 2026-10-07 16:01:23
+==============================================================
+
+── A. 公网可用率（100 次 /v1/health）──
+  可用率 98/100 = 98%   失败 2 次
+  耗时 最小 765  中位 911  P90 1889  P99 23868  最大 23868 ms
+
+── E. 静态资源（各 10 次）──
+  /                       9/10   中位 1016  最大 1223 ms
+  /shot/pc-main.png      10/10   中位 1160  最大 1914 ms
+  /favicon.ico            8/10   中位 1075  最大 1993 ms
+
+── C. 三个成品下载（完整下载）──
+  ykxmz-setup-1.8.2.exe          HTTP 404          0 字节     0.8s        0 KB/s  cf=BYPASS
+  ykxmz-server-1.8.2.zip         HTTP 404          0 字节     0.8s        0 KB/s  cf=BYPASS
+  ykxmz-watch-1.8.2.apk          HTTP 404          0 字节     0.9s        0 KB/s  cf=BYPASS
+
+── B. 长轮询（6 次真实 poll，每次挂 60 秒）──
+  探针注册: 成功
+    1: 200   60817ms
+    2: 0    **失败**
+    3: 200   61758ms
+    4: 200   62027ms
+    5: 200   62060ms
+    6: 200   61247ms
+  长轮询成功 5/6 = 83%   失败: 2:0
+  耗时 最小 60817  中位 61758  P90 62060  最大 62060 ms（理想 ≈ 61000）
+
+==============================================================

_build/break_nettune_deadlock.py

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+r'''解开"nettune 死锁"，然后把根因修掉。
+
+== 死锁是怎么回事 ==
+
+    lanremote-nettune.service:
+        Before=lanremote-tunnel.service          <- 关键
+        ExecStart=/bin/bash net-tune.sh
+
+    net-tune.sh 第 4 步:
+        systemctl restart lanremote-tunnel       <- 在这里永远阻塞
+
+  为什么阻塞：systemd 正在启动 nettune，而 nettune 声明了"我必须在
+  隧道之前启动完"。脚本却在**自己还没结束的时候**去 restart 隧道 ——
+  那要求隧道先停、再等 nettune 结束……systemd 检测到这是顺序冲突，
+  restart 就一直挂着不返回。
+
+  证据：CGroup 里能看到 net-tune.sh（13388）下面挂着
+        systemctl restart lanremote-tunnel（13428），
+        etime 09:32 —— 卡了 9 分半，nettune 一直是 activating。
+
+  后果：nettune 卡住 -> 隧道被 Before= 挡着起不来 -> 公网 530。
+  这就是用户说的"网站还是容易挂"的真因之一。
+
+== 为什么以前没暴露 ==
+
+  设备上原来那份 unit 的 ExecStart 里有个 `iptables ... || ...`，
+  systemd 不支持 ||，所以它**在第 2 条 ExecStart 就报错退出了**，
+  根本没走到"重启隧道"那一步 —— 死锁被那个 bug 遮住了。
+  我把 unit 换成正确形状之后，死锁才露出来。
+
+== 这一步做什么 ==
+
+  1. 杀掉卡住的 systemctl 和 net-tune.sh（解开当前死锁）
+  2. 拉起隧道（网站先恢复）
+  3. 把 net-tune.sh 的"重启隧道"改成**只在手动跑时做**
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "_build"))
+from devssh import run      # noqa: E402
+
+REMOTE = r'''
+echo "════ 1. 解开死锁 ════"
+# 先杀卡住的 systemctl（不然它会一直拽着 systemd 的 job）
+pkill -f 'systemctl restart lanremote-tunnel' 2>/dev/null && echo "  杀了卡住的 systemctl" || echo "  没有卡住的 systemctl"
+sleep 2
+# 再让 nettune 的脚本结束（杀它的子进程已经让主脚本继续往下走了）
+systemctl stop lanremote-nettune 2>/dev/null
+systemctl reset-failed lanremote-nettune 2>/dev/null
+sleep 2
+echo "  nettune 现在: $(systemctl is-active lanremote-nettune)"
+
+echo
+echo "════ 2. 拉起隧道（网站先恢复）════"
+systemctl reset-failed lanremote-tunnel lanremote-tunnel-h2 2>/dev/null
+systemctl start lanremote-tunnel lanremote-tunnel-h2
+sleep 15
+echo "  tunnel:    $(systemctl is-active lanremote-tunnel)"
+echo "  tunnel-h2: $(systemctl is-active lanremote-tunnel-h2)"
+
+echo
+echo "════ 3. 验公网 ════"
+for i in 1 2 3; do
+    code=$(curl -s -o /dev/null -w '%{http_code}' --max-time 15 https://relay.xxmxxs.top/v1/health)
+    echo "  第 $i 次: $code"
+    [ "$code" = "200" ] && break
+    sleep 6
+done
+
+echo
+echo "════ 4. 隧道连接数 ════"
+for p in 20241 20242; do
+    n=$(curl -s --max-time 5 http://127.0.0.1:$p/metrics 2>/dev/null | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}' | head -1)
+    echo "  $p -> ${n:-拿不到}"
+done
+'''
+
+
+def main() -> int:
+    out = run(REMOTE, timeout=300)
+    text = out[1] if isinstance(out, tuple) else str(out)
+    print(text)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/bump_181.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+r'''版本号 1.8.0 -> 1.8.1。
+
+这次是 bug 修复版：局域网劫持 + 长轮询 60 秒。
+（用户规矩：每次上传都要升版号。）
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(r"C:\Users\shu\Desktop\deepseekagent\LanRemote")
+OLD, NEW = "1.8.0", "1.8.1"
+BOM = b"\xef\xbb\xbf"
+
+TARGETS = [
+    "android/AndroidManifest.xml",
+    "android/build_apk.ps1",
+    "installer/ykxmz.iss",
+    "relay/relay.py",
+    "windows/lanremote/__init__.py",
+    "_tests/test_apk_contents.py",
+    "_tests/test_package_remote.py",
+    "_build/package_remote.py",
+    "_build/test_installer_cycle.py",
+]
+NEEDS_BOM = {".ps1"}
+
+
+def main() -> int:
+    print("  %s -> %s" % (OLD, NEW))
+    total = 0
+    for rel in TARGETS:
+        path = ROOT / rel
+        if not path.is_file():
+            print("  [跳过] %s 不存在" % rel)
+            continue
+        raw = path.read_bytes()
+        had_bom = raw.startswith(BOM)
+        text = raw.decode("utf-8-sig")
+        if OLD not in text:
+            print("  [跳过] %-40s 里面没有 %s" % (rel, OLD))
+            continue
+        count = text.count(OLD)
+        text = text.replace(OLD, NEW)
+        want_bom = path.suffix in NEEDS_BOM or had_bom
+        data = text.encode("utf-8")
+        if want_bom:
+            data = BOM + data
+        path.write_bytes(data)
+        print("  %-40s 改了 %d 处" % (rel, count))
+        total += count
+    print()
+    print("  共改 %d 处" % total)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/bump_version_generic.py

@@ -83,9 +83,27 @@ def main() -> int:
         changed += 1
 
     # ---- Windows EXE 版本信息 ----
-    if swap(ROOT / "windows" / "version_info.txt",
-            [(f'"{OLD}.0"', f'"{NEW}.0"')],
-            f"EXE 文件版本 {NEW}.0"):
+    # ⚠ 原来用的是 f'"{OLD}.0"'，一旦 OLD 和文件里对不上就静默跳过
+    #   （version_info.txt 就是这么从 1.7.1 一直漏到现在的）。
+    #   改成正则匹配任意四段版本。
+    import re as _re
+    _vi = ROOT / "windows" / "version_info.txt"
+    if _vi.is_file():
+        _raw = _vi.read_bytes()
+        _bom = _raw.startswith(b"\xef\xbb\xbf")
+        _txt = _raw.decode("utf-8-sig")
+        _new = _re.sub(
+            r'(StringStruct\("(?:File|Product)Version",\\s*")\\d+\\.\\d+\\.\\d+\\.\\d+("\))',
+            r'\\g<1>' + NEW + r'.0\\g<2>', _txt)
+        if _new != _txt:
+            _vi.write_bytes((b"\xef\xbb\xbf" if _bom else b"")
+                            + _new.replace("\\r\\n", "\\n").encode("utf-8"))
+            print(f"  version_info.txt: EXE 文件版本 {NEW}.0")
+            changed += 1
+        else:
+            print("  [跳过] version_info.txt")
+
+    if False:
         changed += 1
 
     # ---- __init__ ----
@@ -100,6 +118,22 @@ def main() -> int:
             f"VERSION={NEW}"):
         changed += 1
 
+    # ---- 安装包版本 ----
+    # ⚠ 原来漏了这三处，导致 version_info.txt 从 1.7.1 起就一直没跟上
+    #   （用户在"文件属性 -> 详细信息"里看到一个错三个版本的号）。
+    if swap(ROOT / "installer" / "ykxmz.iss",
+            [(f'#define MyAppVersion "{OLD}"',
+              f'#define MyAppVersion "{NEW}"'),
+             (f'ykxmz-setup-{OLD}.exe', f'ykxmz-setup-{NEW}.exe')],
+            f"安装包版本 {NEW}"):
+        changed += 1
+
+    # ---- 安装许可页上的版本 ----
+    if swap(ROOT / "installer" / "license-combined.txt",
+            [(f"版本：{OLD}", f"版本：{NEW}")],
+            f"许可页版本 {NEW}"):
+        changed += 1
+
     # ---- 三份文档 ----
     for path in sorted((ROOT / "docs").glob("*.txt")):
         raw = path.read_bytes()
@@ -112,7 +146,31 @@ def main() -> int:
             print(f"  docs/{path.name}")
             changed += 1
 
+    # ---- README 里的成品文件名 ----
+    #
+    # README 里有 8 处写着 `ykxmz-setup-1.8.2.exe` 这类成品名。
+    # 以前没管它，结果一直停在 1.8.2 —— 用户照着 README 去 releases
+    # 找 1.8.2 的包，当然找不到（最新已经是 2.x 了）。
+    #
+    # 这里用"任意数字版本号 -> 新版本"的正则，而不是精确替换 OLD：
+    # README 可能因为漏过几次 bump 而停在更老的版本上，
+    # 精确匹配 OLD 那时候就换不掉了。
+    readme = ROOT / "README.md"
+    if readme.is_file():
+        text = readme.read_text(encoding="utf-8")
+        new_text = re.sub(
+            r"(ykxmz-(?:setup|server|watch|agent)-)\d+\.\d+\.\d+",
+            lambda m: m.group(1) + NEW, text)
+        if new_text != text:
+            readme.write_text(new_text, encoding="utf-8", newline="\n")
+            print("  README.md")
+            changed += 1
+
     # ---- 会断言成品名的测试 ----
+    # 注意 test_installer_cycle.py 也曾经写死过成品名（ykxmz-setup-1.8.2.exe），
+    # 结果它去装一个不存在的包 -> 静默失败 -> 报出一堆莫名其妙的
+    # "配对码实际是 xxx" "版本显示 v1.8.2"。那个文件现在改成自动找
+    # dist 下最新的安装包了，不再需要这里维护。
     for name in ("test_package_remote.py", "test_apk_contents.py"):
         path = ROOT / "_tests" / name
         if not path.is_file():

_build/check_cache.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+# 看各类资源的响应头，判断有哪些能被 Cloudflare 缓存却因为 no-store 被挡了。
+set -u
+
+BASE=https://relay.xxmxxs.top
+UA='LanRemote/1.8.1'
+
+echo "════════ 各路径的缓存相关响应头 ════════"
+for p in "/" "/v1/health" "/shot/pc-main.png" "/favicon.ico" \
+         "/download/ykxmz-server-1.8.1.zip"; do
+    echo "  ── $p ──"
+    curl -sI --max-time 30 -H "User-Agent: $UA" "$BASE$p" 2>/dev/null \
+        | grep -iE '^HTTP|^cache-control|^cf-cache-status|^content-type|^content-length|^expires|^age' \
+        | tr -d '\r' | sed 's/^/      /'
+done
+
+echo
+echo "════════ 静态图中的 cf-cache-status（HIT 说明缓存生效）════════"
+for i in 1 2 3; do
+    s=$(curl -sI --max-time 20 -H "User-Agent: $UA" "$BASE/shot/pc-main.png" 2>/dev/null \
+        | grep -i '^cf-cache-status' | tr -d '\r' | awk '{print $2}')
+    echo "    第 $i 次: cf-cache-status = ${s:-?}"
+    sleep 1
+done
+
+echo
+echo "════════ relay 源码里缓存头的设置 ════════"
+grep -n 'Cache-Control' /root/lanremote-relay/relay.py | sed 's/^/  /'
+
+echo
+echo "════════ 下载路由的实现（看有没有做流式/分块）════════"
+sed -n '/if path.startswith("\/download\/")/,/^        # /p' /root/lanremote-relay/relay.py \
+    | head -50 | sed 's/^/  /'

_build/check_conns.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+# 看长测进度 + 实时连接数波动
+set -u
+
+echo "=== 长测进度 ==="
+tail -20 /root/longstab_quic10.txt 2>/dev/null
+
+echo
+echo "=== 连接数实时（每 3 秒一次，共 12 次 = 36 秒）==="
+for i in $(seq 1 12); do
+    n=$(curl -s --max-time 4 http://127.0.0.1:20241/metrics 2>/dev/null \
+        | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}')
+    printf "  %2d: %s\n" "$i" "${n:-?}"
+    sleep 3
+done
+
+echo
+echo "=== 这 36 秒里隧道日志的新事件 ==="
+MARK=$(wc -l < /root/lanremote-relay/tunnel.log 2>/dev/null || echo 0)
+sleep 1
+journalctl -u lanremote-tunnel --since '2 minutes ago' --no-pager 2>/dev/null \
+    | grep -E 'Lost connection|Registered tunnel|Failed to dial|no recent network' \
+    | tail -14 | sed 's/^/  /'

_build/check_default_relay.py

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*-
+r'''查「默认中转服务器」在源码和已构建成品里各是什么值。
+
+用户报告：软件默认中转服务器应该是**空白**、让用户自己填。
+但给我的版本是填好的，上传的版本是清空的 —— 两者不一致。
+
+先把所有源头找出来，看清楚再改。
+'''
+from __future__ import annotations
+
+import re
+import zipfile
+from pathlib import Path
+
+ROOT = Path(r"C:\Users\shu\Desktop\deepseekagent\LanRemote")
+
+SOURCES = [
+    ("windows/lanremote/server.py", r"DEFAULT_RELAY_URL\s*=\s*(.+)"),
+    ("windows/lanremote/relay.py", r"192\.168\.\d+\.\d+:8080"),
+    ("windows/run_agent.py", r"or\s+\"(192\.168[^\"]*|[^\"]*xxmxxs[^\"]*)\""),
+    ("android/src/com/lanremote/watch/MainActivity.java",
+     r"DEFAULT_RELAY_URL\s*=\s*(.+);"),
+]
+
+print("=" * 70)
+print("  一、源码里的默认中转地址")
+print("=" * 70)
+for rel, pattern in SOURCES:
+    path = ROOT / rel
+    if not path.is_file():
+        print("  [不存在] %s" % rel)
+        continue
+    text = path.read_text(encoding="utf-8", errors="replace")
+    hits = re.findall(pattern, text, re.M)
+    print("  %s" % rel)
+    if hits:
+        for h in hits[:4]:
+            h = h if isinstance(h, str) else h[0]
+            print("      %s" % h.strip()[:100])
+    else:
+        print("      （没匹配到）")
+
+print()
+print("=" * 70)
+print("  二、已构建成品里到底是什么")
+print("=" * 70)
+
+# APK
+apk = ROOT / "dist" / "ykxmz-watch-1.8.2.apk"
+if apk.is_file():
+    print("  %s" % apk.name)
+    try:
+        with zipfile.ZipFile(apk) as z:
+            dex = [n for n in z.namelist() if n.endswith(".dex")]
+            found = []
+            for name in dex:
+                blob = z.read(name)
+                for needle in (b"https://relay.xxmxxs.top",
+                               b"192.168.2.156",
+                               b"192.168.10.105"):
+                    if needle in blob:
+                        found.append((name, needle.decode()))
+            if found:
+                for name, needle in sorted(set(found)):
+                    print("      %s -> 含 %s" % (name, needle))
+            else:
+                print("      dex 里没有硬编码的中转地址（默认是空白）")
+    except Exception as exc:                               # noqa: BLE001
+        print("      读 APK 失败: %s" % exc)
+else:
+    print("  dist/ykxmz-watch-1.8.2.apk 不存在")
+
+# exe / onedir
+exe_dir = ROOT / "dist_exe" / "ykxmz"
+print()
+print("  %s" % exe_dir)
+if exe_dir.is_dir():
+    hits = []
+    for f in exe_dir.rglob("*"):
+        if not f.is_file() or f.suffix.lower() not in (".py", ".pyc"):
+            continue
+        try:
+            blob = f.read_bytes()
+        except OSError:
+            continue
+        for needle in (b"192.168.2.156", b"192.168.10.105",
+                       b"https://relay.xxmxxs.top"):
+            if needle in blob:
+                hits.append((f.relative_to(exe_dir).as_posix(),
+                             needle.decode()))
+    if hits:
+        for name, needle in sorted(set(hits))[:10]:
+            print("      %-50s 含 %s" % (name, needle))
+    else:
+        print("      没有硬编码的中转地址")
+else:
+    print("      不存在")
+
+# 服务端 zip
+print()
+srv = ROOT / "dist" / "ykxmz-server-1.8.2.zip"
+if srv.is_file():
+    print("  %s" % srv.name)
+    try:
+        with zipfile.ZipFile(srv) as z:
+            for name in z.namelist():
+                if not name.endswith((".py", ".txt", ".sh")):
+                    continue
+                try:
+                    text = z.read(name).decode("utf-8", "replace")
+                except Exception:                          # noqa: BLE001
+                    continue
+                for line in text.splitlines():
+                    if ("192.168.2.156" in line or "192.168.10.105" in line
+                            or "relay.xxmxxs.top" in line):
+                        print("      %s: %s" % (name, line.strip()[:90]))
+                        break
+    except Exception as exc:                               # noqa: BLE001
+        print("      读 zip 失败: %s" % exc)
+else:
+    print("  dist/ykxmz-server-1.8.2.zip 不存在")
+
+print()
+print("=" * 70)
+print("  三、结论")
+print("=" * 70)
+print("  期望：默认中转服务器为**空白**，由用户自己填。")
+print("  实际：见上面。凡是出现硬编码地址的地方都要改成空字符串。")

_build/check_device.py

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*-
+r'''看一眼中转服务器的完整状态。
+
+为什么写成文件：这一轮我用 `python -c @"..."@` 传长命令失败了好几次 ——
+PowerShell 的双引号 heredoc 会做变量插值、还会把 `$(...)` 当子表达式
+在本机执行（systemctl / iptables 跑到 Windows 上了）。凡是超过两行
+的远端命令，一律写成文件跑。
+
+用法：
+    python _build/check_device.py
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "_build"))
+from devssh import run      # noqa: E402
+
+REMOTE = r'''
+RELAY=/root/lanremote-relay
+echo "════ 服务 ════"
+for s in lanremote-relay lanremote-tunnel lanremote-tunnel-h2 lanremote-nettune; do
+    printf '  %-24s %s\n' "$s" "$(systemctl is-active $s 2>&1)"
+done
+printf '  %-24s %s\n' "monitor.timer" "$(systemctl is-active lanremote-monitor.timer 2>&1)"
+printf '  %-24s %s\n' "watchdog.timer" "$(systemctl is-active lanremote-watchdog.timer 2>&1)"
+
+echo
+echo "════ 网络 ════"
+printf '  %-24s %s\n' "wlan0 MTU" "$(cat /sys/class/net/wlan0/mtu 2>/dev/null)"
+printf '  %-24s %s\n' "MSS 规则" "$(iptables -t mangle -L -n 2>/dev/null | grep -ci mss) 条"
+printf '  %-24s %s\n' "tcp_mtu_probing" "$(cat /proc/sys/net/ipv4/tcp_mtu_probing 2>/dev/null)"
+printf '  %-24s %s\n' "默认路由" "$(ip route show default 2>/dev/null | head -1)"
+
+echo
+echo "════ 内存 / 运行时长 ════"
+printf '  %-24s %s\n' "运行时长" "$(uptime -p 2>/dev/null)"
+free -m 2>/dev/null | sed -n '2p' | awk '{printf "  %-24s %s/%s MB\n", "内存 used/total", $3, $2}'
+
+echo
+echo "════ 隧道连接数 ════"
+for p in 20241 20242; do
+    n=$(curl -s --max-time 5 "http://127.0.0.1:$p/metrics" 2>/dev/null \
+        | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}' | head -1)
+    printf '  %-24s %s\n' "指标端口 $p" "${n:-拿不到}"
+done
+
+echo
+echo "════ 公网自测 ════"
+printf '  %-24s %s\n' "公网 /v1/health" "$(curl -s -o /dev/null -w '%{http_code} (%{time_total}s)' --max-time 15 https://relay.xxmxxs.top/v1/health 2>/dev/null)"
+printf '  %-24s %s\n' "本机 /v1/health" "$(curl -s -o /dev/null -w '%{http_code}' --max-time 6 http://127.0.0.1:8080/v1/health 2>/dev/null)"
+printf '  %-24s %s\n' "公网首页" "$(curl -s -o /dev/null -w '%{http_code}' --max-time 15 https://relay.xxmxxs.top/ 2>/dev/null)"
+printf '  %-24s %s\n' "后台抢救报告路由" "$(curl -s -o /dev/null -w '%{http_code}' --max-time 6 http://127.0.0.1:8080/rescue/none.txt 2>/dev/null)"
+
+echo
+echo "════ 监测单元状态 ════"
+cat $RELAY/monitor_state.txt 2>/dev/null | sed 's/^/  /' || echo "  （还没有状态文件）"
+echo "  ── monitor.log 尾部 ──"
+tail -5 $RELAY/monitor.log 2>/dev/null | sed 's/^/  /' || echo "  （还没有日志）"
+
+echo
+echo "════ 抢救报告 ════"
+n=$(ls $RELAY/rescue_reports 2>/dev/null | wc -l)
+echo "  共 $n 份"
+ls -la $RELAY/rescue_reports/ 2>/dev/null | tail -n +4 | awk '{printf "  %s  %s\n", $6" "$7" "$8, $9}'
+
+echo
+echo "════ 知识库 ════"
+if [ -f $RELAY/rescue_knowledge.md ]; then
+    echo "  行数：$(wc -l < $RELAY/rescue_knowledge.md)"
+    tail -6 $RELAY/rescue_knowledge.md | sed 's/^/  /'
+else
+    echo "  （没有）"
+fi
+
+echo
+echo "════ 定时器下次触发 ════"
+systemctl list-timers lanremote-monitor.timer lanremote-watchdog.timer --no-pager 2>/dev/null | head -4 | sed 's/^/  /'
+
+echo
+echo "════ 后台页有没有「抢救报告」分区 ════"
+printf '  匹配次数: %s\n' "$(curl -s --max-time 8 http://127.0.0.1:8080/zhongzhuanzhan 2>/dev/null | grep -c '抢救报告')"
+'''
+
+
+def main() -> int:
+    out = run(REMOTE, timeout=300)
+    text = out[1] if isinstance(out, tuple) else str(out)
+    print(text)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/check_gitee_block.py

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+r'''查 Gitee 到底为什么判违规，以及 README 里哪些词可能触发。
+
+== 已知 ==
+
+    https://gitee.com/xmz7891/ykxmz/raw/main/README.md  -> HTTP 451
+    Unavailable For Legal Reasons
+
+451 是"应法律要求不可用"。在国内平台上，这个通常是**内容审核拦的**。
+
+== 要分清两种情况 ==
+
+    A. 整个仓库被限制（那 API 读仓库信息也会失败/受限）
+    B. 只有 README 这个文件被拦（网页能开、raw 不行）
+
+== 同时扫一下 README 里可能触发审核的词 ==
+
+国内平台的关键词审核对这几类比较敏感：
+
+    * 翻墙 / 代理 / VPN / 科学上网
+    * 挖矿 / 矿机 / 算力 / 虚拟货币
+    * 破解 / 破解版 / 盗版 / 激活工具
+    * 外挂 / 作弊
+    * 监控 / 偷拍 / 窃听 / 追踪（"监控"在教育场景容易误判）
+    * 游戏相关的"封号""加速器"
+    * 二维码 / 收款 / 打赏
+
+这份 README 是"教室手表控电脑"，正常。但要确认没混进上面这些。
+'''
+from __future__ import annotations
+
+import json
+import re
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+GITEE = "https://gitee.com/xmz7891/ykxmz"
+
+RISKY = [
+    "翻墙", "代理", "VPN", "vpn", "科学上网", "梯子", "加速器",
+    "挖矿", "矿机", "算力", "比特币", "虚拟货币", "以太坊",
+    "破解", "盗版", "激活工具", "注册机", "keygen", "crack",
+    "外挂", "作弊", "开挂",
+    "监控", "偷拍", "窃听", "追踪", "定位",
+    "打赏", "收款", "二维码收款",
+    "荷官", "博彩", "赌博",
+]
+
+
+def get(url: str, ua: str = "Mozilla/5.0") -> tuple:
+    req = urllib.request.Request(url)
+    req.add_header("User-Agent", ua)
+    try:
+        with urllib.request.urlopen(req, timeout=30) as r:
+            return r.status, r.read().decode("utf-8", "replace")
+    except urllib.error.HTTPError as exc:
+        return exc.code, ""
+    except Exception as exc:                              # noqa: BLE001
+        return "失败", str(exc)[:60]
+
+
+def main() -> int:
+    print("=" * 62)
+    print("  查 Gitee 为什么 451 + 扫 README 可疑词")
+    print("=" * 62)
+
+    print()
+    print("  ── 1. 各入口的状态码 ──")
+    for label, url in [
+        ("仓库主页", GITEE),
+        ("raw README", GITEE + "/raw/main/README.md"),
+        ("raw LICENSE", GITEE + "/raw/main/LICENSE"),
+        ("网页版 README", GITEE + "/blob/main/README.md"),
+        ("发行版页", GITEE + "/releases"),
+    ]:
+        code, body = get(url)
+        note = ""
+        if isinstance(code, int):
+            if code == 200:
+                note = "正常"
+            elif code == 451:
+                note = "**被法律原因拦了**"
+            elif code == 404:
+                note = "不存在"
+        print("    %-16s HTTP %-6s %s" % (label, code, note))
+
+    print()
+    print("  ── 2. 用 Gitee API 看仓库（API 走的是另一条路）──")
+    token_file = ROOT / "_build" / ".gitee_token"
+    if token_file.is_file():
+        token = token_file.read_text(encoding="utf-8").strip()
+        code, body = get(
+            "https://gitee.com/api/v5/repos/xmz7891/ykxmz"
+            "?access_token=%s" % token)
+        print("    API 仓库信息 HTTP %s" % code)
+        if code == 200:
+            try:
+                d = json.loads(body)
+                print("      名称：%s" % d.get("name"))
+                print("      是否私有：%s" % d.get("private"))
+                print("      最近推送：%s" % d.get("pushed_at"))
+            except Exception:                             # noqa: BLE001
+                pass
+
+    print()
+    print("  ── 3. 扫 README 里的可疑词 ──")
+    rm = ROOT / "README.md"
+    text = rm.read_text(encoding="utf-8")
+    lines = text.splitlines()
+    hits = 0
+    for word in RISKY:
+        for i, line in enumerate(lines, 1):
+            if word in line:
+                hits += 1
+                print("    %-10s 第 %d 行: %s"
+                      % (word, i, line.strip()[:60]))
+    if not hits:
+        print("    ✅ 没扫到这些词")
+
+    print()
+    print("  ── 4. README 里的链接（外链也可能被拦）──")
+    urls = re.findall(r"https?://[^\s\)\]\"'<>]+", text)
+    seen = []
+    for u in urls:
+        host = re.sub(r"^https?://", "", u).split("/")[0]
+        if host not in seen:
+            seen.append(host)
+    for h in seen:
+        print("    %s" % h)
+
+    print()
+    print("  ── 5. 结论提示 ──")
+    print("    如果只有 raw 是 451、主页 200，那就是**单个文件被拦**，")
+    print("    通常改掉触发的措辞就能恢复。")
+    print("    如果主页也 451，那是**整个仓库被限制**，得走 Gitee 申诉。")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/check_lightsail.py

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+r'''看一眼 Lightsail 上中转服务器的完整状态。
+
+⚠ 写这个文件的原因：用 `python -c @"..."@` 传带 `$(...)` 的远端命令，
+PowerShell 会**先在本机求值** `$(systemctl ...)`（报"无法将 systemctl
+项识别为 cmdlet"），还会吃掉引号导致 Python 语法错。
+这个毛病我这一轮犯了四五次 —— **凡是超过两行的远端命令，一律写文件。**
+
+用法：
+    python _build/check_lightsail.py
+    python _build/check_lightsail.py --fix      # 顺便修文件属主
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "_build"))
+from lssh import run, HOST as LS_HOST                 # noqa: E402
+
+PORT = "13245"
+DOMAIN = "yk.xxmxxs.top"
+RELAY_DIR = "/opt/ykxmz-relay"
+
+# 三层地址各查一遍：
+#   域名      —— 用户实际走的路（Cloudflare -> nginx -> 中转）
+#   IP:80     —— 绕过 Cloudflare，直连 nginx（域名没配好时靠它）
+#   :13245    —— **应该不通**（中转已只绑 127.0.0.1，不再对公网）
+DOMAIN_URL = "http://%s" % DOMAIN
+NGINX_URL = "http://%s:80" % LS_HOST
+DIRECT_URL = "http://%s:%s" % (LS_HOST, PORT)
+
+REMOTE = r'''
+R=__DIR__
+P=__PORT__
+
+echo "════ 服务 ════"
+for s in ykxmz-relay nginx ykxmz-monitor.timer; do
+    printf '  %-22s %s\n' "$s" "$(systemctl is-active $s 2>&1)"
+done
+
+echo
+echo "════ 三层地址（用户路径 / 绕 CF / 直连中转）════"
+# ⚠ 一律加 -L 跟跳转：nginx 那边 http 会 301 到 https，
+#   不跟跳转拿到的是 301 而不是 200，会看着像"挂了"。
+printf '  %-26s %s\n' "域名 __DOMAIN__" "$(curl -sL -o /dev/null -w '%{http_code}' --max-time 12 __DOMAIN_URL__/v1/health)"
+printf '  %-26s %s\n' "IP:80（nginx）" "$(curl -sL -o /dev/null -w '%{http_code}' --max-time 12 __NGINX_URL__/v1/health)"
+printf '  %-26s %s\n' ":__PORT__（应 000）" "$(curl -s -o /dev/null -w '%{http_code}' --max-time 8 __DIRECT_URL__/v1/health)"
+printf '  %-26s %s\n' "本机 :__PORT__" "$(curl -s -o /dev/null -w '%{http_code}' --max-time 8 http://127.0.0.1:$P/v1/health)"
+printf '  %-26s %s\n' "域名延迟" "$(curl -sL -o /dev/null -w '%{time_total}s' --max-time 12 __DOMAIN_URL__/v1/health)"
+
+echo
+echo "════ 首页角标 ════"
+echo "  域名   -> $(curl -sL --max-time 12 __DOMAIN_URL__/ | grep -o '最新版 [0-9.]*' | head -1)"
+echo "  IP:80  -> $(curl -sL --max-time 12 __NGINX_URL__/ | grep -o '最新版 [0-9.]*' | head -1)"
+
+echo
+echo "════ 缓存头（决定 Cloudflare 缓不缓存）════"
+printf '  %-20s %s 条\n' "下载" "$(curl -sL -I --max-time 12 __DOMAIN_URL__/download/ykxmz-setup-2.1.3.exe | grep -ci cache-control)"
+curl -sL -I --max-time 12 __DOMAIN_URL__/download/ykxmz-setup-2.1.3.exe \
+    | grep -i '^cache-control' | sed 's/^/    /'
+printf '  %-20s %s\n' "长轮询" "$(curl -sL -I --max-time 12 __DOMAIN_URL__/v1/health | grep -i '^cache-control' | tr -d '\r')"
+
+echo
+echo "════ 监听 / 进程 ════"
+ss -tlnp 2>/dev/null | grep -E ":(80|$P) " | sed 's/^/  /'
+ps -eo pid,rss,etime,cmd --sort=-rss 2>/dev/null | grep 'relay\.py' | grep -v grep | head -1 | sed 's/^/  /'
+
+echo
+echo "════ 监测单元 ════"
+cat $R/monitor_state.txt 2>/dev/null | sed 's/^/  /'
+echo "  --- 探测的是什么地址 ---"
+grep -E '^(PUBLIC_URL|FALLBACK_URL)=' $R/monitor.sh | sed 's/^/  /'
+echo "  --- monitor.log 尾部（只挑非 Permission 的）---"
+grep -v 'Permission denied' $R/monitor.log 2>/dev/null | tail -4 | sed 's/^/  /'
+
+echo
+echo "════ 抢救报告 / 知识库 ════"
+echo "  报告 $(ls $R/rescue_reports 2>/dev/null | wc -l) 份"
+echo "  知识库 $(wc -l < $R/rescue_knowledge.md 2>/dev/null || echo 0) 行"
+
+echo
+echo "════ 资源 ════"
+free -m 2>/dev/null | sed -n 2p | awk '{printf "  内存 %s/%s MB\n", $3, $2}'
+df -h / | tail -1 | awk '{printf "  磁盘 %s 用 %s\n", $2, $5}'
+uptime | sed 's/^/  /'
+
+echo
+echo "════ 文件属主（admin 必须能写日志）════"
+ls -la $R/*.log $R/monitor_state.txt 2>/dev/null | awk '{print "  " $3":"$4"  "$9}'
+'''
+
+
+def main() -> int:
+    if "--fix" in sys.argv:
+        print("  ── 修属主 ──")
+        out = run("sudo chown -R admin:admin %s && sudo chmod 755 %s && echo OK"
+                  % (RELAY_DIR, RELAY_DIR), timeout=120, quiet=True)
+        print("  " + out[1].strip())
+
+    cmd = (REMOTE
+           .replace("__DIR__", RELAY_DIR)
+           .replace("__PORT__", PORT)
+           .replace("__DOMAIN__", DOMAIN)
+           .replace("__DOMAIN_URL__", DOMAIN_URL)
+           .replace("__NGINX_URL__", NGINX_URL)
+           .replace("__DIRECT_URL__", DIRECT_URL))
+    out = run(cmd, timeout=300, quiet=True)
+    print(out[1] if isinstance(out, tuple) else out)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/check_progress.sh

@@ -0,0 +1,39 @@
+#!/bin/bash
+# 看可靠性测试进度和隧道事件
+set -u
+
+echo "── 测试进程 ──"
+pgrep -af 'tpr.sh|reliability' | head -3
+echo
+
+echo "── 隧道最近 30 分钟事件 ──"
+reconn=$(journalctl -u lanremote-tunnel --since '30 minutes ago' --no-pager 2>/dev/null | grep -c 'Registered tunnel connection')
+lost=$(journalctl -u lanremote-tunnel --since '30 minutes ago' --no-pager 2>/dev/null | grep -c 'Lost connection')
+iot=$(journalctl -u lanremote-tunnel --since '30 minutes ago' --no-pager 2>/dev/null | grep -c 'i/o timeout')
+echo "  重连 $reconn 次 · 掉线 $lost 次 · i/o timeout $iot 次"
+
+echo
+echo "── 最近的掉线/重连明细 ──"
+journalctl -u lanremote-tunnel --since '30 minutes ago' --no-pager 2>/dev/null \
+    | grep -E 'Registered tunnel connection|Lost connection' | tail -8 | sed 's/^/  /'
+
+echo
+echo "── watchdog 最近 12 行 ──"
+tail -12 /root/lanremote-relay/watchdog.log 2>/dev/null | sed 's/^/  /'
+
+echo
+echo "── 隧道连接数和落点 ──"
+curl -s --max-time 5 http://127.0.0.1:20241/metrics 2>/dev/null \
+    | grep -E '^cloudflared_tunnel_ha_connections|server_locations.*} 1' | sed 's/^/  /'
+
+echo
+echo "── 公网现在通不通（10 次快速探测）──"
+ok=0
+for i in $(seq 1 10); do
+    c=$(curl -s -o /dev/null -w '%{http_code}' --max-time 15 \
+        -H 'User-Agent: LanRemote/1.8.1' https://relay.xxmxxs.top/v1/health)
+    [ "$c" = "200" ] && ok=$((ok+1))
+    printf "    %d: %s\n" "$i" "$c"
+    sleep 1
+done
+echo "    可用 $ok/10"

_build/check_tls_ready.py

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+r'''验证源站的 443 是否就绪（证书签完之后）。
+
+背景：522 是因为 Cloudflare 的 SSL 模式是 Full/Full(strict)，
+回源走 443，而源站只有 80。现在证书签好了、nginx 也配了 443，
+所以要确认：
+
+    1. 本机 443 能自测通（带正确 SNI）
+    2. 从**外面**能不能连上 443
+       —— 这一步取决于用户在 Lightsail 防火墙开没开 443
+'''
+from __future__ import annotations
+
+import socket
+import ssl
+import sys
+import urllib.request
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "_build"))
+from lssh import run, HOST as LS_HOST                 # noqa: E402
+
+DOMAIN = "yk.xxmxxs.top"
+IP = LS_HOST
+
+
+def tcp(host: str, port: int, timeout: float = 8.0) -> bool:
+    s = socket.socket()
+    s.settimeout(timeout)
+    try:
+        s.connect((host, port))
+        return True
+    except Exception:                                     # noqa: BLE001
+        return False
+    finally:
+        s.close()
+
+
+def https(host: str, port: int = 443) -> tuple:
+    """返回 (状态码文本, 证书主体)。"""
+    ctx = ssl.create_default_context()
+    try:
+        with urllib.request.urlopen(
+                "https://%s:%d/v1/health" % (host, port),
+                timeout=15, context=ctx) as r:
+            r.read(64)
+            return str(r.status), "证书验证通过"
+    except ssl.SSLCertVerificationError as exc:
+        return "证书错误", str(exc)[:70]
+    except Exception as exc:                              # noqa: BLE001
+        return "失败", "%s: %s" % (type(exc).__name__, str(exc)[:60])
+
+
+def main() -> int:
+    print("=" * 62)
+    print("  验证 443 是否就绪")
+    print("=" * 62)
+
+    print()
+    print("  ── 1. 源站内部（从服务器自己看）──")
+    # ⚠ 这里**不能用 % 格式化** —— 远端命令里有 curl 的
+    #   %{http_code}，% 格式化会把 %{ 当成格式符直接抛
+    #   "unsupported format character '{'"。用 replace 更安全。
+    inner = (
+        "echo '  --- 监听 ---'; "
+        "ss -tln 2>/dev/null | grep -E ':(80|443) ' | sed 's/^/    /'; "
+        "echo '  --- 本机 https（带 SNI）---'; "
+        "curl -s -o /dev/null -w '    %{http_code}\\n' --max-time 10 "
+        "--resolve __D__:443:127.0.0.1 https://__D__/v1/health; "
+        "echo '  --- 证书主体 ---'; "
+        "sudo openssl x509 -in /etc/letsencrypt/live/__D__/fullchain.pem "
+        "-noout -subject -dates 2>/dev/null | sed 's/^/    /'; "
+        "echo '  --- nginx 里的 443 段 ---'; "
+        "sudo grep -nE 'listen|ssl_certificate|return 301|server_name' "
+        "/etc/nginx/sites-available/ykxmz | sed 's/^/    /'"
+    ).replace("__D__", DOMAIN)
+    out = run(inner, timeout=180, quiet=True)
+    for ln in out[1].strip().splitlines():
+        print(ln)
+
+    print()
+    print("  ── 2. 从这台电脑直连源站（不经过 Cloudflare）──")
+    for port in (80, 443):
+        ok = tcp(IP, port)
+        print("    %s:%-4d TCP %s" % (IP, port, "通" if ok else "不通 ❌"))
+    code, note = https(IP)
+    print("    https://%s/v1/health -> %s  （%s）" % (IP, code, note))
+    print("    （这里会是证书错误，正常 —— 我们是用 IP 直连，")
+    print("      证书是签给域名的。这一步只看 TCP 通不通。）")
+
+    print()
+    print("  ── 3. 经 Cloudflare 的 HTTPS ──")
+    code, note = https(DOMAIN)
+    print("    https://%s/v1/health -> %s  （%s）" % (DOMAIN, code, note))
+
+    print()
+    print("  ── 4. 结论 ──")
+    if tcp(IP, 443):
+        print("    ✅ 443 从外面**通** —— Cloudflare 的 Full(strict) 能工作")
+        if code == "200":
+            print("    ✅ 全链路已经好了")
+        else:
+            print("    ⚠ 443 通了但 HTTPS 还不通，可能是 Cloudflare")
+            print("      还没切到 Full(strict)，或者配置还在生效中")
+    else:
+        print("    ❌ 443 从外面**不通** —— 需要去 Lightsail 防火墙开 TCP 443")
+        print("       （实例 → 联网 → 防火墙 → 添加规则 → 自定义 TCP 443）")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/check_web.sh

@@ -1,4 +1,8 @@
 #!/bin/bash
+
+# ⚠ 管理密码不再写在这里，从环境变量取：
+#     export RELAY_ADMIN_PASSWORD=...
+: "${RELAY_ADMIN_PASSWORD:?请先 export RELAY_ADMIN_PASSWORD}"
 # 官网 / 管理页 / favicon 的最终检查
 set -u
 
@@ -26,7 +30,7 @@ curl -s -o /dev/null -w '     -> %{redirect_url}\n' --max-time 15 "$BASE/admin"
 echo
 echo "  4) 登录"
 curl -s -c /tmp/ck2.txt -o /dev/null --max-time 15 -X POST \
-    -d 'username=xmz7891&password=@REVAedu120830' "$BASE/admin/login" 2>/dev/null
+    -d "username=xmz7891&password=$RELAY_ADMIN_PASSWORD" "$BASE/admin/login" 2>/dev/null
 curl -s -b /tmp/ck2.txt -o /tmp/admin.html --max-time 15 "$BASE/zhongzhuanzhan" 2>/dev/null
 for n in 'id=dlPanel' '网络体检' '退出登录' 'favicon'; do
     grep -q "$n" /tmp/admin.html && echo "       OK $n" || echo "       XX $n"

_build/check_win7_compat.py

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*-
+r'''校验打出来的 EXE 能不能在 **Windows 7** 上跑。
+
+== 为什么需要这个 ==
+
+学校电脑是 Windows 7，装完报「dll 缺失」。
+
+根因不是漏打包，是 **Python 版本越界**：
+
+    Python 3.8   -> 最后一个支持 Windows 7 的版本
+    Python 3.9+  -> 只支持 Windows 8 及以上
+
+Python 3.9 起用到了 `api-ms-win-core-path-l1-1-0.dll` 里的
+`PathCchCanonicalizeEx`，而这个 DLL **Windows 7 上根本不存在**，
+也没法用 api-set 转发（那套机制只在 Win8+ 生效）。
+
+**所以那个 DLL 不是"忘了放进包"，是"放进去也没用"。**
+唯一可行的办法是**用 3.8 打包**。
+
+== 这个脚本查什么 ==
+
+    1. 有没有 python38.dll（而不是 python39/310/311/... ）
+    2. **不该有** api-ms-win-core-path-l1-1-0.dll
+       —— 有它就说明是 3.9+ 打的，Win7 上必挂
+    3. PE 头是不是 32 位（0x14C）
+       —— 32 位在 Win7 的 32/64 位系统上都能跑；
+          64 位在 32 位 Windows 上直接起不来
+    4. 顺带报一下总大小和文件数
+
+用 `python _build/check_win7_compat.py` 单独跑也行，
+`build_exe.ps1` 里会调它，不过就直接拒绝出包。
+'''
+from __future__ import annotations
+
+import struct
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+DIST = ROOT / "dist_exe" / "ykxmz"
+
+FAILS: list = []
+
+
+def check(name: str, ok: bool, why: str = "") -> None:
+    print("  [%s] %s%s" % ("PASS" if ok else "FAIL", name,
+                          ("  —— " + why) if why else ""))
+    if not ok:
+        FAILS.append(name)
+
+
+def pe_machine(path: Path) -> int:
+    """读 PE 头里的 machine 字段。0x14C=32 位，0x8664=64 位。"""
+    with path.open("rb") as f:
+        if f.read(2) != b"MZ":
+            return 0
+        f.seek(0x3C)
+        off = struct.unpack("<I", f.read(4))[0]
+        f.seek(off)
+        if f.read(4) != b"PE\0\0":
+            return 0
+        return struct.unpack("<H", f.read(2))[0]
+
+
+def main() -> int:
+    print("=" * 58)
+    print("  Windows 7 兼容性校验")
+    print("=" * 58)
+    print()
+
+    check("dist_exe/ykxmz 存在", DIST.is_dir(),
+          "先跑 windows\\build_exe.ps1")
+    if not DIST.is_dir():
+        return 1
+
+    dlls = {p.name.lower(): p for p in DIST.rglob("*.dll")}
+    exe = DIST / "ykxmz.exe"
+    check("ykxmz.exe 存在", exe.is_file())
+    if not exe.is_file():
+        return 1
+
+    # ---- 1. Python 运行库版本 ----
+    print()
+    print("一、Python 运行库")
+    py_dlls = sorted(n for n in dlls if n.startswith("python3") and n.endswith(".dll"))
+    for n in py_dlls:
+        print("       %s" % n)
+    check("有 python38.dll（3.8 打的）",
+          any("python38" in n for n in py_dlls),
+          "没有 python38.dll 说明不是 3.8 打的")
+    bad_py = [n for n in py_dlls
+              if any(v in n for v in ("python39", "python310", "python311",
+                                      "python312", "python313", "python314"))]
+    check("没有 3.9+ 的运行库", not bad_py,
+          "3.9+ 的包在 Win7 上会因为缺 DLL 启动失败：%s" % bad_py)
+
+    # ---- 2. 那个要命的 DLL ----
+    print()
+    print("二、Win7 上不存在的那个 DLL")
+    killer = "api-ms-win-core-path-l1-1-0.dll"
+    has = killer in dlls
+    check("**没有** %s" % killer, not has,
+          "有它就说明是 3.9+ 打的 —— Win7 上必然报缺 DLL")
+    print("       （这个 DLL 是 Win8+ 才有的。Python 3.9 起用到它，")
+    print("         放进来也没用，Win7 上加载不了。）")
+
+    # ---- 3. 位数 ----
+    print()
+    print("三、位数")
+    m = pe_machine(exe)
+    arch = {0x14C: "32 位 (x86)", 0x8664: "64 位 (x64)"}.get(m, "未知 (0x%X)" % m)
+    print("       ykxmz.exe: %s" % arch)
+    check("是 32 位（Win7 32/64 位都能跑）", m == 0x14C,
+          "64 位的包在 32 位 Windows 上起不来；学校机器可能是 32 位")
+
+    # ---- 4. 体积概览 ----
+    print()
+    print("四、产物概览")
+    files = list(DIST.rglob("*"))
+    files = [f for f in files if f.is_file()]
+    total = sum(f.stat().st_size for f in files)
+    print("       文件数: %d" % len(files))
+    print("       总大小: %.1f MB" % (total / 1048576))
+    print("       exe 大小: %.1f MB" % (exe.stat().st_size / 1048576))
+
+    print()
+    print("=" * 58)
+    if FAILS:
+        print("  失败 %d 项：%s" % (len(FAILS), ", ".join(FAILS)))
+        print("  这个包学校电脑装不上，不该发布。")
+        return 1
+    print("  ✅ 可以在 Windows 7 / 8 / 10 / 11 上运行")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/chk_ab.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+# 看配比对照有没有开始
+set -u
+
+echo "  ── 隧道当前配比 ──"
+for s in lanremote-tunnel lanremote-tunnel-h2; do
+    printf "    %-24s %s  (%s)\n" "$s" \
+        "$(grep -oE -- '--ha-connections [0-9]+' "/etc/systemd/system/$s.service" 2>/dev/null | tr '\n' ' ')" \
+        "$(systemctl is-active "$s" 2>/dev/null)"
+done
+
+echo
+echo "  ── 对照脚本/进程 ──"
+pgrep -af 'ab_long|rp_ab|collapse|ratio' 2>/dev/null | head -5 | sed 's/^/    /' || echo "    （没在跑）"
+
+echo
+echo "  ── 最近 20 分钟内设备上改过的文件 ──"
+find /root -maxdepth 1 -type f -mmin -20 2>/dev/null | head -10 | sed 's/^/    /' || true
+
+echo
+echo "  ── 有没有对照的产物 ──"
+ls -la --time-style=+%H:%M /root/*ab*.tsv /root/*ab*.out /root/*ratio*.tsv /root/*collapse*.tsv 2>/dev/null | sed 's/^/    /' || echo "    （没有）"
+
+echo
+echo "  ── 公网 ──"
+curl -s --max-time 20 -o /dev/null -w '    HTTP %{http_code}  %{time_total}s\n' \
+    -H 'User-Agent: LanRemote/1.8.2' https://relay.xxmxxs.top/v1/health
+
+echo
+echo "  ── 时间 ──"
+date '+    %H:%M:%S'

_build/chk_ab_now.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+# A/B 对照现状（我换密码重启中转打断了 A 组）
+set -u
+echo "  ══ $(date '+%H:%M:%S') ══"
+echo
+echo "  ── A 组 ──"
+[ -f /root/ab_A.out ] && cat /root/ab_A.out | sed 's/^/    /'
+n=0; [ -f /root/ab_A_health.tsv ] && n=$(wc -l < /root/ab_A_health.tsv)
+echo "    样本: $n"
+[ -f /root/ab_A_summary.txt ] && echo "    ── 汇总 ──" && cat /root/ab_A_summary.txt | sed 's/^/    /'
+[ -f /root/ab_A_health.tsv ] && echo "    最后 2 条:" && tail -2 /root/ab_A_health.tsv | sed 's/^/      /'
+echo
+echo "  ── B 组 ──"
+[ -f /root/ab_B.out ] && cat /root/ab_B.out | sed 's/^/    /' || echo "    （没开始）"
+n2=0; [ -f /root/ab_B_health.tsv ] && n2=$(wc -l < /root/ab_B_health.tsv)
+echo "    样本: $n2"
+echo
+echo "  ── 进程 ──"
+pgrep -af 'rpab|rp_ab' 2>/dev/null | head -3 | sed 's/^/    /' || echo "    （没有在跑）"
+echo
+echo "  ── 记忆/CPU 采样（它加的那个）──"
+[ -f /root/ab_A_res.tsv ] && head -3 /root/ab_A_res.tsv | sed 's/^/    /'
+echo
+echo "  ── 当前配比 ──"
+for s in lanremote-tunnel lanremote-tunnel-h2; do
+    printf "    %-24s %s\n" "$s" \
+        "$(grep -oE -- '--ha-connections [0-9]+' "/etc/systemd/system/$s.service" 2>/dev/null | tr '\n' ' ')"
+done
+echo
+echo "  ── 公网 ──"
+curl -s --max-time 15 -o /dev/null -w '    HTTP %{http_code}  %{time_total}s\n' \
+    -H 'User-Agent: LanRemote/1.8.2' https://relay.xxmxxs.top/v1/health

_build/chk_admin_deployed.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+# 对比设备上的 relay 文件和仓库里的版本
+set -u
+
+D=/root/lanremote-relay
+echo "  ── 设备上的文件 ──"
+ls -la --time-style=+%m-%d_%H:%M "$D"/*.py 2>/dev/null | sed 's/^/    /'
+
+echo
+echo "  ── relay.py 版本号 ──"
+grep -n '^VERSION' "$D/relay.py" 2>/dev/null | sed 's/^/    /'
+
+echo
+echo "  ── admin.py 里有没有新功能 ──"
+for kw in allowNew data-recode set_allow_new set_device_code; do
+    n=$(grep -c "$kw" "$D/admin.py" 2>/dev/null || echo 0)
+    n2=$(grep -c "$kw" "$D/relay.py" 2>/dev/null || echo 0)
+    printf "    %-16s admin.py:%s  relay.py:%s\n" "$kw" "$n" "$n2"
+done
+
+echo
+echo "  ── admin.py 大小和 md5 ──"
+md5sum "$D/admin.py" 2>/dev/null | sed 's/^/    /'
+wc -c "$D/admin.py" 2>/dev/null | sed 's/^/    /'
+
+echo
+echo "  ── 服务状态 ──"
+systemctl is-active lanremote-relay 2>/dev/null | sed 's/^/    relay: /'
+echo "    启动于: $(systemctl show -p ActiveEnterTimestamp --value lanremote-relay 2>/dev/null)"
+
+echo
+echo "  ── 实际返回的管理页开头（看是不是管理页）──"
+KEY=$(cat "$D/data/admin_key.txt" 2>/dev/null)
+curl -s --max-time 15 "http://127.0.0.1:8080/zhongzhuanzhan?key=$KEY" 2>/dev/null | head -c 400
+echo
+echo "    （上面这段的头 400 字节）"

_build/chk_poll30.sh

@@ -0,0 +1,63 @@
+#!/bin/bash
+# 看 relay-stability 的 30 次长轮询结果（目标 2）
+set -u
+
+echo "  ── 汇总文件 ──"
+[ -f /root/rp_poll30_summary.txt ] && cat /root/rp_poll30_summary.txt | sed 's/^/    /'
+echo
+echo "  ── 明细（前 5 行看格式）──"
+[ -f /root/rp_poll30.tsv ] && head -5 /root/rp_poll30.tsv | sed 's/^/    /'
+
+echo
+echo "  ── 自己再算一遍 ──"
+python3 - <<'PYEOF'
+from pathlib import Path
+
+p = Path("/root/rp_poll30.tsv")
+if not p.is_file():
+    print("    没有文件")
+    raise SystemExit(0)
+
+rows = []
+for line in p.read_text(encoding="utf-8", errors="replace").splitlines():
+    line = line.strip()
+    if not line:
+        continue
+    parts = [x.strip() for x in line.replace(",", "\t").split("\t") if x.strip()]
+    if not parts:
+        continue
+    # 找出状态码和耗时
+    code = None
+    ms = None
+    for x in parts:
+        if x in ("200", "502", "530", "000", "401", "504"):
+            code = x
+        elif x.replace(".", "").isdigit() and "." not in x and len(x) >= 4:
+            try:
+                v = int(x)
+                if 500 <= v <= 300000 and ms is None:
+                    ms = v
+            except ValueError:
+                pass
+    if code:
+        rows.append((code, ms))
+
+if not rows:
+    print("    解析不出样本，原始内容：")
+    print(p.read_text(encoding="utf-8", errors="replace")[:400])
+    raise SystemExit(0)
+
+total = len(rows)
+ok = sum(1 for c, _m in rows if c == "200")
+print("    样本 %d，成功 %d，可用率 %.1f%%" % (total, ok, ok * 100.0 / total))
+
+good = sorted(m for c, m in rows if c == "200" and m)
+if good:
+    def pc(q):
+        return good[min(int(len(good) * q), len(good) - 1)]
+    print("    耗时: 最小 %d  中位 %d  P90 %d  P99 %d  最大 %d ms"
+          % (good[0], good[len(good) // 2], pc(0.9), pc(0.99), good[-1]))
+    print("    （理想值 = 60000 + 隧道开销；>90000 的算异常长尾）")
+    outliers = [m for m in good if m > 90000]
+    print("    异常长尾（>90 秒）: %d 次 %s" % (len(outliers), outliers))
+PYEOF

_build/chk_rp_progress.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+# 看 relay-stability 在设备上跑到哪了
+set -u
+
+echo "  ── 它起的进程 ──"
+pgrep -af 'rp_|long2h|ab_long|collapse' 2>/dev/null | head -6 | sed 's/^/    /' || echo "    （没有）"
+
+echo
+echo "  ── /root 下它最近写的文件 ──"
+ls -la --time-style=+%H:%M:%S /root/rp_* /root/*.tsv /root/*.txt /root/*.out 2>/dev/null \
+    | sort -k6 | tail -12 | sed 's/^/    /'
+
+echo
+echo "  ── 那个 2 小时长测的输出 ──"
+if [ -f /root/long2h_health.tsv ]; then
+    echo "    样本数: $(wc -l < /root/long2h_health.tsv)"
+    echo "    最后 3 行:"
+    tail -3 /root/long2h_health.tsv | sed 's/^/      /'
+fi
+
+echo
+echo "  ── 配比对照有没有开始（看隧道配置变没变）──"
+for s in lanremote-tunnel lanremote-tunnel-h2; do
+    printf "    %-24s %s\n" "$s" \
+        "$(grep -oE -- '--protocol [a-z0-9]+|--ha-connections [0-9]+' /etc/systemd/system/$s.service 2>/dev/null | tr '\n' ' ')"
+done
+for p in 20241 20242; do
+    n=$(curl -s --max-time 4 "http://127.0.0.1:$p/metrics" 2>/dev/null \
+        | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}')
+    printf "    端口 %s -> %s 条\n" "$p" "${n:-读不到}"
+done
+
+echo
+echo "  ── 公网自检 ──"
+curl -s --max-time 20 -o /dev/null -w '    HTTP %{http_code}  %{time_total}s\n' \
+    -H 'User-Agent: LanRemote/1.8.2' https://relay.xxmxxs.top/v1/health
+
+echo
+echo "  ── 设备当前时间 ──"
+date '+    %H:%M:%S'

_build/chk_tunnel_now.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+# 看设备上隧道现在的配比 + 连接数（判断 relay-stability 有没有在跑对照）
+set -u
+
+echo "  ── 两个隧道单元的配置 ──"
+for s in lanremote-tunnel lanremote-tunnel-h2; do
+    if [ -f "/etc/systemd/system/$s.service" ]; then
+        cfg=$(grep -oE -- '--protocol [a-z0-9]+|--ha-connections [0-9]+|--metrics [0-9.:]+' \
+              "/etc/systemd/system/$s.service" | tr '\n' ' ')
+        printf "  %-24s %s  (%s)\n" "$s" "$cfg" "$(systemctl is-active $s 2>/dev/null)"
+    else
+        printf "  %-24s （不存在）\n" "$s"
+    fi
+done
+
+echo
+echo "  ── 实时连接数 ──"
+for p in 20241 20242; do
+    n=$(curl -s --max-time 4 "http://127.0.0.1:$p/metrics" 2>/dev/null \
+        | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}')
+    printf "    端口 %s -> %s 条\n" "$p" "${n:-读不到}"
+done
+
+echo
+echo "  ── 公网自检 ──"
+curl -s --max-time 20 -o /dev/null -w '    HTTP %{http_code}  %{time_total}s\n' \
+    -H 'User-Agent: LanRemote/1.8.2' https://relay.xxmxxs.top/v1/health
+
+echo
+echo "  ── relay-stability 的测量进程 ──"
+pgrep -af 'rp_|longstab|bench' 2>/dev/null | head -5 | sed 's/^/    /' || echo "    （没有在跑）"
+
+echo
+echo "  ── 它最近写的文件 ──"
+ls -la --time-style=+%H:%M:%S /root/rp_* /root/*.tsv 2>/dev/null | tail -8 | sed 's/^/    /' || true

_build/clean_dup_assets.py

@@ -0,0 +1,158 @@
+# -*- coding: utf-8 -*-
+r'''统一清理两个平台发行版里的重复附件。
+
+背景：
+    重发时如果只"复用已有发行版"，附件会一次次堆积。
+    Gitee 尤其绕：`GET /releases/tags/{tag}` 返回的 `assets`
+    **只有 name 和 download_url，没有 id**，所以没法删。
+    但另一个接口有 id：
+        GET    /repos/{o}/{r}/releases/{id}/attach_files  -> 带 id
+        DELETE /repos/{o}/{r}/releases/{id}/attach_files/{attach_id}
+
+    Gitea/EzHub 则直接有 assets[].id。
+
+策略：同名附件只保留最新的一份，其余删掉。
+支持 --dry 先看要删什么。
+'''
+from __future__ import annotations
+
+import json
+import sys
+import time
+import urllib.error
+import urllib.request
+from collections import defaultdict
+from pathlib import Path
+
+ROOT = Path(r"C:\Users\shu\Desktop\deepseekagent\LanRemote")
+GT = (ROOT / "_build" / ".gitee_token").read_text(encoding="utf-8").strip()
+ET = (Path.home() / ".ykxmz" / "ezhub_token").read_text(
+    encoding="utf-8").strip()
+TAG = "v1.8.0"
+
+# 这两个是 Gitee 自动生成的源码包，不是我们传的，不要动
+KEEP_ALWAYS = {"v1.8.0.zip", "v1.8.0.tar.gz"}
+
+
+def http(url: str, method: str = "GET", kind: str = "gitea",
+         token: str = "", tries: int = 3):
+    """带重试的请求。网络会抖，不重试会误判。"""
+    headers = {"User-Agent": "ykxmz-clean"}
+    if kind == "gitee":
+        sep = "&" if "?" in url else "?"
+        url = url + sep + "access_token=" + token
+    else:
+        headers["Authorization"] = "token " + token
+    last = None
+    for attempt in range(1, tries + 1):
+        try:
+            req = urllib.request.Request(url, method=method, headers=headers)
+            with urllib.request.urlopen(req, timeout=90) as resp:
+                text = resp.read().decode("utf-8", "replace")
+                return resp.status, (json.loads(text) if text.strip() else {})
+        except urllib.error.HTTPError as exc:
+            return exc.code, exc.read().decode("utf-8", "replace")[:200]
+        except Exception as exc:                      # noqa: BLE001
+            last = exc
+            if attempt < tries:
+                time.sleep(4)
+    return 0, str(last)
+
+
+def list_gitee_assets(rid: int) -> list:
+    """Gitee 要单独调 attach_files 才拿得到 id。"""
+    status, data = http(
+        "https://gitee.com/api/v5/repos/xmz7891/ykxmz/releases/%s"
+        "/attach_files" % rid, kind="gitee", token=GT)
+    if status != 200 or not isinstance(data, list):
+        print("    [失败] 取 Gitee 附件列表 HTTP %s: %s" % (status, data))
+        return []
+    return data
+
+
+def list_gitea_assets(rid: int) -> list:
+    status, data = http(
+        "https://git.261826.xyz/api/v1/repos/xmz/ykxmz/releases/%s"
+        % rid, kind="gitea", token=ET)
+    if status != 200:
+        print("    [失败] 取 EzHub 发行版 HTTP %s" % status)
+        return []
+    return data.get("assets") or []
+
+
+def clean(platform: str, rid: int, assets: list, dry: bool) -> int:
+    groups = defaultdict(list)
+    for a in assets:
+        name = a.get("name") or "?"
+        if name in KEEP_ALWAYS:
+            continue
+        groups[name].append(a)
+
+    removed = 0
+    for name, items in sorted(groups.items()):
+        if len(items) <= 1:
+            continue
+        # 新的排前面
+        items.sort(key=lambda x: str(x.get("created_at") or ""), reverse=True)
+        keep = items[0]
+        print("    %-32s %d 份 -> 保留 id=%s" % (name, len(items),
+                                                keep.get("id")))
+        for extra in items[1:]:
+            aid = extra.get("id")
+            if dry:
+                print("        （演练）会删 id=%s" % aid)
+                removed += 1
+                continue
+            if platform == "gitee":
+                url = ("https://gitee.com/api/v5/repos/xmz7891/ykxmz"
+                       "/releases/%s/attach_files/%s" % (rid, aid))
+            else:
+                url = ("https://git.261826.xyz/api/v1/repos/xmz/ykxmz"
+                       "/releases/%s/assets/%s" % (rid, aid))
+            status, body = http(url, method="DELETE",
+                                kind=("gitee" if platform == "gitee"
+                                      else "gitea"),
+                                token=(GT if platform == "gitee" else ET))
+            if status in (200, 204):
+                print("        ✓ 删了 id=%s" % aid)
+                removed += 1
+            else:
+                print("        ✗ id=%s HTTP %s %s"
+                      % (aid, status, str(body)[:80]))
+    return removed
+
+
+def main() -> int:
+    dry = "--dry" in sys.argv
+    total = 0
+
+    print("  ═══ Gitee ═══")
+    status, rel = http("https://gitee.com/api/v5/repos/xmz7891/ykxmz"
+                       "/releases/tags/" + TAG, kind="gitee", token=GT)
+    if status == 200:
+        rid = rel.get("id")
+        assets = list_gitee_assets(rid)
+        print("    发行版 id=%s，可删附件 %d 个" % (rid, len(assets)))
+        total += clean("gitee", rid, assets, dry)
+    else:
+        print("    [失败] HTTP %s" % status)
+    print()
+
+    print("  ═══ EzHub ═══")
+    status, rel = http("https://git.261826.xyz/api/v1/repos/xmz/ykxmz"
+                       "/releases/tags/" + TAG, kind="gitea", token=ET)
+    if status == 200:
+        rid = rel.get("id")
+        assets = list_gitea_assets(rid)
+        print("    发行版 id=%s，附件 %d 个" % (rid, len(assets)))
+        total += clean("gitea", rid, assets, dry)
+    else:
+        print("    [失败] HTTP %s" % status)
+
+    print()
+    print("  %s %d 个" % ("演练：会删" if dry else "共删", total))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/clean_ezhub_assets.py

@@ -0,0 +1,108 @@
+# -*- coding: utf-8 -*-
+r'''清理 EzHub 发行版里重复的附件。
+
+为什么会重复：
+    release_all.py 发现标签已有发行版时会"复用它"，
+    但**没有先删同名附件**，于是每跑一次就多传一遍。
+    我调试时跑了几次，同一个文件就堆了 2~3 份。
+
+这个脚本：同名附件只保留最新的一份，其余删掉。
+（Gitea 的附件用 id 区分，创建时间看 created_at。）
+'''
+from __future__ import annotations
+
+import json
+import sys
+import urllib.error
+import urllib.request
+from collections import defaultdict
+from pathlib import Path
+
+TOKEN = (Path.home() / ".ykxmz" / "ezhub_token").read_text(
+    encoding="utf-8").strip()
+API = "https://git.261826.xyz/api/v1/repos/xmz/ykxmz"
+TAG = "v1.8.0"
+HEAD = {"Authorization": "token " + TOKEN, "User-Agent": "ykxmz-clean"}
+
+
+def call(url: str, method: str = "GET"):
+    req = urllib.request.Request(url, method=method, headers=HEAD)
+    try:
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            text = resp.read().decode("utf-8", "replace")
+            return resp.status, (json.loads(text) if text.strip() else {})
+    except urllib.error.HTTPError as exc:
+        body = exc.read().decode("utf-8", "replace")[:200]
+        return exc.code, body
+
+
+def main() -> int:
+    dry = "--dry" in sys.argv
+
+    status, release = call("%s/releases/tags/%s" % (API, TAG))
+    if status != 200:
+        print("  [失败] 取发行版 HTTP %s: %s" % (status, release))
+        return 1
+    rid = release["id"]
+    assets = release.get("assets") or []
+    print("  发行版 id=%s，附件 %d 个" % (rid, len(assets)))
+
+    # 按文件名分组
+    groups = defaultdict(list)
+    for a in assets:
+        groups[a.get("name") or "?"].append(a)
+
+    print()
+    print("  分组情况:")
+    to_delete = []
+    for name, items in sorted(groups.items()):
+        # 新的排在前面（created_at 降序）
+        items.sort(key=lambda x: x.get("created_at") or "", reverse=True)
+        keep = items[0]
+        print("    %-32s 共 %d 份，保留 id=%s（%s）"
+              % (name, len(items), keep.get("id"),
+                 (keep.get("created_at") or "")[:19]))
+        for extra in items[1:]:
+            print("        删 id=%s（%s）" % (extra.get("id"),
+                                              (extra.get("created_at")
+                                               or "")[:19]))
+            to_delete.append(extra)
+
+    if not to_delete:
+        print()
+        print("  ✓ 没有重复，不用清理")
+        return 0
+
+    print()
+    if dry:
+        print("  演练：会删 %d 个（去掉 --dry 真删）" % len(to_delete))
+        return 0
+
+    print("  开始删除 %d 个重复附件…" % len(to_delete))
+    ok = 0
+    for asset in to_delete:
+        status, body = call("%s/releases/%s/assets/%s"
+                            % (API, rid, asset.get("id")), method="DELETE")
+        if status in (200, 204):
+            print("    ✓ 删了 id=%s %s" % (asset.get("id"),
+                                           asset.get("name")))
+            ok += 1
+        else:
+            print("    ✗ id=%s HTTP %s %s" % (asset.get("id"), status, body))
+
+    print()
+    print("  删除 %d/%d" % (ok, len(to_delete)))
+
+    # 复查
+    status, release = call("%s/releases/tags/%s" % (API, TAG))
+    assets = release.get("assets") or []
+    print()
+    print("  现在剩 %d 个附件:" % len(assets))
+    for a in assets:
+        print("    %-32s %8.2f MB"
+              % (a.get("name"), (a.get("size") or 0) / 1024 / 1024))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/cleanup_device.sh

@@ -0,0 +1,85 @@
+#!/bin/bash
+# 安全清理随身 WiFi 上的垃圾。
+#
+# 原则：先看清楚再删，删之前把「为什么它一定是垃圾」写下来。
+# 中转相关的目录（/root/lanremote-relay、/root/.cloudflared）一律不碰。
+set -u
+
+BEFORE=$(df -m / | awk 'NR==2 {print $4}')
+echo "════════ 清理前：可用 ${BEFORE} MB ════════"
+echo
+
+echo "════════ 0. 先看 nginx 到底在提供什么（决定动不动它）════════"
+echo "  在跑: $(systemctl is-active nginx)"
+echo "  根目录配置:"
+grep -hE '^\s*(root|server_name|listen)' /etc/nginx/sites-enabled/* /etc/nginx/conf.d/*.conf 2>/dev/null | head -10 | sed 's/^/    /'
+echo "  /var/www 内容:"
+ls -1 /var/www 2>/dev/null | sed 's/^/    /'
+echo "  首页大小: $(stat -c%s /var/www/html/index.nginx-debian.html 2>/dev/null || echo 0) 字节"
+echo "  → 这是 Debian 装 nginx 的默认欢迎页，和中转无关。"
+echo "    **但为了安全我不删 nginx**（万一有人拿它做别的），只报告。"
+
+echo
+echo "════════ 1. 删 /var/lib/mysql（113 MB）════════"
+echo "  依据："
+echo "    * dpkg 里没有任何 mysql/mariadb 包（0 个已安装）"
+echo "    * 没有任何 mysqld 进程"
+echo "    * 没有 mariadb/mysql 的 systemd 服务"
+echo "    → 这是历史遗留的数据目录，包都卸了，目录没删干净。"
+if [ -d /var/lib/mysql ]; then
+    echo "  删除前确认没有进程占用: $(fuser -m /var/lib/mysql 2>/dev/null | wc -l) 个"
+    if [ "$(pgrep -c -f 'mysqld|mariadb' 2>/dev/null || echo 0)" -eq 0 ] \
+       && [ "$(dpkg -l 2>/dev/null | grep -cE '^ii +(mysql-server|mariadb-server)')" -eq 0 ]; then
+        rm -rf /var/lib/mysql
+        echo "  ✓ 已删除 /var/lib/mysql"
+    else
+        echo "  ! 检测到 mysql 相关包或进程，**跳过**（安全第一）"
+    fi
+else
+    echo "  （不存在，跳过）"
+fi
+
+echo
+echo "════════ 2. 清 apt 缓存和索引（约 162 MB）════════"
+echo "  依据：/var/cache/apt 是已下载的 .deb 缓存，随时可重下；"
+echo "        /var/lib/apt/lists 是索引，apt update 会重建。"
+apt-get clean 2>/dev/null
+rm -rf /var/lib/apt/lists/* 2>/dev/null
+echo "  ✓ 已清理"
+
+echo
+echo "════════ 3. 压缩 journald 日志（约 10 MB）════════"
+journalctl --vacuum-size=8M 2>&1 | tail -2 | sed 's/^/  /'
+
+echo
+echo "════════ 4. 清理我遗留的调试脚本（173 个）════════"
+echo "  这些是我这几次调试时上传到 /root 的临时脚本（ab*.sh、bench.sh 等），"
+echo "  中转本身不需要它们。"
+echo "  ⚠ 保留：中转目录、.cloudflared、以及任何看起来像正式运维脚本的"
+n=$(ls -1 /root/*.sh /root/*.py 2>/dev/null | wc -l)
+echo "  清理前: $n 个"
+mkdir -p /root/.trash-debug
+# 只移动我确定是调试用的（a开头/ab开头/bench/check开头等），保留其他
+for f in /root/a*.sh /root/ab*.sh /root/bench*.sh /root/check_*.sh /root/diag_*.sh \
+         /root/dl*.sh /root/final*.sh /root/post_*.sh /root/probe*.py /root/smart_*.sh \
+         /root/setup_*.sh /root/test_*.sh /root/why_*.sh /root/fa*.sh /root/tc*.sh \
+         /root/cc*.sh /root/sa*.sh /root/sq.sh /root/dc.sh /root/vc*.sh; do
+    [ -f "$f" ] && mv "$f" /root/.trash-debug/ 2>/dev/null
+done
+moved=$(ls -1 /root/.trash-debug 2>/dev/null | wc -l)
+echo "  已移走 $moved 个到 /root/.trash-debug（先不真删，确认没问题再删）"
+echo "  /root 下剩余: $(ls -1 /root/*.sh /root/*.py 2>/dev/null | wc -l) 个"
+
+echo
+echo "════════ 5. 中转目录（绝对不动）════════"
+du -sh /root/lanremote-relay /root/.cloudflared 2>/dev/null | sed 's/^/  /'
+echo "  → 这两个是命根子，一个字节都没碰"
+
+echo
+AFTER=$(df -m / | awk 'NR==2 {print $4}')
+echo "════════ 结果 ════════"
+echo "  可用空间: ${BEFORE} MB -> ${AFTER} MB   （腾出 $((AFTER - BEFORE)) MB）"
+df -h / | sed 's/^/  /'
+echo
+echo "  磁盘总览:"
+du -xhd1 / 2>/dev/null | sort -rh | head -8 | sed 's/^/    /'

_build/cleanup_device2.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+# 补删 /var/lib/mysql（上一条脚本的整数判断写错了，误跳过）
+set -u
+
+echo "════════ 删除前的三重确认 ════════"
+echo "  1. 有没有 mysqld/mariadb 进程："
+n=$(pgrep -f 'mysqld|mariadb' 2>/dev/null | wc -l)
+echo "     $n 个"
+echo "  2. dpkg 里有没有 mysql/mariadb 包："
+p=$(dpkg -l 2>/dev/null | grep -cE '^ii +(mysql|mariadb)' || true)
+echo "     $p 个"
+echo "  3. 有没有相关 systemd 服务："
+s=$(systemctl list-unit-files 2>/dev/null | grep -cE '^(mysql|mariadb)' || true)
+echo "     $s 个"
+echo "  4. 目录大小：$(du -sh /var/lib/mysql 2>/dev/null | awk '{print $1}')"
+echo "  5. 有没有别的进程打开着里面的文件："
+fuser -m /var/lib/mysql 2>/dev/null | wc -l | sed 's/^/     /'
+
+if [ "$n" -eq 0 ] && [ "$p" -eq 0 ] && [ "$s" -eq 0 ]; then
+    echo
+    echo "  → 三项都是 0，确认是卸载残留的数据目录，删除"
+    rm -rf /var/lib/mysql
+    echo "  ✓ 已删除"
+else
+    echo
+    echo "  ! 还有引用，**不删**"
+fi
+
+echo
+echo "════════ 把剩余的调试脚本也移走 ════════"
+# 上一条只移走了一部分（通配符没覆盖全）。
+# 现在把 /root 下**所有顶层** .sh/.py 都移进回收目录 ——
+# 中转的运行时代码在 /root/lanremote-relay/ 里，不受影响。
+before=$(ls -1 /root/*.sh /root/*.py 2>/dev/null | wc -l)
+mkdir -p /root/.trash-debug
+for f in /root/*.sh /root/*.py; do
+    [ -f "$f" ] || continue
+    mv "$f" /root/.trash-debug/ 2>/dev/null
+done
+after=$(ls -1 /root/*.sh /root/*.py 2>/dev/null | wc -l)
+echo "  /root 顶层脚本: $before -> $after"
+echo "  回收目录里的: $(ls -1 /root/.trash-debug 2>/dev/null | wc -l) 个"
+echo "  ⚠ 没有真删，放在 /root/.trash-debug；确认中转一切正常后再 rm -rf"
+
+echo
+echo "════════ 确认中转没被影响 ════════"
+echo "  relay 服务: $(systemctl is-active lanremote-relay)"
+echo "  隧道(quic): $(systemctl is-active lanremote-tunnel)"
+echo "  隧道(h2):   $(systemctl is-active lanremote-tunnel-h2)"
+echo "  自检: $(curl -s --max-time 10 http://127.0.0.1:8080/v1/health | head -c 70)"
+echo
+echo "  中转目录完好: $(ls /root/lanremote-relay/ | tr '\n' ' ')"
+
+echo
+echo "════════ 最终空间 ════════"
+df -h / | sed 's/^/  /'
+echo
+du -xhd1 / 2>/dev/null | sort -rh | head -8 | sed 's/^/    /'

_build/dbg_cache_path.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+r'''临时调试：在首页分支里打一行日志，看它到底有没有被执行、extra 传的是什么。
+
+（这个文件只改运行环境里的 relay.py，不改本地仓库。）
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import paramiko
+
+HOST = "192.168.10.105"
+USER = "root"
+PASSWORD = "1313144"
+REMOTE = "/root/lanremote-relay/relay.py"
+
+
+def run(client, cmd: str, timeout: int = 60) -> str:
+    _in, out, err = client.exec_command(cmd, timeout=timeout)
+    return (out.read().decode("utf-8", "replace")
+            + err.read().decode("utf-8", "replace"))
+
+
+def main() -> int:
+    client = paramiko.SSHClient()
+    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+    client.connect(HOST, username=USER, password=PASSWORD, timeout=20,
+                   look_for_keys=False, allow_agent=False)
+    try:
+        # 1. 看看首页分支前后到底长什么样
+        print("  首页分支附近（1400-1415）:")
+        print(run(client, "sed -n '1400,1415p' " + REMOTE))
+
+        # 2. 检查 _send 是否真的会跳过默认头
+        print("  _send 的头部逻辑（895-920）:")
+        print(run(client, "sed -n '895,920p' " + REMOTE))
+
+        # 3. 用 python 直接调这份代码的 _send 看结果
+        probe = r'''
+import sys
+sys.path.insert(0, "/root/lanremote-relay")
+import relay, io
+
+captured = []
+class Fake:
+    def send_response(self, code): captured.append(("__status__", code))
+    def send_header(self, k, v): captured.append((k, v))
+    def end_headers(self): pass
+    wfile = io.BytesIO()
+
+f = Fake()
+relay.Handler._send(f, 200, b"hi", "text/html; charset=utf-8",
+                    {"Cache-Control": "public, max-age=60"})
+cc = [v for k, v in captured if k.lower() == "cache-control"]
+print("  _send 发出的 Cache-Control 值:", cc)
+print("  头数量:", len(cc))
+'''
+        Path("/tmp/probe_send.py").write_text(probe, encoding="utf-8")
+        client.exec_command("cat > /tmp/probe_send.py <<'PYEOF'\n"
+                            + probe + "\nPYEOF\n")[1].channel.recv_exit_status()
+        print("  _send 实测:")
+        print(run(client, "python3 /tmp/probe_send.py 2>&1"))
+
+        # 4. 看 do_GET 里 "/" 前面有没有别的 return
+        print("  do_GET 的 return 位置（1174-1412）:")
+        print(run(client, "awk 'NR>=1174 && NR<=1412 && "
+                          "/return|if path/ {print NR\": \"$0}' " + REMOTE
+                          + " | head -40"))
+    finally:
+        client.close()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/dbg_extract.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+r'''最小复现：只解压两个 zip，看进程会不会被杀。
+
+线索：test_package_remote.py 有时跑 1.6 秒、只打印一行"一、解压"就没了，
+退出码 -1。1.6 秒正好是解压 18.85 MB / 1001 个文件的时间，
+所以要确认"是不是解压这一步出的事"。
+
+每一步都 flush 打印，这样即使被杀也能看到死在哪一行。
+'''
+from __future__ import annotations
+
+import shutil
+import sys
+import tempfile
+import time
+import zipfile
+from pathlib import Path
+
+ROOT = Path(r"C:\Users\shu\Desktop\deepseekagent\LanRemote")
+AGENT = ROOT / "dist" / "ykxmz-agent-1.8.2.zip"
+SERVER = ROOT / "dist" / "ykxmz-server-1.8.2.zip"
+
+
+def say(msg: str) -> None:
+    print("  %s" % msg, flush=True)
+
+
+def main() -> int:
+    work = Path(tempfile.mkdtemp(prefix="dbg_extract_"))
+    say("工作目录 %s" % work)
+
+    for label, path in (("被控端", AGENT), ("服务器端", SERVER)):
+        say("准备解压 %s (%s)" % (label, path.name))
+        say("  文件存在: %s  大小 %.2f MB"
+            % (path.is_file(), path.stat().st_size / 1024 / 1024))
+        t0 = time.time()
+        with zipfile.ZipFile(path) as z:
+            names = z.namelist()
+            say("  条目数 %d" % len(names))
+            for i, name in enumerate(names):
+                z.extract(name, work)
+                if i % 200 == 0:
+                    say("    ... 已解压 %d/%d（%.1fs）"
+                        % (i, len(names), time.time() - t0))
+        say("  %s 解压完成，用了 %.1f 秒" % (label, time.time() - t0))
+
+    say("全部解压完成")
+    agent_dir = work / AGENT.stem
+    exe = agent_dir / "ykxmz.exe"
+    say("ykxmz.exe 在不在: %s" % exe.is_file())
+    if exe.is_file():
+        say("  exe 大小 %.2f MB" % (exe.stat().st_size / 1024 / 1024))
+
+    say("存活检查：睡 3 秒")
+    time.sleep(3)
+    say("还活着 ✓")
+
+    shutil.rmtree(work, ignore_errors=True)
+    say("清理完成，正常退出")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/dbg_java_step.py

@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+r'''单独复现 test_package_remote.py 的第四节（Java 手表端）。
+
+为什么单独跑：
+    整个测试里前三节都过了，第四节报
+        ConnectException: Connection refused
+    这不是链路抖动，是"根本没人在 8095 上监听"。
+    需要判断是中转进程死了，还是 Java 侧连错了地方。
+
+做法：起中转 -> 确认存活 -> 跑 Java 测试 -> 再确认存活，
+每一步都打印中转进程状态，坏在哪一步一目了然。
+'''
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+import urllib.request
+import zipfile
+from pathlib import Path
+
+ROOT = Path(r"C:\Users\shu\Desktop\deepseekagent\LanRemote")
+SERVER_ZIP = ROOT / "dist" / "ykxmz-server-1.8.2.zip"
+TOOLCHAIN = Path(r"C:\Users\shu\Desktop\deepseekagent\starklink\toolchain")
+JAVAC = TOOLCHAIN / "jdk17" / "bin" / "javac.exe"
+JAVA = TOOLCHAIN / "jdk17" / "bin" / "java.exe"
+RELAY_PORT = 8095
+PAIR_CODE = "778899"
+
+
+def alive(base: str) -> str:
+    try:
+        with urllib.request.urlopen(base + "/v1/health", timeout=3) as r:
+            snap = json.loads(r.read())
+        return "活着 设备=%d" % len(snap.get("devices", []))
+    except Exception as exc:                               # noqa: BLE001
+        return "!! 连不上: %s" % exc
+
+
+def main() -> int:
+    work = Path(tempfile.mkdtemp(prefix="dbg_java_"))
+    print("  工作目录 %s" % work)
+    with zipfile.ZipFile(SERVER_ZIP) as z:
+        z.extractall(work)
+    relay_dir = work / SERVER_ZIP.stem
+    relay_py = relay_dir / "relay.py"
+    print("  relay.py: %s" % relay_py.is_file())
+
+    data = work / "relaydata"
+    data.mkdir(parents=True, exist_ok=True)
+    env = dict(os.environ)
+    env.update({
+        "RELAY_PORT": str(RELAY_PORT), "RELAY_BIND": "127.0.0.1",
+        "RELAY_DATA": str(data), "RELAY_POLL": "8",
+        "PYTHONIOENCODING": "utf-8", "PYTHONUNBUFFERED": "1",
+    })
+    log = open(work / "relay.log", "wb")
+    proc = subprocess.Popen([sys.executable, "-u", str(relay_py)], env=env,
+                            stdout=log, stderr=subprocess.STDOUT)
+    base = "http://127.0.0.1:%d" % RELAY_PORT
+
+    try:
+        # 等中转起来
+        for _ in range(40):
+            time.sleep(0.5)
+            if alive(base).startswith("活着"):
+                break
+        print("  1. 中转启动后: %s" % alive(base))
+        print("     进程 poll() = %s（None 表示还活着）" % proc.poll())
+
+        # 编译 Java
+        classes = work / "classes"
+        classes.mkdir(parents=True, exist_ok=True)
+        src_dir = ROOT / "android" / "src" / "com" / "lanremote" / "watch"
+        sources = [src_dir / n for n in
+                   ("Json.java", "B64.java", "Transport.java",
+                    "RelayTransport.java", "TlsCompat.java",
+                    "RemoteClient.java", "DiscoveryCore.java")]
+        sources.append(ROOT / "_tests" / "java" / "JavaRelayTest.java")
+        comp = subprocess.run(
+            [str(JAVAC), "--release", "8", "-encoding", "UTF-8",
+             "-d", str(classes)] + [str(s) for s in sources],
+            capture_output=True, text=True, encoding="utf-8", errors="replace")
+        print("  2. Java 编译: %s" % ("OK" if comp.returncode == 0
+                                      else comp.stderr[:300]))
+        if comp.returncode != 0:
+            return 1
+
+        print("     编译后再看中转: %s" % alive(base))
+
+        # 跑 Java 测试
+        result = subprocess.run(
+            [str(JAVA), "-Dfile.encoding=UTF-8", "-cp", str(classes),
+             "JavaRelayTest", base, PAIR_CODE],
+            capture_output=True, text=True, encoding="utf-8",
+            errors="replace", timeout=120)
+        print("  3. Java 测试退出码 %d" % result.returncode)
+        for line in result.stdout.splitlines():
+            print("      %s" % line)
+        if result.stderr.strip():
+            print("      stderr: %s" % result.stderr.strip()[:400])
+
+        print("  4. Java 跑完后中转: %s" % alive(base))
+        print("     进程 poll() = %s" % proc.poll())
+
+        if proc.poll() is not None:
+            print()
+            print("  === 中转进程已经退出了，日志末尾 ===")
+            log.flush()
+            text = (work / "relay.log").read_text(encoding="utf-8",
+                                                  errors="replace")
+            print(text[-2500:])
+    finally:
+        try:
+            proc.terminate()
+            proc.wait(timeout=8)
+        except Exception:                                  # noqa: BLE001
+            proc.kill()
+        log.close()
+        print()
+        print("  日志留在: %s（没删，方便看）" % work)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/dbg_pkg_full.py

@@ -0,0 +1,272 @@
+# -*- coding: utf-8 -*-
+"""验证三件套压缩包：解压出来实际跑一遍。
+
+不只是看有没有文件 —— 要确认包里的东西**真的能用**：
+    1. 解压
+    2. 服务器端的 relay.py 能起、健康检查通过
+    3. 被控端的 EXE 能起、能连上包里那个中转
+    4. Java 手表端经这个中转连上被控端并执行命令
+    5. 清理
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+import urllib.request
+import zipfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+# 三端分开出（用户要求）：
+#   被控端 -> 一个 zip
+#   服务器端 -> 一个 zip
+#   控制端 -> 直接给 APK（不打 zip）
+AGENT_ZIP = ROOT / "dist" / "ykxmz-agent-1.8.2.zip"
+SERVER_ZIP = ROOT / "dist" / "ykxmz-server-1.8.2.zip"
+WATCH_APK = ROOT / "dist" / "ykxmz-watch-1.8.2.apk"
+TOOLCHAIN = Path(r"C:\Users\shu\Desktop\deepseekagent\starklink\toolchain")
+JAVAC = TOOLCHAIN / "jdk17" / "bin" / "javac.exe"
+JAVA = TOOLCHAIN / "jdk17" / "bin" / "java.exe"
+RELAY_PORT = 8095
+AGENT_PORT = 8895
+PAIR_CODE = "778899"
+
+passed = 0
+failed = 0
+
+
+def check(name, ok, detail=""):
+    global passed, failed
+    if ok:
+        passed += 1
+        print("  [PASS] " + name)
+    else:
+        failed += 1
+        print("  [FAIL] " + name + "  " + str(detail))
+
+
+def main() -> int:
+    # 1) 三个产物都要在
+    for label, path in (("被控端包", AGENT_ZIP), ("服务器端包", SERVER_ZIP),
+                        ("控制端 APK", WATCH_APK)):
+        if not path.is_file():
+            print(f"  找不到{label}: {path}")
+            return 1
+
+    work = Path(tempfile.mkdtemp(prefix="verify_pkg_"))
+    relay_proc = agent_proc = None
+    try:
+        # ---------------- 1. 解压两个 zip ----------------
+        print("一、解压（两个 zip）")
+        with zipfile.ZipFile(AGENT_ZIP) as archive:
+            archive.extractall(work)
+        with zipfile.ZipFile(SERVER_ZIP) as archive:
+            archive.extractall(work)
+
+        # 两个包各自带一层版本目录
+        agent_dir = work / AGENT_ZIP.stem
+        relay_dir = work / SERVER_ZIP.stem
+        check("被控端目录存在", agent_dir.is_dir(), agent_dir)
+        check("服务器端目录存在", relay_dir.is_dir(), relay_dir)
+
+        exe = agent_dir / "ykxmz.exe"
+        relay_py = relay_dir / "relay.py"
+        install_sh = relay_dir / "install.sh"
+        apk = WATCH_APK
+        check("被控端 EXE 在", exe.is_file())
+        check("服务器端 relay.py 在", relay_py.is_file())
+        check("服务器端 install.sh 在", install_sh.is_file())
+        check("服务器端带了网络调优脚本", (relay_dir / "net-tune.sh").is_file())
+        check("服务器端带了看门狗", (relay_dir / "watchdog.sh").is_file())
+        check("控制端 APK 在（直接在 dist 里）", apk.is_file(), apk)
+
+        # 说明文档要有 BOM（否则记事本会认成 GBK 乱码）
+        for label, path in (("被控端", agent_dir / "README-agent.txt"),
+                            ("服务器端", relay_dir / "README-server.txt"),
+                            ("控制端（旁边那份）",
+                             ROOT / "dist" / "ykxmz-watch-1.8.2-说明.txt")):
+            raw = path.read_bytes() if path.is_file() else b""
+            check(f"{label}说明有 UTF-8 BOM",
+                  raw[:3] == b"\xef\xbb\xbf", raw[:3])
+
+        # 三份正式文档：两个包里都要有
+        for label, base in (("被控端包", agent_dir), ("服务器端包", relay_dir)):
+            for doc in ("LICENSE.txt", "BEFORE-INSTALL.txt",
+                        "AFTER-INSTALL.txt"):
+                check(f"{label}带了 {doc}", (base / doc).is_file())
+
+        # 被控端目录里不该有 data / 说明残留
+        check("没有把 data 目录打进去",
+              not (agent_dir / "data").exists())
+        check("带了三个工具脚本",
+              all((agent_dir / n).is_file()
+                  for n in ("wlzj.bat", "xffhq.bat", "fxfhq.bat")),
+              [n for n in ("wlzj.bat", "xffhq.bat", "fxfhq.bat")
+               if not (agent_dir / n).is_file()])
+
+        # ---------------- 2. 起包里的中转 ----------------
+        print()
+        print("二、用包里的 relay.py 起中转")
+        relay_data = work / "relaydata"
+        relay_data.mkdir(parents=True, exist_ok=True)
+        env = dict(os.environ)
+        env.update({
+            "RELAY_PORT": str(RELAY_PORT), "RELAY_BIND": "127.0.0.1",
+            "RELAY_DATA": str(relay_data), "RELAY_POLL": "8",
+            "PYTHONIOENCODING": "utf-8", "PYTHONUNBUFFERED": "1",
+        })
+        relay_proc = subprocess.Popen(
+            [sys.executable, "-u", str(relay_py)], env=env,
+            stdout=open(work / "relay.log", "wb"),
+            stderr=subprocess.STDOUT)
+        base = f"http://127.0.0.1:{RELAY_PORT}"
+        up = False
+        for _ in range(40):
+            time.sleep(0.5)
+            try:
+                with urllib.request.urlopen(base + "/v1/health",
+                                            timeout=2) as r:
+                    if r.status == 200:
+                        up = True
+                        break
+            except Exception:                             # noqa: BLE001
+                continue
+        check("包里的中转能起", up)
+        if not up:
+            print((work / "relay.log").read_text(encoding="utf-8",
+                                                 errors="replace")[-800:])
+            return 1
+
+        # ---------------- 3. 起包里的被控端 ----------------
+        print()
+        print("三、用包里的 EXE 起被控端，让它连这个中转")
+        data_dir = agent_dir / "data"
+        data_dir.mkdir(parents=True, exist_ok=True)
+        sys.path.insert(0, str(ROOT / "windows"))
+        from lanremote.config import Store
+        store = Store(data_dir)
+        store.set_pairing_code(PAIR_CODE)
+        store.set("setup_done", True)
+        store.set("allow_new_pairing", True)
+        store.set("close_pair_after_first", False)
+        store.set("server_name", "包里测试电脑")
+        store.set("relay_url", base)
+        store.set("port", AGENT_PORT)
+
+        agent_proc = subprocess.Popen(
+            [str(exe), "--silent", "--port", str(AGENT_PORT)],
+            cwd=str(agent_dir),
+            stdout=open(work / "agent.log", "wb"),
+            stderr=subprocess.STDOUT)
+        online = False
+        info = {}
+        for _ in range(60):
+            time.sleep(1.0)
+            try:
+                with urllib.request.urlopen(base + "/v1/health",
+                                            timeout=3) as r:
+                    snap = json.loads(r.read())
+                for item in snap.get("devices", []):
+                    if item.get("online"):
+                        info = item
+                        online = True
+                        break
+            except Exception:                             # noqa: BLE001
+                continue
+            if online:
+                break
+        check("包里的 EXE 连上了包里的中转", online, str(info)[:150])
+        if not online:
+            print((work / "agent.log").read_text(encoding="utf-8",
+                                                 errors="replace")[-1000:])
+            return 1
+        check("配对码对得上", info.get("code") == PAIR_CODE, info.get("code"))
+        check("设备名对得上", info.get("name") == "包里测试电脑",
+              info.get("name"))
+
+        # ---------------- 4. Java 手表端 ----------------
+        print()
+        print("四、Java 手表端经这个中转连被控端")
+        print("  [调试] 进第四节前: relay poll()=%s agent poll()=%s"
+              % (relay_proc.poll(), agent_proc.poll()))
+        try:
+            import urllib.request as _u
+            with _u.urlopen(base + "/v1/health", timeout=3) as _r:
+                print("  [调试] 中转健康检查: %s" % _r.status)
+        except Exception as _e:
+            print("  [调试] 中转健康检查失败: %s" % _e)
+        classes = work / "classes"
+        classes.mkdir(parents=True, exist_ok=True)
+        sources = [ROOT / "android" / "src" / "com" / "lanremote" / "watch" / n
+                   for n in ("Json.java", "B64.java", "Transport.java",
+                             "RelayTransport.java", "TlsCompat.java",
+                             "RemoteClient.java",
+                             "DiscoveryCore.java")]
+        sources.append(ROOT / "_tests" / "java" / "JavaRelayTest.java")
+        comp = subprocess.run(
+            [str(JAVAC), "--release", "8", "-encoding", "UTF-8",
+             "-d", str(classes)] + [str(s) for s in sources],
+            capture_output=True, text=True, encoding="utf-8", errors="replace")
+        check("Java 编译通过", comp.returncode == 0, comp.stderr[:200])
+        if comp.returncode != 0:
+            return 1
+
+        # 这条链路实测只有 ~75% 可用（丢包 40%，边缘还在美西），
+        # 而这里串行发多个请求，任何一个被丢就整体失败 —— 会假失败。
+        # 测试要验证的是**产品逻辑**，链路可靠性有专门的可用率测量盯着。
+        # 所以重试 3 次，任一次全过就算过。
+        result = None
+        tail = ""
+        for attempt in range(3):
+            result = subprocess.run(
+                [str(JAVA), "-Dfile.encoding=UTF-8", "-cp", str(classes),
+                 "JavaRelayTest", base, PAIR_CODE],
+                capture_output=True, text=True, encoding="utf-8",
+                errors="replace")
+            tail = (result.stdout.strip().splitlines()[-1]
+                    if result.stdout.strip() else "")
+            if result.returncode == 0 and "失败 0 项" in tail:
+                if attempt:
+                    print(f"      （第 {attempt + 1} 次才通过 —— "
+                          f"链路抖动，不是产品问题）")
+                break
+            if attempt < 2:
+                time.sleep(2.0)
+        check("Java 手表端经中转全部通过",
+              result is not None and result.returncode == 0
+              and "失败 0 项" in tail, tail)
+        for line in result.stdout.splitlines():
+            if "[FAIL]" in line:
+                print("      " + line.strip())
+
+        print()
+        print("=" * 66)
+        print(f"通过 {passed} 项，失败 {failed} 项")
+        return 0 if failed == 0 else 1
+    finally:
+        for process in (agent_proc, relay_proc):
+            if process is not None:
+                try:
+                    process.terminate()
+                    process.wait(timeout=8)
+                except Exception:                         # noqa: BLE001
+                    try:
+                        process.kill()
+                    except Exception:                 # noqa: BLE001
+                        pass
+        time.sleep(1)
+        print()
+        print('  [调试] 临时目录保留在: %s' % work)
+        for _p in (relay_proc, agent_proc):
+            if _p is not None:
+                print('  [调试] 进程 %s poll()=%s'
+                      % (_p.pid, _p.poll()))
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/dbg_setcode.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+r'''单独查 set_code 为什么没返回 kicked。'''
+import json
+import time
+import urllib.error
+import urllib.request
+
+BASE = "http://127.0.0.1:8080"
+KEY = open("/root/lanremote-relay/data/admin_key.txt", encoding="utf-8").read().strip()
+
+
+def call(path, payload=None, method="POST", admin=False):
+    data = json.dumps(payload).encode() if payload is not None else None
+    h = {"Content-Type": "application/json"}
+    if admin:
+        h["X-Admin"] = KEY
+    req = urllib.request.Request(BASE + path, data=data, headers=h, method=method)
+    try:
+        with urllib.request.urlopen(req, timeout=15) as r:
+            body = r.read().decode("utf-8", "replace")
+            try:
+                return r.status, json.loads(body)
+            except Exception:
+                return r.status, body
+    except urllib.error.HTTPError as e:
+        body = e.read().decode("utf-8", "replace")
+        try:
+            return e.code, json.loads(body)
+        except Exception:
+            return e.code, body
+
+
+stamp = int(time.time())
+dev = "dbg-%d" % stamp
+c1 = "%06d" % ((stamp + 1) % 1000000)
+c2 = "%06d" % ((stamp + 2) % 1000000)
+
+print("1. 注册设备")
+print("  ", call("/v1/agent/register",
+                {"deviceId": dev, "code": c1, "name": "dbg", "version": "1.8.2"}))
+
+print("2. attach 造一个会话")
+print("  ", call("/v1/client/attach", {"code": c1, "name": "手表"}))
+
+print("3. 看会话数")
+st, h = call("/v1/health", method="GET")
+print("   sessions =", h.get("sessions"))
+
+print("4. 改码 %s -> %s" % (c1, c2))
+st, r = call("/v1/admin/set_code", {"deviceId": dev, "code": c2}, admin=True)
+print("   状态码:", st)
+print("   响应:", json.dumps(r, ensure_ascii=False))
+
+print("5. 再改一次（同样改 %s -> 另一个码）" % c2)
+c3 = "%06d" % ((stamp + 3) % 1000000)
+st, r = call("/v1/admin/set_code", {"deviceId": dev, "code": c3}, admin=True)
+print("   响应:", json.dumps(r, ensure_ascii=False))
+
+print("6. 清理")
+print("  ", call("/v1/admin/delete", {"deviceId": dev}, admin=True))

_build/debug_rescue_000.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+r'''查 /rescue/ 为什么返回 HTTP 000。
+
+000 是 curl 的"没拿到任何响应"。但同一个端口上 /v1/health 是好的、
+目录穿越请求也能拿到 404 —— 说明不是端口不通，是**特定路径**出问题。
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "_build"))
+from devssh import run      # noqa: E402
+
+REMOTE = r'''
+RELAY=/root/lanremote-relay
+B=http://127.0.0.1:8080
+
+echo "════ 造一份报告 ════"
+printf '测试报告\n\n  判断：测试结论\n' > $RELAY/rescue_reports/19700101-000000-demo.txt
+ls -la $RELAY/rescue_reports/ | sed 's/^/  /'
+
+echo
+echo "════ 对照：几个路径的返回 ════"
+for p in /v1/health /rescue/19700101-000000-demo.txt /rescue/nonexistent.txt /rescue/; do
+    printf '  %-42s -> %s\n' "$p" "$(curl -s -o /dev/null -w '%{http_code}' --max-time 6 "$B$p")"
+done
+
+echo
+echo "════ 详细看 /rescue/ 那次请求 ════"
+curl -sv --max-time 8 "$B/rescue/19700101-000000-demo.txt" 2>&1 | head -25 | sed 's/^/  /'
+
+echo
+echo "════ relay 日志尾部（有没有 Traceback）════"
+journalctl -u lanremote-relay --no-pager -n 30 2>/dev/null | tail -30 | sed 's/^/  /'
+
+echo
+echo "════ 后台密码文件在不在 ════"
+ls -la $RELAY/data/admin_password.txt 2>&1 | sed 's/^/  /'
+echo "  （长度 $(wc -c < $RELAY/data/admin_password.txt 2>/dev/null || echo 0)）"
+
+echo
+echo "════ 清理 ════"
+rm -f $RELAY/rescue_reports/19700101-000000-demo.txt
+'''
+
+
+def main() -> int:
+    out = run(REMOTE, timeout=180)
+    text = out[1] if isinstance(out, tuple) else str(out)
+    print(text)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/deploy_lightsail.py

@@ -0,0 +1,175 @@
+# -*- coding: utf-8 -*-
+r'''把中转服务器部署到 AWS Lightsail 那台新机器上。
+
+== 为什么要搬 ==
+
+原来中转跑在一台"随身 WiFi"小机器上（Debian aarch64、460MB 内存、
+走 4G），一直有一堆搞不定的问题：
+
+    * 线路对 Cloudflare 隧道的 **7844 端口间歇性阻断**
+      —— 443 通、7844 不通，隧道每 3~10 分钟就掉一次，公网跟着 530
+      （这个查了很久，cloudflared 自己的 precheck 才说清楚）
+    * 只有 460MB 内存，跑什么都得省着来
+    * 会掉电/硬挂（实测 18:42 一次非正常关机，19:58 才起来）
+    * 全靠 Cloudflare 隧道兜，隧道一抖网站就抖
+
+新机器（Lightsail）**有公网 IP**，直接监听就行 ——
+不需要隧道、不经过 Cloudflare 的 7844、内存是 4 倍、磁盘 59G。
+上面那些问题**一次性全部消失**。
+
+== 关键配置 ==
+
+    RELAY_PORT=13245        用户指定（防火墙那边他会开）
+    RELAY_BIND=0.0.0.0      有公网 IP，直接对外
+
+    13245 大于 1024，所以**不需要** CAP_NET_BIND_SERVICE，
+    用普通用户跑就行 —— 比听 80 干净。
+
+== 为什么不用 root 跑 ==
+
+relay 是个只读文件的 HTTP 服务，没有任何理由给它 root。
+用 admin 用户跑，万一被打穿，损失也小得多。
+（2026-10-08 之前那个仓库里还硬编码过管理员密码，
+ 这种教训够一次就行了。）
+'''
+from __future__ import annotations
+
+import sys
+import tempfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "_build"))
+from lssh import run, upload, HOST as LS_HOST         # noqa: E402
+
+# 用户指定的端口
+PORT = "13245"
+REMOTE_DIR = "/opt/ykxmz-relay"
+DATA_DIR = REMOTE_DIR + "/data"   # relay.py 现在默认就用 data/ 了
+
+# 服务端要传的文件（.py 是服务本体，.ico 是管理页图标）
+FILES = ["relay.py", "admin.py", "landing.py", "showcase.py", "favicon.ico"]
+
+UNIT = '''[Unit]
+Description=ykxmz 中转服务器
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=admin
+Group=admin
+WorkingDirectory=%(dir)s
+
+# ⚠ 监听地址和端口都从这里来。
+#   13245 是用户指定的（他会在 Lightsail 防火墙那边开）。
+#   BIND 用 0.0.0.0 是因为新机器**有公网 IP**，不再需要
+#   Cloudflare 隧道（原来那个隧道在这条线路上每 3~10 分钟掉一次，
+#   是"网站容易挂"的主因之一）。
+Environment=RELAY_PORT=%(port)s
+Environment=RELAY_BIND=0.0.0.0
+
+ExecStart=/usr/bin/python3 %(dir)s/relay.py
+Restart=always
+RestartSec=3
+
+# 兜底：内存保护（这台有 2G，给 512M 足够且不会拖垮整机）
+MemoryMax=512M
+# 别让它写爆磁盘
+LimitNOFILE=4096
+
+StandardOutput=append:%(dir)s/relay.log
+StandardError=append:%(dir)s/relay.log
+
+[Install]
+WantedBy=multi-user.target
+'''
+
+
+def main() -> int:
+    print("=" * 62)
+    print("  部署到 Lightsail（LS_HOST），端口 %s" % PORT)
+    print("=" * 62)
+
+    print()
+    print("  ── 1. 建目录 ──")
+    out = run("sudo mkdir -p %s %s && sudo chown -R admin:admin %s && "
+              "echo OK" % (REMOTE_DIR, DATA_DIR, REMOTE_DIR),
+              timeout=120)
+    for ln in out[1].strip().splitlines():
+        print("    " + ln)
+
+    print()
+    print("  ── 2. 传服务端文件 ──")
+    for name in FILES:
+        local = ROOT / "relay" / name
+        if not local.is_file():
+            print("    [跳过] %s 不存在" % name)
+            continue
+        upload(str(local), "%s/%s" % (REMOTE_DIR, name))
+    # 产品截图（官网要用）
+    shots = ROOT / "relay" / "site_shots"
+    if shots.is_dir():
+        run("mkdir -p %s/site_shots" % REMOTE_DIR, timeout=60, quiet=True)
+        for f in sorted(shots.iterdir()):
+            if f.is_file():
+                upload(str(f), "%s/site_shots/%s" % (REMOTE_DIR, f.name))
+    else:
+        print("    [警告] 没有 relay/site_shots，官网截图会 404")
+
+    print()
+    print("  ── 3. 写 systemd unit ──")
+    unit = UNIT % {"dir": REMOTE_DIR, "port": PORT}
+    tmp = Path(tempfile.gettempdir()) / "ykxmz-relay.service"
+    tmp.write_text(unit, encoding="utf-8", newline="\n")
+    upload(str(tmp), "/tmp/ykxmz-relay.service")
+    out = run("sudo mv /tmp/ykxmz-relay.service /etc/systemd/system/ && "
+              "sudo systemctl daemon-reload && echo '  unit 已装'",
+              timeout=120)
+    for ln in out[1].strip().splitlines():
+        print("    " + ln)
+
+    print()
+    print("  ── 4. 语法检查 + 启动 ──")
+    out = run(
+        "cd %s && for f in relay.py admin.py landing.py showcase.py; do "
+        "python3 -c \"import ast,sys;ast.parse(open(sys.argv[1],"
+        "encoding='utf-8').read())\" $f || exit 1; done && echo PY_OK"
+        % REMOTE_DIR, timeout=120)
+    for ln in out[1].strip().splitlines():
+        print("    " + ln)
+
+    out = run("sudo systemctl enable ykxmz-relay >/dev/null 2>&1; "
+              "sudo systemctl restart ykxmz-relay; sleep 5; "
+              "systemctl is-active ykxmz-relay", timeout=180)
+    for ln in out[1].strip().splitlines():
+        print("    " + ln)
+
+    print()
+    print("  ── 5. 自测 ──")
+    out = run(
+        "echo \"  本机 health: $(curl -s -o /dev/null -w '%%{http_code}' "
+        "--max-time 8 http://127.0.0.1:%(p)s/v1/health)\"; "
+        "echo \"  监听: $(ss -tlnp 2>/dev/null | grep %(p)s | head -1)\"; "
+        "echo '  --- 启动日志 ---'; "
+        "tail -12 %(d)s/relay.log 2>/dev/null"
+        % {"p": PORT, "d": REMOTE_DIR}, timeout=120)
+    for ln in out[1].strip().splitlines():
+        print("    " + ln)
+
+    print()
+    print("  ── 6. 管理密码（登录后台用）──")
+    out = run("cat %s/data/admin_password.txt 2>/dev/null; echo; "
+              "cat %s/data/admin_key.txt 2>/dev/null" % (DATA_DIR, DATA_DIR),
+              timeout=60)
+    for ln in out[1].strip().splitlines():
+        print("    " + ln)
+
+    print()
+    print("  提示：防火墙要先放行 TCP %s（用户来开）。" % PORT)
+    print("        之后公网地址就是 http://LS_HOST:%s/" % PORT)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/deploy_lightsail_monitor.py

@@ -0,0 +1,285 @@
+# -*- coding: utf-8 -*-
+r'''在 Lightsail 上装好「监测单元 + 紧急预案」。
+
+== 部署什么 ==
+
+    /opt/ykxmz-relay/monitor.sh              每 60 秒查一次公网
+    /opt/ykxmz-relay/rescue-lightsail.sh     四级阶梯抢救
+    /etc/systemd/system/ykxmz-monitor.service
+    /etc/systemd/system/ykxmz-monitor.timer
+
+== 和随身 WiFi 那版的区别 ==
+
+那版围着 Cloudflare 隧道转：查隧道连接数、重启隧道、重施 MSS/MTU。
+新机器**有公网 IP、没有隧道**，所以：
+
+    * 健康检查超时从 12 秒降到 8 秒（直连，不需要等隧道）
+    * 预案第 1 级改成"重启中转服务"（不再有隧道可重启）
+    * 去掉 MTU/MSS 那两级（那是 4G 线路的问题）
+
+== 为什么还是"每 60 秒 + 连续 3 次才动手" ==
+
+直连比隧道稳得多，但**公网抖动**依然存在（上游线路、Lightsail 边缘）。
+一次失败就救会天天瞎折腾，所以保留防抖。
+现在预期是**基本不会触发** —— 触发了就说明真出事了。
+'''
+from __future__ import annotations
+
+import sys
+import tempfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "_build"))
+from lssh import run, upload, HOST as LS_HOST         # noqa: E402
+
+RELAY_DIR = "/opt/ykxmz-relay"
+PORT = "13245"
+PUBLIC_URL = "http://%s:%s" % (LS_HOST, PORT)
+
+MONITOR = r'''#!/bin/bash
+# ============================================================================
+#  网站监测单元（Lightsail 版）
+# ============================================================================
+#
+#  每 60 秒从**公网**查一次，连续 3 次不通就叫紧急预案。
+#
+#  为什么不查 127.0.0.1：
+#      本机 200 只说明进程活着。用户真正关心的是"打开
+#      http://LS_HOST:13245 能不能出页面" —— 那要经过
+#      Lightsail 的防火墙 / 安全组 / 上游线路。实测踩过：
+#      隧道两条实例都掉了，本机 curl 照样 200，但公网 502。
+#
+#  为什么用 timer 不用常驻进程：
+#      崩了下一分钟自己就回来，不会有"跑久了状态变脏"的问题。
+# ============================================================================
+
+set -u
+
+RELAY_DIR="${RELAY_DIR:-/opt/ykxmz-relay}"
+PUBLIC_URL="${PUBLIC_URL:-__PUBLIC_URL__}"
+
+FAIL_THRESHOLD="${FAIL_THRESHOLD:-3}"
+COOLDOWN="${COOLDOWN:-600}"
+CHECK_TIMEOUT="${CHECK_TIMEOUT:-8}"
+
+STATE="$RELAY_DIR/monitor_state.txt"
+LOG="$RELAY_DIR/monitor.log"
+LOCKFILE="/tmp/ykxmz-monitor.lock"
+
+if ! mkdir "$LOCKFILE" 2>/dev/null; then
+    exit 0
+fi
+trap 'rmdir "$LOCKFILE" 2>/dev/null' EXIT
+
+log() { echo "$(date '+%F %T')  $*" >> "$LOG"; }
+
+FAILS=0
+LAST_RESCUE=0
+if [ -f "$STATE" ]; then
+    FAILS=$(grep -m1 '^fails=' "$STATE" 2>/dev/null | cut -d= -f2)
+    LAST_RESCUE=$(grep -m1 '^last_rescue=' "$STATE" 2>/dev/null | cut -d= -f2)
+    FAILS=${FAILS:-0}
+    LAST_RESCUE=${LAST_RESCUE:-0}
+fi
+NOW=$(date +%s)
+
+CODE=$(curl -s -o /dev/null -w '%{http_code}' --max-time "$CHECK_TIMEOUT" \
+       "$PUBLIC_URL/v1/health" 2>/dev/null)
+DUR=$(curl -s -o /dev/null -w '%{time_total}' --max-time "$CHECK_TIMEOUT" \
+      "$PUBLIC_URL/v1/health" 2>/dev/null)
+DUR=${DUR:-0}
+
+write_state() {
+    {
+        echo "fails=$1"
+        echo "last_rescue=$2"
+        echo "last_code=$CODE"
+        echo "last_check=$NOW"
+        echo "last_dur=$DUR"
+    } > "$STATE"
+}
+
+if [ "$CODE" = "200" ]; then
+    if [ "$FAILS" != "0" ]; then
+        log "公网恢复（HTTP 200，${DUR}s）—— 之前连续失败 $FAILS 次"
+    fi
+    PREV=$(grep -m1 '^last_code=' "$STATE" 2>/dev/null | cut -d= -f2)
+    [ "$PREV" != "200" ] && log "公网正常（HTTP 200，${DUR}s）"
+    write_state 0 "$LAST_RESCUE"
+    exit 0
+fi
+
+FAILS=$((FAILS + 1))
+log "公网异常 第 $FAILS 次（HTTP ${CODE:-无响应}，${DUR}s）"
+write_state "$FAILS" "$LAST_RESCUE"
+
+if [ "$FAILS" -lt "$FAIL_THRESHOLD" ]; then
+    exit 0
+fi
+
+SINCE=$((NOW - LAST_RESCUE))
+if [ "$LAST_RESCUE" != "0" ] && [ "$SINCE" -lt "$COOLDOWN" ]; then
+    log "  已连续失败 $FAILS 次，但距上次抢救只过了 ${SINCE}s（冷却 ${COOLDOWN}s）"
+    exit 0
+fi
+
+HINT=""
+if [ -f "$RELAY_DIR/rescue_knowledge.md" ]; then
+    HINT=$(grep -oE '第 [0-9] 级奏效' "$RELAY_DIR/rescue_knowledge.md" 2>/dev/null \
+           | sort | uniq -c | sort -rn | head -1 | grep -oE '[0-9]')
+fi
+
+log "连续失败 $FAILS 次，启动紧急预案${HINT:+（知识库提示：第 $HINT 级常奏效）}"
+write_state "$FAILS" "$NOW"
+
+timeout 300 bash "$RELAY_DIR/rescue-lightsail.sh" \
+    "监测单元：公网连续 $FAILS 次不通" >> "$LOG" 2>&1
+RC=$?
+
+if [ "$RC" = "0" ]; then
+    log "  预案完成：已恢复"
+else
+    log "  预案完成：仍未恢复（退出码 $RC），报告在 rescue_reports/"
+fi
+exit 0
+'''
+
+SERVICE = '''[Unit]
+# ykxmz 网站监测单元（Lightsail 版）
+Description=ykxmz 网站监测单元（每 60 秒检查公网，异常时启动紧急预案）
+After=network-online.target ykxmz-relay.service
+Wants=network-online.target
+
+[Service]
+Type=oneshot
+TimeoutStartSec=360
+
+# 用普通用户跑 —— 它只读状态、调 systemctl restart，不需要 root。
+# （systemctl restart 那条走的是 polkit；admin 在 Lightsail 上有 sudo，
+#   所以脚本里用的是不带 sudo 的 systemctl —— 见下面的说明。）
+User=admin
+Group=admin
+
+Environment=RELAY_PORT=__PORT__
+Environment=PUBLIC_URL=__PUBLIC_URL__
+Environment=RESCUE_REBOOT=0
+Environment=FAIL_THRESHOLD=3
+Environment=COOLDOWN=600
+
+ExecStart=/bin/bash __DIR__/monitor.sh
+
+StandardOutput=append:__DIR__/monitor.log
+StandardError=append:__DIR__/monitor.log
+
+[Install]
+WantedBy=multi-user.target
+'''
+
+TIMER = '''[Unit]
+Description=每 60 秒检查一次网站是否可用
+
+[Timer]
+OnBootSec=45s
+OnUnitActiveSec=60s
+AccuracySec=5s
+Unit=ykxmz-monitor.service
+
+[Install]
+WantedBy=timers.target
+'''
+
+
+def main() -> int:
+    print("=" * 62)
+    print("  在 Lightsail 上装监测单元 + 紧急预案")
+    print("=" * 62)
+
+    monitor = (MONITOR.replace("__PUBLIC_URL__", PUBLIC_URL))
+    tmp = Path(tempfile.gettempdir())
+
+    print()
+    print("  ── 1. 传脚本 ──")
+    mp = tmp / "monitor.sh"
+    mp.write_text(monitor, encoding="utf-8", newline="\n")
+    upload(str(mp), "%s/monitor.sh" % RELAY_DIR, mode=0o755)
+
+    rp = ROOT / "relay" / "rescue-lightsail.sh"
+    if rp.is_file():
+        upload(str(rp), "%s/rescue-lightsail.sh" % RELAY_DIR, mode=0o755)
+    else:
+        print("    ✗ 找不到 relay/rescue-lightsail.sh")
+        return 1
+
+    print()
+    print("  ── 2. 传 systemd 单元 ──")
+    sp = tmp / "ykxmz-monitor.service"
+    sp.write_text(SERVICE.replace("__PORT__", PORT)
+                  .replace("__PUBLIC_URL__", PUBLIC_URL)
+                  .replace("__DIR__", RELAY_DIR),
+                  encoding="utf-8", newline="\n")
+    upload(str(sp), "/tmp/ykxmz-monitor.service")
+    tp = tmp / "ykxmz-monitor.timer"
+    tp.write_text(TIMER, encoding="utf-8", newline="\n")
+    upload(str(tp), "/tmp/ykxmz-monitor.timer")
+
+    print()
+    print("  ── 3. 装单元 + 建目录 ──")
+    out = run(
+        "sudo mv /tmp/ykxmz-monitor.service /tmp/ykxmz-monitor.timer "
+        "/etc/systemd/system/ && "
+        "mkdir -p %s/rescue_reports && chmod +x %s/*.sh && "
+        "if [ ! -f %s/rescue_knowledge.md ]; then "
+        "printf '# 紧急预案知识库\\n\\n每次自动抢救成功会记一条「第几级奏效」。"
+        "\\n下次同类症状优先试历史上奏效的那一级。\\n' > %s/rescue_knowledge.md; "
+        "fi && sudo systemctl daemon-reload && echo OK"
+        % (RELAY_DIR, RELAY_DIR, RELAY_DIR, RELAY_DIR), timeout=180)
+    for ln in out[1].strip().splitlines():
+        print("    " + ln)
+
+    print()
+    print("  ── 4. 启用定时器 ──")
+    out = run("sudo systemctl enable --now ykxmz-monitor.timer 2>&1 | tail -2; "
+              "sleep 2; systemctl is-active ykxmz-monitor.timer",
+              timeout=180)
+    for ln in out[1].strip().splitlines():
+        print("    " + ln)
+
+    print()
+    print("  ── 5. 手动跑一次监测（验证它能工作）──")
+    out = run("bash %s/monitor.sh; echo '--- 状态 ---'; "
+              "cat %s/monitor_state.txt 2>/dev/null; "
+              "echo '--- 日志 ---'; tail -3 %s/monitor.log 2>/dev/null"
+              % (RELAY_DIR, RELAY_DIR, RELAY_DIR), timeout=180)
+    for ln in out[1].strip().splitlines():
+        print("    " + ln)
+
+    print()
+    print("  ── 6. 演练预案（网站正常时应该什么都不做）──")
+    out = run("bash %s/rescue-lightsail.sh '安装验证（网站正常）' 2>&1 | tail -6; "
+              "echo '--- 报告数（应该是 0）---'; "
+              "ls %s/rescue_reports 2>/dev/null | wc -l"
+              % (RELAY_DIR, RELAY_DIR), timeout=180)
+    for ln in out[1].strip().splitlines():
+        print("    " + ln)
+
+    print()
+    print("  ── 7. 总览 ──")
+    out = run(
+        "printf '  %-26s %s\\n' 'ykxmz-relay' \"$(systemctl is-active ykxmz-relay)\"; "
+        "printf '  %-26s %s\\n' 'ykxmz-monitor.timer' \"$(systemctl is-active ykxmz-monitor.timer)\"; "
+        "printf '  %-26s %s\\n' '本机 health' \"$(curl -s -o /dev/null -w '%%{http_code}' http://127.0.0.1:%s/v1/health)\"; "
+        "printf '  %-26s %s\\n' '公网 health' \"$(curl -s -o /dev/null -w '%%{http_code}' %s/v1/health)\""
+        % (PORT, PUBLIC_URL), timeout=180)
+    for ln in out[1].strip().splitlines():
+        print("    " + ln)
+
+    print()
+    print("  说明：预案里用 systemctl 重启服务，而 monitor.service 以 admin")
+    print("        身份跑 —— admin 在 Lightsail 上有免密 sudo，但脚本里没加")
+    print("        sudo。如果实测发现重启失败，把它改成 sudo systemctl 即可。")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/deploy_lightsail_release.py

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+r'''把一个版本的代码和成品部署到 Lightsail。
+
+用法：
+    python _build/deploy_lightsail_release.py 2.1.3
+    python _build/deploy_lightsail_release.py 2.1.3 --code-only
+    python _build/deploy_lightsail_release.py 2.1.3 --files-only
+
+== 为什么写成文件 ==
+
+这一轮我用 `python -c @"..."@` 传带 `$(...)` 的远端命令，
+PowerShell 把 `$(systemctl ...)` 当成本机的子表达式执行了
+（报 "无法将 systemctl 项识别为 cmdlet"），还吃掉引号导致
+Python 语法错。凡是超过两行的远端命令，一律写成文件跑。
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "_build"))
+from lssh import run, upload, HOST as LS_HOST         # noqa: E402
+
+RELAY_DIR = "/opt/ykxmz-relay"
+PORT = "13245"
+PUBLIC = "http://%s:%s" % (LS_HOST, PORT)
+
+CODE = ["relay.py", "admin.py", "landing.py", "showcase.py"]
+ARTIFACTS = ["ykxmz-setup-{v}.exe", "ykxmz-watch-{v}.apk",
+             "ykxmz-watch-{v}-说明.txt", "ykxmz-server-{v}.zip"]
+
+
+def main() -> int:
+    args = [a for a in sys.argv[1:] if a]
+    if not args:
+        print(__doc__)
+        return 1
+    version = args[0]
+    code_only = "--code-only" in args
+    files_only = "--files-only" in args
+
+    print("=" * 62)
+    print("  部署 %s 到 Lightsail" % version)
+    print("=" * 62)
+
+    if not code_only:
+        print()
+        print("  ── 1. 传成品到 downloads/ ──")
+        run("mkdir -p %s/downloads" % RELAY_DIR, timeout=60, quiet=True)
+        for tpl in ARTIFACTS:
+            name = tpl.format(v=version)
+            local = ROOT / "dist" / name
+            if not local.is_file():
+                print("    [跳过] %s 不存在" % name)
+                continue
+            upload(str(local), "%s/downloads/%s" % (RELAY_DIR, name))
+
+    if not files_only:
+        print()
+        print("  ── 2. 传服务端代码 ──")
+        for name in CODE:
+            local = ROOT / "relay" / name
+            if not local.is_file():
+                print("    [跳过] %s 不存在" % name)
+                continue
+            upload(str(local), "%s/%s" % (RELAY_DIR, name))
+
+        print()
+        print("  ── 3. 语法检查 + 重启 ──")
+        out = run(
+            "cd %s && for f in relay.py admin.py landing.py showcase.py; do "
+            "python3 -c \"import ast,sys;ast.parse(open(sys.argv[1],"
+            "encoding='utf-8').read())\" $f || exit 1; done && echo PY_OK"
+            % RELAY_DIR, timeout=120, quiet=True)
+        print("    " + out[1].strip().splitlines()[-1])
+
+        out = run("sudo systemctl restart ykxmz-relay; sleep 4; "
+                  "systemctl is-active ykxmz-relay", timeout=180, quiet=True)
+        print("    relay 状态: " + out[1].strip())
+
+    print()
+    print("  ── 4. 复核 ──")
+    script = (
+        'printf "  %-18s %s\\n" 本机 "'
+        '$(curl -s -o /dev/null -w \'%{http_code}\' --max-time 8 '
+        'http://127.0.0.1:' + PORT + '/v1/health)"\n'
+        'printf "  %-18s %s\\n" 公网 "'
+        '$(curl -s -o /dev/null -w \'%{http_code}\' --max-time 15 '
+        + PUBLIC + '/v1/health)"\n'
+        'printf "  %-18s %s\\n" 公网首页 "'
+        '$(curl -s -o /dev/null -w \'%{http_code}\' --max-time 15 '
+        + PUBLIC + '/)"\n'
+        'printf "  %-18s %s\\n" 公网延迟 "'
+        '$(curl -s -o /dev/null -w \'%{time_total}s\' --max-time 15 '
+        + PUBLIC + '/v1/health)"\n'
+        'printf "  %-18s %s\\n" 角标 "'
+        '$(curl -s --max-time 10 http://127.0.0.1:' + PORT
+        + '/ | grep -o "最新版 [0-9.]*" | head -1)"\n'
+        'printf "  %-18s %s\\n" 监听 "'
+        '$(ss -tln 2>/dev/null | grep ":' + PORT + ' " | wc -l) 个"\n'
+        'printf "  %-18s %s\\n" 监测 "'
+        'fails=$(grep -m1 ^fails= ' + RELAY_DIR
+        + '/monitor_state.txt 2>/dev/null | cut -d= -f2); '
+        'echo ${fails:-?} 次连续失败"\n'
+        'printf "  %-18s %s\\n" 抢救报告 "'
+        '$(ls ' + RELAY_DIR + '/rescue_reports 2>/dev/null | wc -l) 份"\n'
+    )
+    out = run(script, timeout=180, quiet=True)
+    for ln in out[1].strip().splitlines():
+        print(ln)
+
+    print()
+    print("  公网地址：%s" % PUBLIC)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/deploy_monitor.py

@@ -0,0 +1,151 @@
+# -*- coding: utf-8 -*-
+r'''把「网站监测 + 紧急预案 + 抢救报告分区」部署到中转服务器。
+
+部署的东西：
+    relay.py / admin.py            后台多一个「抢救报告」分区 + /rescue/ 下载
+    monitor.sh / rescue.sh         监测单元 + 紧急预案
+    lanremote-monitor.service/.timer  每 60 秒拉一次 monitor.sh
+    lanremote-nettune.service      顺手修掉设备上那份过期的（见下）
+
+== 顺手修的设备问题 ==
+
+设备上那份 lanremote-nettune.service 是**很早以前的版本**，有两个毛病：
+
+  1. ExecStart 里写了 `iptables ... || iptables ...`
+     systemd 的 ExecStart **不支持 `||`** —— 它把 `||` 当成一个参数，
+     iptables 报 `Bad argument '||'`，服务直接 exit 2 失败。
+
+  2. 里面有一句 `ip link set wlan0 mtu 1400`，而 net-tune.sh 自己
+     实测过"降到 1400 反而掉到 50%"并把网卡设回 1500。
+     **两条 ExecStart 顺序是 net-tune.sh 先、1400 后**，所以最终是 1400 ——
+     也就是说这份过期配置一直在主动损害稳定性。
+
+本地 relay/deploy.sh 生成的是对的（单入口 -> deploy-tune.sh）。
+这里直接按那个正确形状重写设备上的 unit。
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "_build"))
+from devssh import upload, run      # noqa: E402
+
+RELAY_DIR = "/root/lanremote-relay"
+UNIT_DIR = "/etc/systemd/system"
+
+FILES = [
+    "relay.py", "admin.py", "landing.py", "showcase.py",
+    "monitor.sh", "rescue.sh", "net-tune.sh", "watchdog.sh",
+    "deploy-tune.sh",
+]
+
+NETTUNE_UNIT = '''[Unit]
+Description=ykxmz 网络调优（MSS 钳制 + 路径 MTU 探测）
+After=network-online.target
+Wants=network-online.target
+Before=lanremote-relay.service lanremote-tunnel.service lanremote-tunnel-h2.service
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+# ⚠ 只跑 net-tune.sh 这一个入口 —— MSS / 接口 MTU / 路径探测的唯一出处。
+#
+#   设备上原来那份 unit 有两条毛病：
+#     * ExecStart 里写了 `iptables ... || iptables ...`
+#       systemd 的 ExecStart **不支持 `||`**，它把 `||` 当参数传给
+#       iptables，报 `Bad argument '||'`，服务直接 exit 2 失败。
+#     * 还有一句 `ip link set wlan0 mtu 1400`，而 net-tune.sh 自己
+#       实测过"降到 1400 反而掉到 50%"并把网卡设回 1500。
+#       两条 ExecStart 是 net-tune.sh 先、1400 后，所以最终停在 1400 ——
+#       这份过期配置一直在主动损害稳定性。
+#
+#   （仓库里的 deploy.sh 生成的是 `ExecStart=/bin/bash deploy-tune.sh`
+#     那种形状，但设备上并没有 deploy-tune.sh，所以这里直接用
+#     net-tune.sh，和设备的实际情况对齐。
+#     deploy-tune.sh 也一并传上去了，以后想切回单入口随时可以。）
+ExecStart=/bin/bash /root/lanremote-relay/net-tune.sh
+
+[Install]
+WantedBy=multi-user.target
+'''
+
+
+def main() -> int:
+    print("=" * 62)
+    print("  部署 监测单元 + 紧急预案 + 抢救报告分区")
+    print("=" * 62)
+
+    print()
+    print("  ── 1. 上传文件 ──")
+    for name in FILES:
+        local = ROOT / "relay" / name
+        if not local.is_file():
+            print("    [跳过] %s 不存在" % name)
+            continue
+        upload(str(local), "%s/%s" % (RELAY_DIR, name))
+        print("    ✓ %s" % name)
+
+    for unit in ("lanremote-monitor.service", "lanremote-monitor.timer"):
+        local = ROOT / "relay" / unit
+        upload(str(local), "%s/%s" % (UNIT_DIR, unit))
+        print("    ✓ %s -> %s" % (unit, UNIT_DIR))
+
+    print()
+    print("  ── 2. 修掉过期的 nettune 服务（MTU 打架 + ExecStart 里的 ||）──")
+    import tempfile
+    tmp = Path(tempfile.gettempdir()) / "lanremote-nettune.service"
+    tmp.write_text(NETTUNE_UNIT, encoding="utf-8", newline="\n")
+    upload(str(tmp), "%s/lanremote-nettune.service" % UNIT_DIR)
+    print("    ✓ 已替换")
+
+    print()
+    print("  ── 3. 语法检查 ──")
+    out = run(
+        "cd %s && for f in relay.py admin.py landing.py showcase.py; do "
+        "python3 -c \"import ast,sys; ast.parse(open(sys.argv[1],encoding='utf-8').read())\" $f "
+        "|| exit 1; done && echo PY_OK; "
+        "bash -n monitor.sh && bash -n rescue.sh && echo SH_OK; "
+        "systemd-analyze verify %s/lanremote-monitor.service 2>&1 | head -3 || true"
+        % (RELAY_DIR, UNIT_DIR), timeout=120)
+    for ln in out[1].strip().splitlines():
+        print("    " + ln)
+
+    print()
+    print("  ── 4. 建目录 + 知识库 + 重载并启用 ──")
+    out = run(
+        "mkdir -p %s/rescue_reports && chmod +x %s/monitor.sh %s/rescue.sh && "
+        "[ -f %s/rescue_knowledge.md ] || printf '# 紧急预案知识库\\n\\n"
+        '每次自动抢救成功，这里会记一条"第几级奏效"。\\n'
+        '以后遇到同类症状，监测单元会优先试历史上奏效的那一级。\\n" > %s/rescue_knowledge.md; '
+        "systemctl daemon-reload && "
+        "systemctl restart lanremote-nettune.service; sleep 3; "
+        "systemctl enable --now lanremote-monitor.timer 2>&1 | tail -1; "
+        "sleep 2; systemctl is-active lanremote-monitor.timer"
+        % (RELAY_DIR, RELAY_DIR, RELAY_DIR, RELAY_DIR, RELAY_DIR), timeout=180)
+    for ln in out[1].strip().splitlines():
+        print("    " + ln)
+
+    print()
+    print("  ── 5. 复核 ──")
+    out = run(
+        "echo 'nettune: '$(systemctl is-active lanremote-nettune.service); "
+        "echo 'monitor.timer: '$(systemctl is-active lanremote-monitor.timer); "
+        "echo 'MTU: '$(cat /sys/class/net/wlan0/mtu); "
+        "echo 'MSS 规则: '$(iptables -t mangle -L -n 2>/dev/null | grep -ci mss)' 条'; "
+        "echo '报告目录: '$(ls %s/rescue_reports 2>/dev/null | wc -l)' 份'; "
+        "echo '后台分区: '$(curl -s -o /dev/null -w '%%{http_code}' http://127.0.0.1:8080/rescue/nonexistent.txt)"
+        % RELAY_DIR, timeout=120)
+    for ln in out[1].strip().splitlines():
+        print("    " + ln)
+
+    print()
+    print("  提示：监测单元默认每 60 秒查一次公网，连续 3 次不通才动手；")
+    print("        抢救完 10 分钟内不再动手（防抖，避免来回重启）。")
+    print("        日志在 %s/monitor.log 和 %s/rescue.log。" % (RELAY_DIR, RELAY_DIR))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/deploy_release.py

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+r'''把某个版本的成品和官网代码传到中转服务器。
+
+用法：
+    python _build/deploy_release.py 1.9.0
+    python _build/deploy_release.py 1.9.0 --code-only     # 只更新官网代码
+    python _build/deploy_release.py 1.9.0 --files-only    # 只传成品文件
+
+== 为什么写成脚本文件而不是 python -c ==
+
+这一轮我在 PowerShell 里用 `python -c @"..."@` 写带引号和 $ 的
+Python 代码，失败了四五次（PowerShell 会插值、会吃掉 $、嵌套引号
+转义一层套一层）。凡是超过两行的 Python，一律写成 .py 文件再跑。
+
+== 官网上"最新版"是怎么来的 ==
+
+relay.py 的 _list_downloads() 按 **mtime 倒序** 返回文件，
+landing.py 的 _version() 取**第一个**能匹配到 x.y.z 的文件名。
+
+所以"上传哪个版本，官网就显示哪个版本" —— 不用改任何代码。
+按顺序传 1.9.0、再传 2.0.0，官网就会先显示 1.9.0、再显示 2.0.0。
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "_build"))
+
+from devssh import upload, run  # noqa: E402
+
+REMOTE_DIR = "/root/lanremote-relay"
+DL_DIR = REMOTE_DIR + "/downloads"
+
+# 要传的成品（和 dist/ 里的文件名一致）
+ARTIFACTS = [
+    "ykxmz-setup-{v}.exe",
+    "ykxmz-watch-{v}.apk",
+    "ykxmz-watch-{v}-说明.txt",
+    "ykxmz-server-{v}.zip",
+]
+
+# 官网/服务端代码
+CODE = ["relay.py", "admin.py", "landing.py", "showcase.py"]
+
+
+def main() -> int:
+    args = [a for a in sys.argv[1:] if a]
+    if not args:
+        print(__doc__)
+        return 1
+    version = args[0]
+    code_only = "--code-only" in args
+    files_only = "--files-only" in args
+
+    print("=" * 62)
+    print("  部署 %s 到中转服务器" % version)
+    print("=" * 62)
+
+    # ---------------- 成品 ----------------
+    if not code_only:
+        print()
+        print("  ── 1. 上传成品到 downloads/ ──")
+        for tpl in ARTIFACTS:
+            name = tpl.format(v=version)
+            local = ROOT / "dist" / name
+            if not local.is_file():
+                print("    [跳过] %s 不存在" % name)
+                continue
+            upload(str(local), "%s/%s" % (DL_DIR, name))
+            print("    ✓ %-34s %10d 字节" % (name, local.stat().st_size))
+
+    # ---------------- 代码 ----------------
+    if not files_only:
+        print()
+        print("  ── 2. 更新官网/服务端代码 ──")
+        for name in CODE:
+            local = ROOT / "relay" / name
+            if not local.is_file():
+                print("    [跳过] %s 不存在" % name)
+                continue
+            upload(str(local), "%s/%s" % (REMOTE_DIR, name))
+            print("    ✓ %s" % name)
+
+        print()
+        print("  ── 3. 语法检查 + 重启 ──")
+        out = run(
+            "cd %s && python3 - <<'PY'\n"
+            "import ast\n"
+            "for f in %r:\n"
+            "    ast.parse(open(f, encoding='utf-8').read())\n"
+            "print('语法 OK')\n"
+            "PY" % (REMOTE_DIR, tuple(CODE)),
+            timeout=90)
+        print("    " + out[1].strip().splitlines()[-1])
+
+        out = run("systemctl restart lanremote-relay && sleep 4 && "
+                  "systemctl is-active lanremote-relay && "
+                  "grep -m1 '^VERSION' %s/relay.py" % REMOTE_DIR, timeout=120)
+        for ln in out[1].strip().splitlines():
+            print("    " + ln)
+
+    # ---------------- 复核 ----------------
+    print()
+    print("  ── 4. 复核：官网现在显示哪个版本 ──")
+    out = run(
+        "curl -s -H 'Cache-Control: no-cache' http://127.0.0.1:8080/v1/downloads",
+        timeout=60)
+    print("    " + out[1].strip()[:400])
+
+    out = run("curl -s -H 'Cache-Control: no-cache' http://127.0.0.1:8080/ "
+              "| grep -o '最新版 [0-9.]*' | head -1", timeout=60)
+    print("    官网首页角标: " + out[1].strip())
+
+    print()
+    print("  提示：官网 / 走 max-age=60，公网可能需要等一分钟才刷新；")
+    print("        下载链接带 604800 缓存，换版本号正好会换 URL。")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/desktop_state.py

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+r'''看当前桌面/窗口的真实状态 —— 诊断"桌面消失、一片蓝"。
+
+用户报："我现在桌面消失了，电脑一片蓝，然后还有个蓝色的窗口"。
+
+已知：
+    18:42:41 机器异常关机（Kernel-Power 41 / EventLog 6008，无蓝屏记录）
+    19:58:23 重新启动
+    20:01:37 explorer 起来
+    自启项里没有 ykxmz，当前也没有 ykxmz 在跑
+
+要查的是：现在屏幕上到底有什么、是不是有全屏窗口盖住了桌面。
+'''
+from __future__ import annotations
+
+import ctypes
+import ctypes.wintypes as wt
+import subprocess
+
+user32 = ctypes.WinDLL("user32", use_last_error=True)
+
+EnumWindows = user32.EnumWindows
+EnumWindows.argtypes = [ctypes.WINFUNCTYPE(wt.BOOL, wt.HWND, wt.LPARAM),
+                        wt.LPARAM]
+
+
+class RECT(ctypes.Structure):
+    _fields_ = [("left", wt.LONG), ("top", wt.LONG),
+                ("right", wt.LONG), ("bottom", wt.LONG)]
+
+
+def windows() -> list:
+    out = []
+
+    def cb(hwnd, _lp):
+        if not user32.IsWindowVisible(hwnd):
+            return True
+        title = ctypes.create_unicode_buffer(512)
+        user32.GetWindowTextW(hwnd, title, 512)
+        cls = ctypes.create_unicode_buffer(256)
+        user32.GetClassNameW(hwnd, cls, 256)
+        r = RECT()
+        user32.GetWindowRect(hwnd, ctypes.byref(r))
+        pid = wt.DWORD()
+        user32.GetWindowThreadProcessId(hwnd, ctypes.byref(pid))
+        w, h = r.right - r.left, r.bottom - r.top
+        if w > 80 and h > 80:
+            out.append({"hwnd": hwnd, "title": title.value, "cls": cls.value,
+                        "pid": pid.value, "w": w, "h": h,
+                        "x": r.left, "y": r.top})
+        return True
+
+    EnumWindows(ctypes.WINFUNCTYPE(wt.BOOL, wt.HWND, wt.LPARAM)(cb), 0)
+    return out
+
+
+def proc_name(pid: int) -> str:
+    try:
+        r = subprocess.run(
+            ["powershell", "-NoProfile", "-Command",
+             "(Get-Process -Id %d -EA SilentlyContinue).ProcessName" % pid],
+            capture_output=True, text=True, timeout=8)
+        return (r.stdout or "").strip() or "?"
+    except Exception:                                     # noqa: BLE001
+        return "?"
+
+
+def main() -> int:
+    sw = user32.GetSystemMetrics(0)
+    sh = user32.GetSystemMetrics(1)
+    print("  屏幕: %d x %d" % (sw, sh))
+    print("  当前输入桌面: %s" % _desktop_name())
+    print()
+
+    ws = windows()
+    ws.sort(key=lambda w: w["w"] * w["h"], reverse=True)
+    print("  可见窗口 %d 个（按面积排序，前 20）:" % len(ws))
+    for w in ws[:20]:
+        full = w["w"] >= sw - 4 and w["h"] >= sh - 4
+        pn = proc_name(w["pid"])
+        print("    %s %-14s pid=%-6d %dx%d @(%d,%d)"
+              % ("★全屏" if full else "     ", pn, w["pid"],
+                 w["w"], w["h"], w["x"], w["y"]))
+        print("          类=%-22s 标题=%r" % (w["cls"][:22], w["title"][:60]))
+    print()
+    fulls = [w for w in ws if w["w"] >= sw - 4 and w["h"] >= sh - 4]
+    if fulls:
+        print("  ⚠ 有 %d 个全屏窗口 —— 下面这些就是盖住桌面的嫌疑：" % len(fulls))
+        for w in fulls:
+            print("      pid=%d (%s) 类=%s 标题=%r"
+                  % (w["pid"], proc_name(w["pid"]), w["cls"], w["title"][:50]))
+    else:
+        print("  ✓ 没有全屏窗口盖着")
+    print()
+    ex = subprocess.run(["powershell", "-NoProfile", "-Command",
+                         "Get-Process explorer -EA SilentlyContinue | "
+                         "Select-Object -First 1 -ExpandProperty Id"],
+                        capture_output=True, text=True, timeout=10)
+    print("  explorer PID: %s" % ((ex.stdout or "").strip() or "**没在跑**"))
+    return 0
+
+
+def _desktop_name() -> str:
+    """当前输入桌面的名字。Default = 正常，Winlogon = 锁屏。"""
+    h = user32.OpenInputDesktop(0, False, 0x0001)
+    if not h:
+        return "(拿不到 —— 可能锁屏或没有交互桌面)"
+    try:
+        sb = ctypes.create_unicode_buffer(256)
+        need = wt.DWORD()
+        ok = user32.GetUserObjectInformationW(h, 2, sb, 512,
+                                              ctypes.byref(need))
+        return sb.value if ok else "(拿不到名字)"
+    finally:
+        user32.CloseDesktop(h)
+
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main())

_build/device_loadtest.sh

@@ -96,7 +96,7 @@ PY
     echo
     echo "  收尾：清掉负载测试造的设备和会话"
     curl -s -o /dev/null --max-time 8 -X POST "$BASE/v1/admin/forget" \
-        -H 'X-Admin: 120830' -H 'Content-Type: application/json' \
+        -H 'X-Admin: <改从环境变量读>' -H 'Content-Type: application/json' \
         -d '{"code":"112233"}'
 fi
 

_build/devssh.py

@@ -4,38 +4,100 @@
 用法：
     python _build/devssh.py "命令"            # 跑一条命令
     python _build/devssh.py --script 文件     # 跑一段脚本
+
+== 地址会自动试 ==
+
+这台设备跟着教室网络走，地址会变：
+    192.168.2.156  <->  192.168.10.105
+所以这里**按顺序试多个地址**，谁先连通就用谁，不用改代码。
+
+想强制指定就用环境变量：
+    $env:YKXMZ_DEV_HOST = "192.168.10.105"
+
+⚠ 以前的坑：定义了 HOST_FALLBACKS 但**三个函数都直接用 HOST**，
+  那个常量根本没被用过。于是设备一换网段就全部连不上，
+  而且报的是「Connection refused / timed out」，看起来像设备挂了。
 """
 from __future__ import annotations
 
+import os
 import sys
 import time
 from pathlib import Path
 
 import paramiko
 
-# 随身 WiFi（Debian）的地址。
-#
-# 这台设备跟着教室网络走，地址会变：
-#   192.168.2.156  ->  192.168.10.105（换网络了）
-# 所以优先读环境变量 YKXMZ_DEV_HOST，没有才用下面的默认值。
-# 换网络时不用改代码：
-#     $env:YKXMZ_DEV_HOST = "192.168.10.105"
-import os
-
-HOST = os.environ.get("YKXMZ_DEV_HOST", "192.168.10.105")
 USER = "root"
 PASSWORD = os.environ.get("YKXMZ_DEV_PASS", "1313144")
 
-# 旧地址留一份，方便回退或同时探测
-HOST_FALLBACKS = ("192.168.10.105", "192.168.2.156")
+# 候选地址，按顺序试。
+#   环境变量优先（想锁定时用），然后是最近见过的两个地址。
+_CANDIDATES: list[str] = []
+
+
+def _build_candidates() -> list[str]:
+    out = []
+    env_host = (os.environ.get("YKXMZ_DEV_HOST") or "").strip()
+    if env_host:
+        out.append(env_host)
+    for host in ("192.168.2.156",      # 当前地址
+                 "192.168.10.105"):    # 换网络前用过
+        if host not in out:
+            out.append(host)
+    return out
+
+
+CANDIDATES = _build_candidates()
+HOST = CANDIDATES[0]          # 兼容老代码：默认取第一个
+HOST_FALLBACKS = tuple(CANDIDATES[1:])
+
+# 记住这次连通的是哪个，后续调用不用每次从头试
+_CONNECTED: str | None = None
+
+
+def _connect(timeout: int = 15):
+    """按候选顺序连，返回 (client, host)。全都不通才抛异常。"""
+    global _CONNECTED
+    order = list(CANDIDATES)
+    if _CONNECTED and _CONNECTED in order:
+        # 上次通的那个排最前，省一次失败尝试
+        order.remove(_CONNECTED)
+        order.insert(0, _CONNECTED)
+
+    errors = []
+    for host in order:
+        client = paramiko.SSHClient()
+        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+        try:
+            client.connect(host, username=USER, password=PASSWORD,
+                           timeout=timeout, banner_timeout=20,
+                           auth_timeout=20, look_for_keys=False,
+                           allow_agent=False)
+            if _CONNECTED != host:
+                print(f"  [devssh] 连上 {host}")
+            _CONNECTED = host
+            return client, host
+        except Exception as exc:                          # noqa: BLE001
+            errors.append(f"{host}: {type(exc).__name__} {exc}")
+            try:
+                client.close()
+            except Exception:                             # noqa: BLE001
+                pass
+    raise RuntimeError("所有候选地址都连不上：\n  " + "\n  ".join(errors))
+
+
+def probe() -> str | None:
+    """探一下现在哪个地址能用（不抛异常）。"""
+    try:
+        client, host = _connect(timeout=8)
+        client.close()
+        return host
+    except Exception:                                     # noqa: BLE001
+        return None
 
 
 def run(command: str, timeout: int = 600, quiet: bool = False) -> tuple:
-    client = paramiko.SSHClient()
-    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-    client.connect(HOST, username=USER, password=PASSWORD, timeout=15,
-                   banner_timeout=20, auth_timeout=20,
-                   look_for_keys=False, allow_agent=False)
+    client, _host = _connect()
     try:
         _stdin, stdout, stderr = client.exec_command(command, timeout=timeout)
         out = stdout.read().decode("utf-8", "replace")
@@ -52,10 +114,7 @@ def run(command: str, timeout: int = 600, quiet: bool = False) -> tuple:
 
 
 def upload(local: str, remote: str, mode: int = 0o644) -> None:
-    client = paramiko.SSHClient()
-    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-    client.connect(HOST, username=USER, password=PASSWORD, timeout=15,
-                   look_for_keys=False, allow_agent=False)
+    client, _host = _connect()
     try:
         sftp = client.open_sftp()
         sftp.put(local, remote)
@@ -67,10 +126,7 @@ def upload(local: str, remote: str, mode: int = 0o644) -> None:
 
 
 def download(remote: str, local: str) -> None:
-    client = paramiko.SSHClient()
-    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-    client.connect(HOST, username=USER, password=PASSWORD, timeout=15,
-                   look_for_keys=False, allow_agent=False)
+    client, _host = _connect()
     try:
         sftp = client.open_sftp()
         sftp.get(remote, local)
@@ -83,13 +139,19 @@ def download(remote: str, local: str) -> None:
 if __name__ == "__main__":
     if len(sys.argv) < 2:
         print(__doc__)
+        print("  候选地址: %s" % ", ".join(CANDIDATES))
+        print("  现在能连的: %s" % (probe() or "（一个都不通）"))
         sys.exit(1)
     if sys.argv[1] == "--script":
         run(Path(sys.argv[2]).read_text(encoding="utf-8"), timeout=600)
+    elif sys.argv[1] == "--probe":
+        got = probe()
+        print("  能连的地址: %s" % (got or "（一个都不通）"))
+        sys.exit(0 if got else 1)
     else:
         args = sys.argv[1:]
         timeout = 600
-        if args and args[0] == '--timeout':
+        if args and args[0] == "--timeout":
             timeout = int(args[1])
             args = args[2:]
-        run(" ".join(args), timeout=timeout)
+        sys.exit(run(" ".join(args), timeout=timeout)[0])

_build/diag502b.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+# 502 诊断 v2
+set -u
+
+echo "  ══ 1. 三个服务 ══"
+for s in lanremote-relay lanremote-tunnel lanremote-tunnel-h2; do
+    printf "    %-24s %s\n" "$s" "$(systemctl is-active $s 2>/dev/null)"
+done
+
+echo
+echo "  ══ 2. 所有 cloudflared 进程（看 protocol / metrics 端口）══"
+ps -eo pid,args 2>/dev/null | grep '[c]loudflared tunnel' | while read -r line; do
+    echo "    $line" | cut -c1-160
+done
+
+echo
+echo "  ══ 3. 两个 metrics 端口分别报几条连接 ══"
+for p in 20241 20242; do
+    n=$(curl -s --max-time 4 "http://127.0.0.1:$p/metrics" 2>/dev/null \
+        | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}')
+    printf "    %s -> %s 条\n" "$p" "${n:-读不到}"
+done
+
+echo
+echo "  ══ 4. 隧道 config.yml 的回源配置（关键：指向哪个端口）══"
+cat /root/.cloudflared/config.yml 2>/dev/null | sed 's/^/    /'
+
+echo
+echo "  ══ 5. relay 实际监听端口 ══"
+ss -lntp 2>/dev/null | grep -E 'python|8080|8880' | sed 's/^/    /' || echo "    （没看到）"
+
+echo
+echo "  ══ 6. 本机 8080 ══"
+curl -s --max-time 8 -o /dev/null -w '    HTTP %{http_code}  %{time_total}s\n' \
+    -H 'User-Agent: LanRemote/1.8.2' http://127.0.0.1:8080/v1/health
+
+echo
+echo "  ══ 7. 公网（关键）══"
+curl -s --max-time 25 -o /dev/null -w '    HTTP %{http_code}  %{time_total}s\n' \
+    -H 'User-Agent: LanRemote/1.8.2' https://relay.xxmxxs.top/v1/health
+
+echo
+echo "  ══ 8. cloudflared 日志最近 25 行 ══"
+journalctl -u lanremote-tunnel -n 25 --no-pager 2>/dev/null | tail -25 | sed 's/^/    /'

_build/diag_502_deep.sh

@@ -0,0 +1,72 @@
+#!/bin/bash
+# 诊断中转为什么 502 / 延时 1426ms
+set -u
+
+echo "════════ 1. 服务状态 ════════"
+for s in lanremote-relay lanremote-tunnel lanremote-nettune lanremote-watchdog.timer; do
+    printf "  %-26s %s\n" "$s" "$(systemctl is-active $s 2>&1)"
+done
+
+echo
+echo "════════ 2. 隧道连接数 · 落点 ════════"
+curl -s --max-time 5 http://127.0.0.1:20241/metrics 2>/dev/null \
+    | grep -E '^cloudflared_tunnel_ha_connections|server_locations' | sed 's/^/  /'
+
+echo
+echo "════════ 3. 本机中转响应（排除公网因素）════════"
+for i in 1 2 3; do
+    printf "  %d: HTTP %s  %sms\n" "$i" \
+        "$(curl -s -o /dev/null -w '%{http_code}' --max-time 8 http://127.0.0.1:8080/v1/health)" \
+        "$(curl -s -o /dev/null -w '%{time_total}' --max-time 8 http://127.0.0.1:8080/v1/health | awk '{printf "%d", $1*1000}')"
+done
+
+echo
+echo "════════ 4. 公网延时拆解（关键）════════"
+echo "  a) 到 Cloudflare 边缘的裸 RTT:"
+for i in 1 2 3; do
+    t=$(curl -s -o /dev/null -w '%{time_connect}' --max-time 15 https://relay.xxmxxs.top/v1/health 2>/dev/null)
+    echo "     连接耗时 $(echo "$t" | awk '{printf "%.0f", $1*1000}') ms"
+done
+
+echo
+echo "  b) 完整请求耗时（含隧道回源）:"
+for i in 1 2 3 4 5; do
+    out=$(curl -s -o /dev/null -w '%{http_code} %{time_connect} %{time_starttransfer} %{time_total}' \
+          --max-time 25 -H 'User-Agent: LanRemote/1.8.0' https://relay.xxmxxs.top/v1/health 2>/dev/null)
+    echo "     码/连接/首字节/总计: $(echo "$out" | awk '{printf "%s  %.0fms  %.0fms  %.0fms", $1, $2*1000, $3*1000, $4*1000}')"
+    sleep 1
+done
+
+echo
+echo "════════ 5. 本机到 Cloudflare 的网络质量 ════════"
+ping -c 10 -W 2 1.1.1.1 2>/dev/null | tail -2 | sed 's/^/  /'
+echo "  ---"
+ping -c 10 -W 2 104.21.54.45 2>/dev/null | tail -2 | sed 's/^/  /'
+echo "  ---"
+ping -c 10 -W 2 198.41.200.43 2>/dev/null | tail -2 | sed 's/^/  /'
+
+echo
+echo "════════ 6. 隧道日志最近的重连/错误 ════════"
+tail -400 /root/lanremote-relay/tunnel.log 2>/dev/null \
+    | grep -E 'Registered|Lost connection|Retrying|i/o timeout|context deadline' \
+    | tail -12 | sed 's/^/  /'
+
+echo
+echo "════════ 7. 隧道连接数变化趋势（连打 30 次）════════"
+for i in $(seq 1 30); do
+    c=$(curl -s --max-time 4 http://127.0.0.1:20241/metrics 2>/dev/null \
+        | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}')
+    h=$(curl -s -o /dev/null -w '%{http_code}' --max-time 12 \
+        -H 'User-Agent: LanRemote/1.8.0' https://relay.xxmxxs.top/v1/health)
+    printf "  %2d: 连接 %-3s 公网 %s\n" "$i" "${c:-?}" "$h"
+    sleep 2
+done
+
+echo
+echo "════════ 8. watchdog 最近记录 ════════"
+tail -10 /root/lanremote-relay/watchdog.log 2>/dev/null | sed 's/^/  /'
+
+echo
+echo "════════ 9. 资源占用 ════════"
+free -m | sed 's/^/  /'
+echo "  负载: $(cat /proc/loadavg | cut -d' ' -f1-3)"

_build/diag_admin_js.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+r'''把管理页的内嵌 JS 抠出来，看第 46 行为什么语法错。
+
+背景：_tests/test_admin_live.py 用 node --check 检查页面上的内嵌脚本，
+报第 46 行 SyntaxError: Invalid or unexpected token。
+但同一个页面上的管理接口（/v1/admin/allow_new、/v1/admin/set_code）
+是能用的 —— 说明后端没问题，问题在浏览器端。
+
+两种可能：
+  A. 真的有语法错 -> 用户点按钮没反应（严重）
+  B. 我抠脚本的方式不对（比如页面里字符串里含 </script>，
+     或者 JS 用到了 node 不认的语法）-> 假警报
+
+这个脚本把可疑的那一行原样打出来，人肉判断是哪种。
+'''
+from __future__ import annotations
+
+import json
+import re
+import subprocess
+import sys
+import tempfile
+import urllib.request
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "_build"))
+from devssh import run as ssh_run                          # noqa: E402
+
+BASE = "https://relay.xxmxxs.top"
+UA = {"User-Agent": "LanRemote/1.8.2"}
+
+
+def main() -> int:
+    _c, out, _e = ssh_run(
+        "cat /root/lanremote-relay/data/admin_key.txt", timeout=60, quiet=True)
+    key = (out or "").strip().splitlines()[0]
+
+    req = urllib.request.Request(BASE + "/zhongzhuanzhan",
+                                 headers={**UA, "X-Admin": key})
+    with urllib.request.urlopen(req, timeout=25) as resp:
+        html = resp.read().decode("utf-8", "replace")
+
+    scripts = re.findall(r"<script[^>]*>(.*?)</script>", html, re.S)
+    inline = [s for s in scripts if s.strip()]
+    print("  页面上有 %d 段内嵌脚本，长度: %s"
+          % (len(inline), [len(s) for s in inline]))
+
+    js = inline[0]
+    lines = js.splitlines()
+    print("  第 1 段共 %d 行" % len(lines))
+    print()
+    print("  ════ 第 40~54 行原样 ════")
+    for i in range(39, min(54, len(lines))):
+        marker = " <<<< 报错行" if i == 45 else ""
+        print("  %3d| %s%s" % (i + 1, lines[i], marker))
+    print()
+
+    # 把这一段单独跑 node --check，确认能复现
+    with tempfile.NamedTemporaryFile("w", suffix=".js", delete=False,
+                                     encoding="utf-8") as fh:
+        fh.write(js)
+        path = fh.name
+    proc = subprocess.run(["node", "--check", path],
+                          capture_output=True, text=True,
+                          encoding="utf-8", errors="replace")
+    print("  node --check 退出码: %d" % proc.returncode)
+    if proc.stderr:
+        print("  stderr:")
+        for line in proc.stderr.splitlines()[:12]:
+            print("    " + line)
+    Path(path).unlink(missing_ok=True)
+
+    # 也检查每一行里有没有裸控制字符
+    print()
+    print("  ════ 有没有裸控制字符 ════")
+    bad = 0
+    for i, line in enumerate(lines, 1):
+        for ch in line:
+            if ord(ch) < 32 and ch not in "\t":
+                print("    第 %d 行有控制字符 0x%02x" % (i, ord(ch)))
+                bad += 1
+                break
+    if not bad:
+        print("    ✓ 没有")
+
+    # 反引号 / 模板字面量 / 正则 里可能藏着截断问题
+    print()
+    print("  ════ 源 HTML 里 </script> 出现几次 ════")
+    print("    %d 次（正常应该等于 <script> 的个数）" % html.count("</script>"))
+    print("    <script 出现 %d 次" % html.lower().count("<script"))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/diag_admin_section.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+r'''查后台「抢救报告」分区为什么不显示。
+
+可能原因：
+  1. 后台页要登录，curl 直接拿是登录页（那 0 次是正常的，得带 cookie）
+  2. relay.py 没真正重新加载（旧进程还在）
+  3. 模板参数没传进去
+
+一条条排除。
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "_build"))
+from devssh import run      # noqa: E402
+
+REMOTE = r'''
+RELAY=/root/lanremote-relay
+
+echo "════ 1. 直接 curl 后台页，看返回的是什么 ════"
+curl -s --max-time 8 -D- http://127.0.0.1:8080/zhongzhuanzhan -o /tmp/adm.html 2>&1 | head -8
+echo "  --- 页面大小: $(wc -c < /tmp/adm.html) 字节 ---"
+echo "  --- 前 3 行 ---"
+head -3 /tmp/adm.html | sed 's/^/    /'
+echo "  --- 含关键词统计 ---"
+for k in 登录 密码 password 抢救报告 下载区 设备; do
+    printf '    %-12s %s\n' "$k" "$(grep -c "$k" /tmp/adm.html 2>/dev/null)"
+done
+
+echo
+echo "════ 2. relay.py 里到底有没有 rescue_fn ════"
+grep -n 'rescue_fn' $RELAY/relay.py | head -5 | sed 's/^/  /'
+echo "  admin.py 里 _rescue_rows:"
+grep -n 'def _rescue_rows\|def render_admin' $RELAY/admin.py | head -4 | sed 's/^/  /'
+
+echo
+echo "════ 3. 进程是什么时候起的（比文件新还是旧）════"
+ps -o pid,lstart,cmd -p $(systemctl show -p MainPID --value lanremote-relay) 2>/dev/null | sed 's/^/  /'
+echo "  relay.py 修改时间: $(stat -c '%y' $RELAY/relay.py)"
+echo "  admin.py 修改时间: $(stat -c '%y' $RELAY/admin.py)"
+
+echo
+echo "════ 4. 无登录直接调 render_admin 看看（绕过 HTTP）════"
+cd $RELAY && python3 -c "
+import admin
+html = admin.render_admin({'version':'2.0.0','uptimeSeconds':1,'devices':[],'allowNew':True},
+                         'https://x','/zhongzhuanzhan',0, lambda: [],
+                         rescue_fn=lambda: [{'name':'20261008-120000.txt','size':1234,
+                                             'mtime':1791400000,
+                                             'summary':'测试摘要'}] )
+print('  渲染长度:', len(html))
+print('  含抢救报告:', '抢救报告' in html)
+print('  含测试摘要:', '测试摘要' in html)
+print('  含下载链接:', '/rescue/20261008-120000.txt' in html)
+" 2>&1 | sed 's/^/  /'
+'''
+
+
+def main() -> int:
+    out = run(REMOTE, timeout=180)
+    text = out[1] if isinstance(out, tuple) else str(out)
+    print(text)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/diag_cache.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+# 查为什么首页还是 no-store，尽管代码里有 max-age=60
+set -u
+
+echo "════════ 1. 进程状态 ════════"
+systemctl show lanremote-relay -p ActiveEnterTimestamp -p MainPID --value | sed 's/^/  /'
+echo "  现在: $(date '+%Y-%m-%d %H:%M:%S')"
+echo "  进程命令行:"
+ps -o pid,etime,cmd -p $(systemctl show lanremote-relay -p MainPID --value) 2>/dev/null | sed 's/^/  /'
+
+echo
+echo "════════ 2. 本地首页响应头（全部）════════"
+curl -sI --max-time 15 http://127.0.0.1:8080/ 2>/dev/null | tr -d '\r' | sed 's/^/  /'
+
+echo
+echo "════════ 3. 换个端口直接跑这份代码，排除服务读的是别的文件 ════════"
+cd /root/lanremote-relay
+RELAY_PORT=18099 RELAY_BIND=127.0.0.1 timeout 8 python3 relay.py > /tmp/fresh.log 2>&1 &
+sleep 4
+echo "  新进程的首页头:"
+curl -sI --max-time 6 http://127.0.0.1:18099/ 2>/dev/null | tr -d '\r' | grep -iE '^cache-control|^HTTP' | sed 's/^/    /'
+wait 2>/dev/null || true
+
+echo
+echo "════════ 4. 服务实际读的文件是哪个 ════════"
+systemctl cat lanremote-relay 2>/dev/null | grep -E 'WorkingDirectory|ExecStart' | sed 's/^/  /'
+echo "  WorkingDirectory 下的 relay.py md5: $(md5sum /root/lanremote-relay/relay.py 2>/dev/null | awk '{print $1}')"
+
+echo
+echo "════════ 5. 有没有 __pycache__ 里的旧字节码在捣乱 ════════"
+ls -la /root/lanremote-relay/__pycache__/ 2>/dev/null | sed 's/^/  /' || echo "  （没有 __pycache__）"
+
+echo
+echo "════════ 6. 源码里那段到底长什么样（带行号）════════"
+grep -n -B3 -A6 'max-age=60' /root/lanremote-relay/relay.py | sed 's/^/  /'

_build/diag_nettune_stuck.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+r'''查 nettune 为什么卡在 activating（它挡着隧道，隧道一挂网站就 530）。
+
+发现：
+    lanremote-nettune      activating   <- 卡住
+    lanremote-tunnel       inactive     <- 在等 nettune
+    lanremote-tunnel-h2    inactive
+    公网 530
+
+nettune 的 unit 里有 Before=lanremote-tunnel.service，
+所以它卡住 = 隧道永远起不来。
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "_build"))
+from devssh import run      # noqa: E402
+
+REMOTE = r'''
+echo "════ 1. nettune 的完整状态 ════"
+systemctl status lanremote-nettune --no-pager -n 25 2>&1 | tail -25
+
+echo
+echo "════ 2. 有没有卡住的子进程 ════"
+systemctl show -p MainPID -p ControlPID -p ExecMainStatus -p StateChangeTimestamp lanremote-nettune 2>&1
+echo "  --- 所有相关进程 ---"
+ps -eo pid,ppid,stat,etime,cmd 2>/dev/null | grep -E 'iptables|net-tune|deploy-tune|ip link' | grep -v grep
+
+echo
+echo "════ 3. net-tune.sh 里会不会卡住的那步 ════"
+echo "  --- 脚本第 4 步（重启隧道）会 wait 吗 ---"
+grep -n 'systemctl restart' /root/lanremote-relay/net-tune.sh
+
+echo
+echo "════ 4. 手动跑一次 net-tune.sh 看卡在哪（30 秒超时）════"
+timeout 30 bash /root/lanremote-relay/net-tune.sh 2>&1 | tail -15
+echo "  退出码: $?"
+
+echo
+echo "════ 5. 卡住的时候隧道是什么状态 ════"
+systemctl is-active lanremote-tunnel lanremote-tunnel-h2
+journalctl -u lanremote-tunnel --no-pager -n 12 2>/dev/null | tail -12
+'''
+
+
+def main() -> int:
+    out = run(REMOTE, timeout=300)
+    text = out[1] if isinstance(out, tuple) else str(out)
+    print(text)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/diag_relay_bench.py

@@ -0,0 +1,241 @@
+# -*- coding: utf-8 -*-
+r'''复刻 bench_lan_vs_relay 的中转那一半，抓被控端日志。
+
+我自己那个 ins_relay_flow.py 是中转 4/4 通过的，
+但 bench_lan_vs_relay.py 的中转那半报"连接阶段失败: timed out"。
+差异一定在设置里，所以要逐项对齐 bench 的写法：
+  * RELAY_POLL=2（我那边是 5）
+  * 用 YKXMZ_DATA 指到临时目录 + --silent（我那边直接写 windows/data）
+  * 每条路起**一台全新的**被控端
+  * 先 attach 再 pair（bench 的 relay_connect 就是这么做的）
+
+把每一步的耗时和被控端日志都打出来。
+'''
+from __future__ import annotations
+
+import json
+import os
+import socket
+import subprocess
+import sys
+import tempfile
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+WINDOWS = ROOT / "windows"
+UA = {"User-Agent": "LanRemote/1.8.2"}
+CODE = "975310"
+
+
+def free_port() -> int:
+    s = socket.socket()
+    s.bind(("127.0.0.1", 0))
+    p = s.getsockname()[1]
+    s.close()
+    return p
+
+
+def post(base, path, body=b"", headers=None, timeout=20.0):
+    h = dict(UA)
+    h.update(headers or {})
+    req = urllib.request.Request(base + path, data=body, headers=h,
+                                 method="POST")
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return resp.status, resp.read()
+    except urllib.error.HTTPError as exc:
+        return exc.code, exc.read()
+    except Exception as exc:                              # noqa: BLE001
+        return 0, str(exc).encode()
+
+
+def get(base, path, timeout=5.0):
+    req = urllib.request.Request(base + path, headers=UA)
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return resp.status, resp.read()
+    except Exception as exc:                              # noqa: BLE001
+        return 0, str(exc).encode()
+
+
+def main() -> int:
+    work = Path(tempfile.mkdtemp(prefix="benchdiag_"))
+    relay_port = free_port()
+    agent_port = free_port()
+    base = "http://127.0.0.1:%d" % relay_port
+    relay_proc = agent_proc = None
+    relay_log = agent_log = None
+    try:
+        print("  中转端口 %d  被控端端口 %d" % (relay_port, agent_port))
+
+        # ---- 1. 本地中转（对齐 bench：RELAY_POLL=2）----
+        rdata = work / "r"
+        rdata.mkdir(parents=True, exist_ok=True)
+        env = dict(os.environ)
+        env.update({"RELAY_PORT": str(relay_port), "RELAY_BIND": "127.0.0.1",
+                    "RELAY_DATA": str(rdata), "RELAY_POLL": "2",
+                    "PYTHONIOENCODING": "utf-8", "PYTHONUNBUFFERED": "1"})
+        relay_log = open(work / "relay.log", "wb")
+        relay_proc = subprocess.Popen(
+            [sys.executable, "-u", str(ROOT / "relay" / "relay.py")], env=env,
+            stdout=relay_log, stderr=subprocess.STDOUT)
+        for _ in range(60):
+            time.sleep(0.5)
+            if get(base, "/v1/health")[0] == 200:
+                break
+        print("  中转就绪")
+
+        # ---- 2. 被控端（对齐 bench：YKXMZ_DATA + --silent + 独立锁端口）----
+        sys.path.insert(0, str(WINDOWS))
+        from lanremote.config import Store
+        adata = work / "a"
+        adata.mkdir(parents=True, exist_ok=True)
+        store = Store(adata)
+        store.set_pairing_code(CODE)
+        store.set("setup_done", True)
+        store.set("allow_new_pairing", True)
+        store.set("close_pair_after_first", False)
+        store.set("server_name", "基准测试电脑")
+        store.set("relay_url", base)
+        store.set("port", agent_port)
+
+        aenv = dict(os.environ)
+        aenv.update({"YKXMZ_DATA": str(adata),
+                     "YKXMZ_LOCK_PORT": str(free_port()),
+                     "PYTHONIOENCODING": "utf-8", "PYTHONUNBUFFERED": "1"})
+        agent_log = open(work / "agent.log", "wb")
+        agent_proc = subprocess.Popen(
+            [sys.executable, "-u", str(WINDOWS / "run_agent.py"),
+             "--silent", "--port", str(agent_port)],
+            cwd=str(WINDOWS), env=aenv,
+            stdout=agent_log, stderr=subprocess.STDOUT)
+
+        online = False
+        for _ in range(45):
+            time.sleep(1.0)
+            if agent_proc.poll() is not None:
+                print("  ✗ 被控端启动即退出，返回码 %s" % agent_proc.returncode)
+                break
+            st, body = get(base, "/v1/health", timeout=4)
+            if st == 200:
+                snap = json.loads(body.decode())
+                if any(d.get("online") for d in snap.get("devices", [])):
+                    online = True
+                    break
+        print("  被控端登记: %s" % ("成功" if online else "**失败**"))
+        if not online:
+            return 1
+
+        # ---- 3. 完全照 bench 的 relay_connect 做 ----
+        print()
+        print("  ── 照 bench 的顺序：attach -> pair ──")
+        t0 = time.time()
+        st, body = post(base, "/v1/client/attach", json.dumps(
+            {"code": CODE, "name": "基准测试手表"}).encode(),
+            {"Content-Type": "application/json"})
+        att = json.loads(body.decode())
+        session = att.get("session", "")
+        print("    attach: %dms ok=%s session=%s"
+              % (int((time.time() - t0) * 1000), att.get("ok"),
+                 session[:8] if session else "无"))
+
+        payload = (json.dumps({"cmd": "pair", "deviceId": "bench-relay",
+                               "deviceName": "基准测试手表",
+                               "code": CODE}, ensure_ascii=False)
+                   + "\n").encode()
+        t0 = time.time()
+        st, _ = post(base, "/v1/client/send", payload, {"X-Session": session})
+        print("    send pair: %dms status=%s" % (int((time.time() - t0) * 1000), st))
+
+        # 轮询等回复，每轮都打点
+        buf = b""
+        deadline = time.time() + 40
+        got = None
+        round_no = 0
+        while time.time() < deadline:
+            round_no += 1
+            remaining = deadline - time.time()
+            t0 = time.time()
+            st, chunk = post(base, "/v1/client/poll", b"",
+                             {"X-Session": session}, min(10.0, remaining))
+            buf += chunk
+            print("      poll#%d: %dms status=%s 收到 %d 字节"
+                  % (round_no, int((time.time() - t0) * 1000), st, len(chunk)))
+            while b"\n" in buf:
+                line, _, buf = buf.partition(b"\n")
+                if not line.strip():
+                    continue
+                msg = json.loads(line.decode())
+                if "event" in msg:
+                    continue
+                got = msg
+                break
+            if got is not None:
+                break
+
+        if got is None:
+            print("    ✗ 40 秒内没等到 pair 的回复")
+        else:
+            print("    ✓ pair 回复: %s" % json.dumps(got, ensure_ascii=False)[:120])
+
+        # ---- 4. 再来几次 ping ----
+        if got is not None:
+            for i in range(5):
+                payload = (json.dumps({"cmd": "ping"}) + "\n").encode()
+                post(base, "/v1/client/send", payload, {"X-Session": session})
+                deadline = time.time() + 15
+                ok = False
+                while time.time() < deadline:
+                    st, chunk = post(base, "/v1/client/poll", b"",
+                                     {"X-Session": session}, 8.0)
+                    buf += chunk
+                    while b"\n" in buf:
+                        line, _, buf = buf.partition(b"\n")
+                        if not line.strip():
+                            continue
+                        msg = json.loads(line.decode())
+                        if "event" in msg:
+                            continue
+                        ok = True
+                        break
+                    if ok:
+                        break
+                print("    ping#%d: %s" % (i + 1, "OK" if ok else "**超时**"))
+
+        # ---- 5. 被控端日志 ----
+        print()
+        print("  ════ 被控端日志（最后 25 行）════")
+        agent_log.flush()
+        for line in (work / "agent.log").read_text(
+                encoding="utf-8", errors="replace").splitlines()[-25:]:
+            print("    " + line[:120])
+        print()
+        print("  ════ 进程还活着吗 ════")
+        print("    agent poll = %s" % agent_proc.poll())
+        print()
+        print("  ════ 中转日志（最后 10 行）════")
+        relay_log.flush()
+        for line in (work / "relay.log").read_text(
+                encoding="utf-8", errors="replace").splitlines()[-10:]:
+            print("    " + line[:120])
+        return 0
+    finally:
+        for p in (agent_proc, relay_proc):
+            if p is not None:
+                try:
+                    p.terminate()
+                    p.wait(timeout=6)
+                except Exception:                         # noqa: BLE001
+                    try:
+                        p.kill()
+                    except Exception:                     # noqa: BLE001
+                        pass
+        import shutil
+        shutil.rmtree(work, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/diag_relay_leg.py

@@ -0,0 +1,183 @@
+# -*- coding: utf-8 -*-
+"""单独验证"跨网络中转载荷"这条腿，每步都打时间戳，定位卡在哪。
+
+只读诊断：起中转 + 真实被控端，然后用 HTTP 长轮询走一遍 pair/ping。
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import socket
+import subprocess
+import sys
+import tempfile
+import time
+import urllib.request
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "windows"))
+
+_UA = {"User-Agent": "LanRemote/1.8.2"}
+T0 = time.time()
+
+
+def say(msg: str) -> None:
+    print("  [%6.1fs] %s" % (time.time() - T0, msg), flush=True)
+
+
+def free_port() -> int:
+    with socket.socket() as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+def post(base, path, body=b"", headers=None, timeout=20.0):
+    req = urllib.request.Request(base + path, data=body, method="POST",
+                                 headers=dict(_UA))
+    for k, v in (headers or {}).items():
+        req.add_header(k, v)
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        return resp.status, resp.read()
+
+
+def main() -> int:
+    work = Path(tempfile.mkdtemp(prefix="diag_relayleg_"))
+    relay = agent = None
+    try:
+        from lanremote.config import Store
+        relay_port = free_port()
+        agent_port = free_port()
+        base = "http://127.0.0.1:%d" % relay_port
+        code = "246813"
+
+        say("起中转 %s" % base)
+        rd = work / "relaydata"
+        rd.mkdir(parents=True, exist_ok=True)
+        env = dict(os.environ)
+        env.update({"RELAY_PORT": str(relay_port), "RELAY_BIND": "127.0.0.1",
+                    "RELAY_DATA": str(rd), "RELAY_POLL": "2",
+                    "PYTHONIOENCODING": "utf-8", "PYTHONUNBUFFERED": "1"})
+        relay = subprocess.Popen(
+            [sys.executable, "-u", str(ROOT / "relay" / "relay.py")], env=env,
+            stdout=open(work / "relay.log", "wb"), stderr=subprocess.STDOUT)
+        for _ in range(60):
+            time.sleep(0.5)
+            try:
+                with urllib.request.urlopen(base + "/v1/health", timeout=2):
+                    break
+            except Exception:                               # noqa: BLE001
+                continue
+        say("中转就绪")
+
+        data = work / "agentdata"
+        data.mkdir(parents=True, exist_ok=True)
+        st = Store(data)
+        st.set_pairing_code(code)
+        st.set("setup_done", True)
+        st.set("allow_new_pairing", True)
+        st.set("close_pair_after_first", False)
+        st.set("server_name", "诊断电脑")
+        st.set("relay_url", base)
+        st.set("port", agent_port)
+
+        env2 = dict(os.environ)
+        env2.update({"YKXMZ_DATA": str(data),
+                     "YKXMZ_LOCK_PORT": str(free_port()),
+                     "PYTHONIOENCODING": "utf-8", "PYTHONUNBUFFERED": "1"})
+        say("起被控端 端口 %d" % agent_port)
+        agent = subprocess.Popen(
+            [sys.executable, "-u", str(ROOT / "windows" / "run_agent.py"),
+             "--silent", "--port", str(agent_port)],
+            cwd=str(ROOT / "windows"), env=env2,
+            stdout=open(work / "agent.log", "wb"), stderr=subprocess.STDOUT)
+
+        online = False
+        for _ in range(45):
+            time.sleep(1.0)
+            try:
+                with urllib.request.urlopen(base + "/v1/health", timeout=4) as r:
+                    snap = json.loads(r.read().decode("utf-8"))
+            except Exception:                               # noqa: BLE001
+                continue
+            if any(d.get("online") for d in snap.get("devices", [])):
+                online = True
+                break
+        say("被控端在线: %s" % online)
+        if not online:
+            say((data / "silent.log").read_text(encoding="utf-8",
+                                                errors="replace")[-500:])
+            return 1
+
+        say("attach 接入")
+        body = json.dumps({"code": code, "name": "诊断手表"},
+                          ensure_ascii=False).encode()
+        _s, raw = post(base, "/v1/client/attach", body)
+        attach = json.loads(raw.decode())
+        session = attach.get("session", "")
+        say("attach ok=%s session=%s" % (attach.get("ok"), session[:12]))
+
+        buf = b""
+
+        def call(obj, timeout=25.0):
+            nonlocal buf
+            payload = (json.dumps(obj, ensure_ascii=False) + "\n").encode()
+            say("  send %s" % obj.get("cmd"))
+            post(base, "/v1/client/send", payload, {"X-Session": session},
+                 timeout)
+            say("  send 返回，开始 poll")
+            deadline = time.time() + timeout
+            while True:
+                while b"\n" in buf:
+                    line, _, buf = buf.partition(b"\n")
+                    if not line.strip():
+                        continue
+                    msg = json.loads(line.decode())
+                    if "event" in msg:
+                        continue
+                    say("  收到 %s" % msg.get("cmd"))
+                    return msg
+                left = deadline - time.time()
+                if left <= 0:
+                    raise TimeoutError("等回复超时")
+                t = time.time()
+                _s, chunk = post(base, "/v1/client/poll", b"",
+                                 {"X-Session": session}, min(20.0, left))
+                say("  poll 返回 %d 字节，用了 %.1fs"
+                    % (len(chunk), time.time() - t))
+                buf += chunk
+
+        say("pair")
+        reply = call({"cmd": "pair", "deviceId": "diag-relay",
+                      "deviceName": "诊断手表", "code": code})
+        say("pair ok=%s" % reply.get("ok"))
+
+        for i in range(3):
+            t = time.time()
+            pong = call({"cmd": "ping"})
+            say("ping #%d ok=%s 往返 %.0f ms"
+                % (i + 1, pong.get("ok"), (time.time() - t) * 1000))
+        return 0
+    except Exception as exc:                                # noqa: BLE001
+        import traceback
+        say("异常: %s" % exc)
+        traceback.print_exc()
+        return 1
+    finally:
+        for p in (agent, relay):
+            if p is not None:
+                try:
+                    p.terminate()
+                    p.wait(timeout=5)
+                except Exception:                           # noqa: BLE001
+                    try:
+                        p.kill()
+                    except Exception:                      # noqa: BLE001
+                        pass
+        time.sleep(0.3)
+        shutil.rmtree(work, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

_build/diag_relay_register.py

@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+"""诊断：为什么被控端登记不到本地中转。
+
+只读诊断，不动任何仓库文件。
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import socket
+import subprocess
+import sys
+import tempfile
+import time
+import urllib.request
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "windows"))
+
+
+def free_port() -> int:
+    with socket.socket() as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+def get(url, timeout=5):
+    try:
+        with urllib.request.urlopen(url, timeout=timeout) as r:
+            return r.status, r.read().decode("utf-8", "replace")
+    except Exception as exc:                                # noqa: BLE001
+        return 0, str(exc)
+
+
+def main() -> int:
+    work = Path(tempfile.mkdtemp(prefix="diag_relay_"))
+    relay_port = free_port()
+    agent_port = free_port()
+    relay_url = "http://127.0.0.1:%d" % relay_port
+    print("  中转 %s   被控端端口 %d" % (relay_url, agent_port))
+
+    from lanremote.config import Store
+    # ⚠ 关键：run_agent.py 读的是 data_dir()，不是我们随手建的目录。
+    #   第一次诊断就栽在这儿 —— 配置写进了临时目录，agent 却读
+    #   windows/data，于是"怎么都不登记"。
+    #   data_dir() 优先认 YKXMZ_DATA，所以用环境变量把它指到临时目录，
+    #   这样两边看到的是同一份配置。
+    real_data = work / "agentdata"
+    real_data.mkdir(parents=True, exist_ok=True)
+    os.environ["YKXMZ_DATA"] = str(real_data)
+    store = Store(real_data)
+    store.set_pairing_code("135790")
+    store.set("setup_done", True)
+    store.set("allow_new_pairing", True)
+    store.set("close_pair_after_first", False)
+    store.set("server_name", "诊断电脑")
+    store.set("relay_url", relay_url)
+    store.set("port", agent_port)
+    print("  store 里的 relay_url = %r" % store.get("relay_url"))
+
+    relay_data = work / "relaydata"
+    relay_data.mkdir(parents=True, exist_ok=True)
+    env = dict(os.environ)
+    env.update({
+        "RELAY_PORT": str(relay_port), "RELAY_BIND": "127.0.0.1",
+        "RELAY_DATA": str(relay_data), "RELAY_POLL": "4",
+        "PYTHONIOENCODING": "utf-8", "PYTHONUNBUFFERED": "1",
+    })
+    relay = subprocess.Popen(
+        [sys.executable, "-u", str(ROOT / "relay" / "relay.py")], env=env,
+        stdout=open(work / "relay.log", "wb"), stderr=subprocess.STDOUT)
+    for _ in range(40):
+        time.sleep(0.5)
+        if get(relay_url + "/v1/health")[0] == 200:
+            break
+    print("  中转: %s" % ("起来了" if get(relay_url + "/v1/health")[0] == 200
+                          else "没起来"))
+
+    agent_log = open(work / "agent_stdout.log", "wb")
+    agent_env = dict(os.environ)
+    agent_env["YKXMZ_DATA"] = str(real_data)
+    agent_env["PYTHONIOENCODING"] = "utf-8"
+    agent = subprocess.Popen(
+        [sys.executable, "-u", str(ROOT / "windows" / "run_agent.py"),
+         "--silent", "--port", str(agent_port)],
+        cwd=str(ROOT / "windows"), env=agent_env,
+        stdout=agent_log, stderr=subprocess.STDOUT)
+
+    deadline = time.time() + 45
+    online = None
+    while time.time() < deadline:
+        time.sleep(1.5)
+        st, body = get(relay_url + "/v1/health")
+        if st == 200:
+            try:
+                snap = json.loads(body)
+            except Exception:                               # noqa: BLE001
+                continue
+            devs = snap.get("devices", [])
+            if devs:
+                online = devs
+                break
+        if agent.poll() is not None:
+            print("  ! 被控端进程已退出，退出码 %s" % agent.returncode)
+            break
+
+    print()
+    print("  ==== 中转看到的设备 ====")
+    if online:
+        for d in online:
+            print("    %s" % json.dumps(d, ensure_ascii=False)[:200])
+    else:
+        print("    （空 —— 没登记上）")
+
+    print()
+    print("  ==== 被控端 stdout（最后 800 字）====")
+    agent_log.flush()
+    try:
+        print((work / "agent_stdout.log").read_text(
+            encoding="utf-8", errors="replace")[-800:])
+    except Exception as exc:                                # noqa: BLE001
+        print("    读不到: %s" % exc)
+
+    print()
+    print("  ==== 被控端 silent.log（HeadlessUI 写这里）====")
+    try:
+        txt = (real_data / "silent.log").read_text(encoding="utf-8",
+                                                   errors="replace")
+        print(txt[-2000:])
+    except Exception as exc:                                # noqa: BLE001
+        print("    读不到: %s" % exc)
+
+    print()
+    print("  ==== 中转日志里的注册相关 ====")
+    try:
+        txt = (work / "relay.log").read_text(encoding="utf-8",
+                                             errors="replace")
+        for line in txt.splitlines():
+            if any(k in line for k in ("register", "注册", "被控端", "poll",
+                                       "上线", "Traceback", "Error")):
+                print("    " + line[:150])
+    except Exception as exc:                                # noqa: BLE001
+        print("    读不到: %s" % exc)
+
+    for proc in (agent, relay):
+        try:
+            proc.terminate()
+            proc.wait(timeout=5)
+        except Exception:                                   # noqa: BLE001
+            try:
+                proc.kill()
+            except Exception:                              # noqa: BLE001
+                pass
+    time.sleep(0.3)
+    shutil.rmtree(work, ignore_errors=True)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

_build/diag_server_dns.py

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+r'''查服务器的 DNS 为什么解析不了 yk.xxmxxs.top。
+
+现象：服务器上 curl 报 "Could not resolve host"，但
+      加 --resolve 手动指定 Cloudflare 的边缘 IP 就 200。
+      也就是**网络通、只有解析不行**。
+
+监测单元查的就是这个域名，所以它必然一直失败
+-> 启动紧急预案 -> 瞎折腾。
+
+要区分是哪种情况：
+    A. 服务器的 DNS 服务器本身坏了 / 不响应
+    B. DNS 服务器能通，但**不知道这个域名**（还没传播到这台机器用的解析器）
+    C. systemd-resolved 的缓存或 stub 出问题
+    D. /etc/hosts 或 nsswitch 配置把解析绕过去了
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "_build"))
+from lssh import run      # noqa: E402
+
+DOMAIN = "yk.xxmxxs.top"
+
+REMOTE = r'''
+D=__DOMAIN__
+
+echo "════ 1. /etc/resolv.conf ════"
+cat /etc/resolv.conf 2>/dev/null | sed 's/^/  /'
+
+echo
+echo "════ 2. 有没有 systemd-resolved ════"
+systemctl is-active systemd-resolved 2>&1 | sed 's/^/  systemd-resolved: /'
+resolvectl status 2>/dev/null | grep -E 'DNS Servers|DNS Domain|Current DNS|Fallback' | head -8 | sed 's/^/  /'
+
+echo
+echo "════ 3. 拿几个公共 DNS 直接问（绕过本机配置）════"
+for ns in 1.1.1.1 8.8.8.8 9.9.9.9; do
+    printf '  %-10s ' "$ns"
+    if command -v dig >/dev/null 2>&1; then
+        r=$(dig +short +time=4 +tries=1 @$ns A $D 2>/dev/null | head -3 | tr '\n' ' ')
+        echo "${r:-（没答）}"
+    else
+        echo "（没装 dig）"
+    fi
+done
+
+echo
+echo "════ 4. 本机默认解析 ════"
+printf '  %-26s ' "getent hosts"; getent hosts $D 2>/dev/null || echo "（空）"
+printf '  %-26s ' "解析一个已知域名"; getent hosts www.cloudflare.com 2>/dev/null | head -1 || echo "（也失败！说明 DNS 整体有问题）"
+printf '  %-26s ' "解析亚马逊自家域名"; getent hosts aws.amazon.com 2>/dev/null | head -1 || echo "（失败）"
+
+echo
+echo "════ 5. nsswitch / hosts ════"
+grep -vE '^\s*#|^\s*$' /etc/nsswitch.conf 2>/dev/null | grep '^hosts' | sed 's/^/  /'
+echo "  --- /etc/hosts 里有没有 yk.xxmxxs.top ---"
+grep -i "$D" /etc/hosts 2>/dev/null | sed 's/^/  /' || echo "  （没有）"
+
+echo
+echo "════ 6. 用 python 解析（走的是同一套 nsswitch）════"
+python3 -c "
+import socket
+try:
+    print('  ', socket.getaddrinfo('$D', 443)[:2])
+except Exception as e:
+    print('   失败:', e)
+" 2>&1 | sed 's/^/  /'
+
+echo
+echo "════ 7. 装个 dig（如果没装）════"
+command -v dig >/dev/null 2>&1 || {
+    echo "  装 dnsutils…"
+    sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq dnsutils 2>&1 | tail -1
+}
+echo "  dig: $(command -v dig || echo 没装)"
+
+echo
+echo "════ 8. 再问一次（装完 dig 之后）════"
+for ns in 1.1.1.1 8.8.8.8; do
+    printf '  %-10s ' "$ns"
+    dig +short +time=5 +tries=2 @$ns A $D 2>/dev/null | head -3 | tr '\n' ' ' | sed 's/$/\n/'
+done
+echo "  默认解析:"
+dig +short +time=5 A $D 2>/dev/null | head -3 | sed 's/^/    /' || echo "    （空）"
+'''
+
+
+def main() -> int:
+    print("=" * 62)
+    print("  查服务器的 DNS")
+    print("=" * 62)
+    out = run(REMOTE.replace("__DOMAIN__", DOMAIN), timeout=600, quiet=True)
+    print(out[1] if isinstance(out, tuple) else out)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/diag_server_self_access.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+r'''查服务器为什么访问不了自己的域名（curl 返回 000）。
+
+== 现象 ==
+
+    从我的电脑  -> https://yk.xxmxxs.top  = 200  ✅
+    从服务器自己-> https://yk.xxmxxs.top  = 000  ❌
+
+监测单元就跑在服务器上、查的就是这个域名，所以它一直判失败
+-> fails 一直涨 -> 会启动紧急预案 -> 瞎折腾。
+
+== 最可能的原因：IPv6 ==
+
+yk.xxmxxs.top 在 Cloudflare 上有 **AAAA 记录**：
+    2606:4700:3036::6815:362d
+    2606:4700:3036::ac43:df96
+
+Lightsail 的实例默认**没有 IPv6 地址**。curl 会先试 IPv6、失败，
+如果不自动回退到 IPv4，就直接报连接失败（=000）。
+
+验证办法很简单：`curl -4`（强制 IPv4）通不通。
+
+== 其他可能 ==
+
+  * DNS 在服务器上解析不出来（getent hosts 看看）
+  * Cloudflare 拒绝来自源站自己 IP 的请求（回环防护）——不太可能
+  * 出站被挡（Lightsail 默认出站全开，概率低）
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "_build"))
+from lssh import run, HOST as LS_HOST                 # noqa: E402
+
+DOMAIN = "yk.xxmxxs.top"
+
+REMOTE = r'''
+D=__DOMAIN__
+
+echo "════ 1. 服务器有没有 IPv6 ════"
+ip -brief addr show 2>/dev/null | sed 's/^/  /'
+echo "  --- IPv6 默认路由 ---"
+ip -6 route show default 2>/dev/null | sed 's/^/  /' || echo "  （没有 IPv6 默认路由）"
+
+echo
+echo "════ 2. 域名解析（IPv4 / IPv6 分开看）════"
+echo "  A 记录:"
+getent ahostsv4 $D 2>/dev/null | awk '{print "    " $1}' | sort -u
+echo "  AAAA 记录:"
+getent ahostsv6 $D 2>/dev/null | awk '{print "    " $1}' | sort -u
+echo "  --- dig 结果 ---"
+dig +short A $D 2>/dev/null | sed 's/^/    A: /'
+dig +short AAAA $D 2>/dev/null | sed 's/^/    AAAA: /'
+
+echo
+echo "════ 3. curl 各种姿势 ════"
+printf '  %-30s %s\n' "默认（可能走 IPv6）" "$(curl -s -o /dev/null -w '%{http_code}' --max-time 15 https://$D/v1/health)"
+printf '  %-30s %s\n' "强制 IPv4 (-4)" "$(curl -s4 -o /dev/null -w '%{http_code}' --max-time 15 https://$D/v1/health)"
+printf '  %-30s %s\n' "强制 IPv6 (-6)" "$(curl -s6 -o /dev/null -w '%{http_code}' --max-time 10 https://$D/v1/health)"
+printf '  %-30s %s\n' "http 强制 IPv4" "$(curl -s4L -o /dev/null -w '%{http_code}' --max-time 15 http://$D/v1/health)"
+
+echo
+echo "  --- 详细报错（默认那条）---"
+curl -s -o /dev/null -w '    %{http_code}\n' --max-time 10 https://$D/v1/health 2>&1 || true
+curl -v -o /dev/null --max-time 12 https://$D/v1/health 2>&1 | grep -iE 'trying|connected|refused|timed|error|Could not' | head -10 | sed 's/^/    /'
+
+echo
+echo "════ 4. 直连 Cloudflare 边缘 IP（跳过 DNS）════"
+for ip in 104.21.54.45 172.67.223.150; do
+    printf '  %-20s %s\n' "$ip (HTTPS)" "$(curl -sk -o /dev/null -w '%{http_code}' --max-time 12 --resolve $D:443:$ip https://$D/v1/health)"
+done
+
+echo
+echo "════ 5. 出站到 Cloudflare 通不通（纯 TCP）════"
+for ip in 104.21.54.45 172.67.223.150; do
+    if timeout 6 bash -c "</dev/tcp/$ip/443" 2>/dev/null; then
+        echo "  $ip:443  通"
+    else
+        echo "  $ip:443  不通"
+    fi
+done
+
+echo
+echo "════ 6. 对比：直连自己的 nginx ════"
+printf '  %-30s %s\n' "127.0.0.1:443（带 SNI）" "$(curl -sk -o /dev/null -w '%{http_code}' --max-time 8 --resolve $D:443:127.0.0.1 https://$D/v1/health)"
+printf '  %-30s %s\n' "公网 IP:443" "$(curl -sk -o /dev/null -w '%{http_code}' --max-time 8 --resolve $D:443:LS_HOST https://$D/v1/health)"
+'''
+
+
+def main() -> int:
+    print("=" * 62)
+    print("  查服务器为什么访问不了自己的域名")
+    print("=" * 62)
+    out = run(REMOTE.replace("__DOMAIN__", DOMAIN), timeout=300, quiet=True)
+    print(out[1] if isinstance(out, tuple) else out)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/diag_tunnel_conns.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+# 查隧道为什么只有 3 条连接（配置 6）
+set -u
+
+echo "════════ 1. 当前连接数 ════════"
+curl -s --max-time 5 http://127.0.0.1:20241/metrics 2>/dev/null \
+    | grep -E '^cloudflared_tunnel_ha_connections|server_locations.*} 1' | sed 's/^/  /'
+
+echo
+echo "════════ 2. cloudflared 进程 ════════"
+ps -o pid,etime,rss,cmd -p $(systemctl show lanremote-tunnel -p MainPID --value) 2>/dev/null | sed 's/^/  /'
+
+echo
+echo "════════ 3. 最近 30 分钟的连接事件 ════════"
+journalctl -u lanremote-tunnel --since '30 minutes ago' --no-pager 2>/dev/null \
+    | grep -E 'Registered|Lost|Unable|Unregistered|connIndex' | tail -20 | sed 's/^/  /'
+
+echo
+echo "════════ 4. cloudflared 的完整参数 ════════"
+systemctl cat lanremote-tunnel 2>/dev/null | grep -A8 'ExecStart=' | sed 's/^/  /'
+
+echo
+echo "════════ 5. 4 个活跃连接都在哪个落点、延迟多少 ════════"
+curl -s --max-time 5 http://127.0.0.1:20241/metrics 2>/dev/null \
+    | grep -E 'cloudflared_tunnel_(server_locations|connection_)' \
+    | grep -v '^#' | sed 's/^/  /'
+
+echo
+echo "════════ 6. 内存占用（MemoryMax=160M 可能把 cloudflared 撑爆）════════"
+systemctl show lanremote-tunnel -p MemoryCurrent -p MemoryMax --value | sed 's/^/  /'
+echo "  ---"
+echo "  设备总内存:"
+free -m | sed 's/^/    /'
+
+echo
+echo "════════ 7. 日志里有没有 OOM 或被杀 ════════"
+journalctl -u lanremote-tunnel --since '2 hours ago' --no-pager 2>/dev/null \
+    | grep -icE 'oom|killed|signal' | sed 's/^/  OOM/被杀 相关行数: /'
+dmesg 2>/dev/null | grep -iE 'oom|killed process' | tail -5 | sed 's/^/  /' || echo "  dmesg 里没有"
+
+echo
+echo "════════ 8. 隧道日志末尾（看有没有在反复失败）════════"
+tail -20 /root/lanremote-relay/tunnel.log 2>/dev/null | sed 's/^/  /'

_build/diag_tunnel_down.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+r'''查隧道为什么掉连接（公网 530，连接数 1/0）。
+
+上一轮才刚修掉 nettune 死锁、把公网拉到 200；这次重启 nettune 之后
+又变成 530 了。要分清是：
+    * nettune 又卡了（那个死锁没修干净？）
+    * 还是隧道自己掉了（cloudflared 的问题）
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "_build"))
+from devssh import run      # noqa: E402
+
+REMOTE = r'''
+echo "════ 1. 服务状态 + 有没有卡住的 ════"
+for s in lanremote-relay lanremote-tunnel lanremote-tunnel-h2 lanremote-nettune; do
+    printf '  %-24s %s\n' "$s" "$(systemctl is-active $s)"
+done
+echo "  --- nettune 卡住吗 ---"
+systemctl show -p SubState -p MainPID -p ExecMainStartTimestamp lanremote-nettune 2>&1 | sed 's/^/    /'
+echo "  --- 有没有卡住的 systemctl ---"
+ps -eo pid,etime,cmd 2>/dev/null | grep -E 'systemctl|net-tune' | grep -v grep | sed 's/^/    /'
+
+echo
+echo "════ 2. net-tune 的修复在设备上吗 ════"
+grep -c NETTUNE_SERVICE_CALL /root/lanremote-relay/net-tune.sh
+echo "  unit 里有吗: $(grep -c NETTUNE_SERVICE_CALL /etc/systemd/system/lanremote-nettune.service)"
+
+echo
+echo "════ 3. 隧道为什么连接数是 0 ════"
+journalctl -u lanremote-tunnel --no-pager -n 25 2>/dev/null | tail -25 | sed 's/^/  /'
+
+echo
+echo "════ 4. 隧道 unit 长什么样（重启策略 / 协议）════"
+systemctl cat lanremote-tunnel 2>/dev/null | grep -vE '^#' | head -25 | sed 's/^/  /'
+
+echo
+echo "════ 5. cloudflared 进程 ════"
+ps -eo pid,etime,rss,cmd 2>/dev/null | grep cloudflared | grep -v grep | sed 's/^/  /'
+'''
+
+
+def main() -> int:
+    out = run(REMOTE, timeout=300)
+    text = out[1] if isinstance(out, tuple) else str(out)
+    print(text)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/diag_tunnel_log.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+r'''看隧道为什么反复掉（公网 530 的真因）。
+
+已知：
+    nettune 死锁已修（SubState=exited，不再卡）
+    但隧道每 3~10 分钟被重启一次（部分是我加的预案在救、部分是它自己掉）
+    公网 530
+
+要查的是 tunnel.log 里 cloudflared 到底在报什么。
+'''
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "_build"))
+from devssh import run      # noqa: E402
+
+REMOTE = r'''
+LOG=/root/lanremote-relay/tunnel.log
+H2LOG=/root/lanremote-relay/tunnel-h2.log
+
+echo "════ 1. tunnel.log 里的错误行（最近 40 条）════"
+grep -iE 'error|fail|warn|timeout|retry|refused|EOF|unregister|connection' "$LOG" 2>/dev/null | tail -40 | sed 's/^/  /'
+
+echo
+echo "════ 2. tunnel.log 最后 25 行（原样）════"
+tail -25 "$LOG" 2>/dev/null | sed 's/^/  /'
+
+echo
+echo "════ 3. h2 那份的日志 ════"
+tail -15 "$H2LOG" 2>/dev/null | sed 's/^/  /'
+
+echo
+echo "════ 4. 两份日志多大（写爆了会拖慢小机器）════"
+ls -la "$LOG" "$H2LOG" 2>/dev/null | sed 's/^/  /'
+
+echo
+echo "════ 5. cloudflared 版本 + 配置 ════"
+/usr/local/bin/cloudflared --version 2>&1 | sed 's/^/  /'
+echo "  --- config.yml ---"
+cat /root/.cloudflared/config.yml 2>/dev/null | sed 's/^/  /'
+
+echo
+echo "════ 6. 现在两条隧道的连接数 ════"
+for p in 20241 20242; do
+    n=$(curl -s --max-time 5 "http://127.0.0.1:$p/metrics" 2>/dev/null | grep '^cloudflared_tunnel_ha_connections' | awk '{print $2}' | head -1)
+    echo "  $p -> ${n:-拿不到}"
+done
+
+echo
+echo "════ 7. 公网现在通吗 ════"
+echo "  $(curl -s -o /dev/null -w '%{http_code}' --max-time 15 https://relay.xxmxxs.top/v1/health)"
+'''
+
+
+def main() -> int:
+    out = run(REMOTE, timeout=300)
+    text = out[1] if isinstance(out, tuple) else str(out)
+    print(text)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/diag_tunnel_opt.sh

@@ -0,0 +1,70 @@
+#!/bin/bash
+# 看隧道当前配置，并做一轮协议/连接数的对照实测。
+set -u
+
+echo "════════ 1. 隧道服务当前参数 ════════"
+grep -E 'ExecStart' /etc/systemd/system/lanremote-tunnel.service | sed 's/^/  /'
+
+echo
+echo "════════ 2. cloudflared 版本 & 支持的参数 ════════"
+cloudflared --version 2>&1 | head -1 | sed 's/^/  /'
+echo "  --- 和丢包恢复相关的参数:"
+cloudflared tunnel run --help 2>&1 | grep -E 'protocol|ha-connections|edge-ip-version|region|retries' | sed 's/^/    /'
+
+echo
+echo "════════ 3. 当前落点 ════════"
+curl -s --max-time 5 http://127.0.0.1:20241/metrics 2>/dev/null \
+    | grep 'server_locations.*} 1' | sed 's/^/  /'
+
+echo
+echo "════════ 4. 测一轮公网（12 次，记录耗时分布）════════"
+times=()
+ok=0
+for i in $(seq 1 12); do
+    out=$(curl -s -o /dev/null -w '%{http_code} %{time_total}' --max-time 25 \
+          -H 'User-Agent: LanRemote/1.8.0' https://relay.xxmxxs.top/v1/health)
+    code=$(echo "$out" | awk '{print $1}')
+    ms=$(echo "$out" | awk '{printf "%d", $2*1000}')
+    times+=("$ms")
+    [ "$code" = "200" ] && ok=$((ok+1))
+    printf "  %2d: HTTP %-4s %5sms\n" "$i" "$code" "$ms"
+    sleep 1
+done
+echo "  可用 $ok/12"
+echo "  耗时: $(printf '%s\n' "${times[@]}" | sort -n | awk '{a[NR]=$1} END {printf "最小 %dms  中位 %dms  最大 %dms", a[1], a[int(NR/2)+1], a[NR]}')"
+
+echo
+echo "════════ 5. 每个候选 edge IP 的可达性（挑最快的）════════"
+python3 - <<'PY'
+import socket, time
+ips = ["198.41.192.47", "198.41.192.57", "198.41.192.67", "198.41.192.107",
+       "198.41.192.167", "198.41.192.227", "198.41.200.23", "198.41.200.33",
+       "198.41.200.43", "198.41.200.63", "198.41.200.113", "198.41.200.193"]
+rows = []
+for ip in ips:
+    s = socket.socket(); s.settimeout(4)
+    t = time.perf_counter()
+    try:
+        s.connect((ip, 7844))
+        ms = (time.perf_counter() - t) * 1000
+        rows.append((ms, ip, "通"))
+    except OSError as e:
+        rows.append((99999, ip, "不通"))
+    finally:
+        s.close()
+rows.sort()
+for ms, ip, st in rows:
+    if st == "通":
+        print("    %-16s %6.0f ms" % (ip, ms))
+    else:
+        print("    %-16s 不通" % ip)
+good = [r for r in rows if r[2] == "通"]
+print("    => %d/%d 可达，最快 %s" % (len(good), len(rows), good[0][1] if good else "无"))
+PY
+
+echo
+echo "════════ 6. 隧道日志里 i/o timeout 的最近频率 ════════"
+for kw in 'Registered tunnel connection' 'Lost connection' 'i/o timeout' 'context deadline'; do
+    n=$(tail -800 /root/lanremote-relay/tunnel.log 2>/dev/null | grep -c "$kw")
+    printf "  %-34s %s 次（最近 800 行）\n" "$kw" "$n"
+done

_build/dl_long2h_conns.tsv

@@ -0,0 +1,94 @@
+2026-10-07 17:27:20	X	X
+2026-10-07 17:28:27	8	2
+2026-10-07 17:29:33	8	2
+2026-10-07 17:30:53	7	2
+2026-10-07 17:31:59	1	2
+2026-10-07 17:33:04	8	2
+2026-10-07 17:34:11	8	2
+2026-10-07 17:35:17	8	2
+2026-10-07 17:36:22	8	2
+2026-10-07 17:37:29	8	2
+2026-10-07 17:38:36	8	2
+2026-10-07 17:39:43	8	2
+2026-10-07 17:41:02	7	2
+2026-10-07 17:42:08	7	2
+2026-10-07 17:43:09	7	2
+2026-10-07 17:44:16	8	2
+2026-10-07 17:45:23	8	2
+2026-10-07 17:46:28	8	2
+2026-10-07 17:47:32	8	2
+2026-10-07 17:48:37	8	2
+2026-10-07 17:49:43	8	2
+2026-10-07 17:50:48	7	2
+2026-10-07 17:52:06	8	2
+2026-10-07 17:53:20	7	2
+2026-10-07 17:54:26	7	2
+2026-10-07 17:55:33	8	2
+2026-10-07 17:57:06	1	2
+2026-10-07 17:58:12	8	2
+2026-10-07 17:59:17	8	2
+2026-10-07 18:00:35	8	2
+2026-10-07 18:01:38	5	2
+2026-10-07 18:02:46	8	1
+2026-10-07 18:03:52	6	2
+2026-10-07 18:04:59	6	2
+2026-10-07 18:06:05	8	2
+2026-10-07 18:07:10	8	2
+2026-10-07 18:08:16	8	2
+2026-10-07 18:09:20	8	2
+2026-10-07 18:10:39	7	2
+2026-10-07 18:11:29	7	2
+2026-10-07 18:12:35	8	2
+2026-10-07 18:13:38	8	2
+2026-10-07 18:14:42	8	2
+2026-10-07 18:15:47	8	2
+2026-10-07 18:16:53	8	2
+2026-10-07 18:17:58	8	2
+2026-10-07 18:19:04	8	2
+2026-10-07 18:20:10	8	2
+2026-10-07 18:21:13	8	2
+2026-10-07 18:22:19	8	2
+2026-10-07 18:23:21	8	2
+2026-10-07 18:24:26	8	2
+2026-10-07 18:25:34	7	2
+2026-10-07 18:26:39	8	2
+2026-10-07 18:27:45	8	2
+2026-10-07 18:28:51	8	2
+2026-10-07 18:30:09	8	2
+2026-10-07 18:30:59	8	2
+2026-10-07 18:32:06	7	2
+2026-10-07 18:33:12	7	1
+2026-10-07 18:34:19	8	2
+2026-10-07 18:35:24	8	2
+2026-10-07 18:36:29	8	2
+2026-10-07 18:37:34	8	2
+2026-10-07 18:38:39	8	2
+2026-10-07 18:39:46	8	2
+2026-10-07 18:40:48	8	2
+2026-10-07 18:41:50	8	2
+2026-10-07 18:42:52	8	2
+2026-10-07 18:43:57	8	2
+2026-10-07 18:45:04	8	2
+2026-10-07 18:46:10	8	2
+2026-10-07 18:47:15	8	2
+2026-10-07 18:48:21	8	2
+2026-10-07 18:49:26	8	2
+2026-10-07 18:50:45	8	2
+2026-10-07 18:51:51	8	2
+2026-10-07 18:52:53	8	2
+2026-10-07 18:53:58	8	2
+2026-10-07 18:55:04	8	2
+2026-10-07 18:56:10	8	2
+2026-10-07 18:57:15	8	2
+2026-10-07 18:58:23	8	2
+2026-10-07 18:59:29	8	2
+2026-10-07 19:00:36	5	2
+2026-10-07 19:01:40	7	2
+2026-10-07 19:02:42	6	1
+2026-10-07 19:03:55	6	2
+2026-10-07 19:05:03	8	2
+2026-10-07 19:06:10	8	2
+2026-10-07 19:07:16	8	2
+2026-10-07 19:08:22	8	2
+2026-10-07 19:09:27	8	2
+2026-10-07 19:10:46	6	2

_build/dl_long2h_health.tsv

@@ -0,0 +1,362 @@
+2026-10-07 17:27:20	502	1407
+2026-10-07 17:27:36	200	921
+2026-10-07 17:27:52	200	1063
+2026-10-07 17:28:09	200	1491
+2026-10-07 17:28:27	200	2796
+2026-10-07 17:28:44	200	2277
+2026-10-07 17:29:00	200	974
+2026-10-07 17:29:17	200	1274
+2026-10-07 17:29:33	200	1265
+2026-10-07 17:29:50	200	1176
+2026-10-07 17:30:06	200	1062
+2026-10-07 17:30:35	200	14074
+2026-10-07 17:30:53	200	2637
+2026-10-07 17:31:09	200	1180
+2026-10-07 17:31:26	200	1524
+2026-10-07 17:31:42	530	862
+2026-10-07 17:31:58	200	1683
+2026-10-07 17:32:15	200	997
+2026-10-07 17:32:31	200	1530
+2026-10-07 17:32:48	200	1542
+2026-10-07 17:33:04	200	1257
+2026-10-07 17:33:21	200	1439
+2026-10-07 17:33:38	200	1526
+2026-10-07 17:33:55	200	2034
+2026-10-07 17:34:11	200	1438
+2026-10-07 17:34:28	200	1240
+2026-10-07 17:34:44	200	1509
+2026-10-07 17:35:01	200	1280
+2026-10-07 17:35:17	200	1240
+2026-10-07 17:35:34	200	1293
+2026-10-07 17:35:50	200	1018
+2026-10-07 17:36:06	200	1063
+2026-10-07 17:36:22	200	1033
+2026-10-07 17:36:40	200	2410
+2026-10-07 17:36:56	200	1206
+2026-10-07 17:37:13	200	1503
+2026-10-07 17:37:29	200	1152
+2026-10-07 17:37:47	200	2442
+2026-10-07 17:38:03	200	1267
+2026-10-07 17:38:20	200	1555
+2026-10-07 17:38:36	200	1187
+2026-10-07 17:38:54	200	2524
+2026-10-07 17:39:10	200	973
+2026-10-07 17:39:26	200	1444
+2026-10-07 17:39:43	200	1285
+2026-10-07 17:40:00	200	1600
+2026-10-07 17:40:16	200	982
+2026-10-07 17:40:45	200	14272
+2026-10-07 17:41:01	200	1264
+2026-10-07 17:41:18	200	1235
+2026-10-07 17:41:35	200	1482
+2026-10-07 17:41:51	200	1471
+2026-10-07 17:42:08	200	1483
+2026-10-07 17:42:37	200	13940
+2026-10-07 17:42:53	200	1073
+2026-10-07 17:43:09	200	1093
+2026-10-07 17:43:26	200	1472
+2026-10-07 17:43:43	200	1576
+2026-10-07 17:43:59	200	1453
+2026-10-07 17:44:16	200	1984
+2026-10-07 17:44:33	200	1237
+2026-10-07 17:44:49	200	924
+2026-10-07 17:45:06	200	1936
+2026-10-07 17:45:23	200	1750
+2026-10-07 17:45:39	200	1039
+2026-10-07 17:45:55	200	1033
+2026-10-07 17:46:11	200	1061
+2026-10-07 17:46:27	200	1083
+2026-10-07 17:46:44	200	847
+2026-10-07 17:47:00	200	972
+2026-10-07 17:47:16	200	1055
+2026-10-07 17:47:32	200	1219
+2026-10-07 17:47:48	200	1034
+2026-10-07 17:48:05	200	1203
+2026-10-07 17:48:21	200	1142
+2026-10-07 17:48:37	200	1235
+2026-10-07 17:48:53	200	988
+2026-10-07 17:49:10	200	1636
+2026-10-07 17:49:26	200	998
+2026-10-07 17:49:43	200	1226
+2026-10-07 17:49:59	200	849
+2026-10-07 17:50:15	200	966
+2026-10-07 17:50:31	200	1476
+2026-10-07 17:50:48	200	1336
+2026-10-07 17:51:05	200	1452
+2026-10-07 17:51:21	200	1017
+2026-10-07 17:51:50	200	13815
+2026-10-07 17:52:06	200	1437
+2026-10-07 17:52:23	200	1215
+2026-10-07 17:52:39	200	1065
+2026-10-07 17:53:03	200	9538
+2026-10-07 17:53:20	200	1556
+2026-10-07 17:53:36	200	1132
+2026-10-07 17:53:53	200	1548
+2026-10-07 17:54:09	200	1243
+2026-10-07 17:54:26	200	1499
+2026-10-07 17:54:43	200	1516
+2026-10-07 17:54:59	200	1491
+2026-10-07 17:55:16	200	1492
+2026-10-07 17:55:33	200	1665
+2026-10-07 17:55:49	200	1227
+2026-10-07 17:56:06	200	1531
+2026-10-07 17:56:46	000	25000
+2026-10-07 17:57:06	502	4652
+2026-10-07 17:57:22	200	1475
+2026-10-07 17:57:39	200	1545
+2026-10-07 17:57:55	200	1116
+2026-10-07 17:58:11	200	1026
+2026-10-07 17:58:28	200	1544
+2026-10-07 17:58:44	200	1038
+2026-10-07 17:59:00	200	992
+2026-10-07 17:59:17	200	988
+2026-10-07 17:59:34	200	1823
+2026-10-07 17:59:50	200	1004
+2026-10-07 18:00:06	200	1236
+2026-10-07 18:00:35	200	14105
+2026-10-07 18:01:05	200	14208
+2026-10-07 18:01:21	200	1597
+2026-10-07 18:01:38	200	1531
+2026-10-07 18:01:56	200	2613
+2026-10-07 18:02:13	200	1563
+2026-10-07 18:02:29	200	1509
+2026-10-07 18:02:46	200	1521
+2026-10-07 18:03:03	200	1492
+2026-10-07 18:03:19	200	1546
+2026-10-07 18:03:36	200	1215
+2026-10-07 18:03:52	200	1579
+2026-10-07 18:04:09	200	1592
+2026-10-07 18:04:26	200	2187
+2026-10-07 18:04:43	200	1001
+2026-10-07 18:04:59	200	1600
+2026-10-07 18:05:16	200	1116
+2026-10-07 18:05:32	200	991
+2026-10-07 18:05:49	200	1986
+2026-10-07 18:06:05	200	1005
+2026-10-07 18:06:21	200	992
+2026-10-07 18:06:37	200	1080
+2026-10-07 18:06:54	200	1066
+2026-10-07 18:07:10	200	1463
+2026-10-07 18:07:27	200	1210
+2026-10-07 18:07:43	200	1408
+2026-10-07 18:07:59	200	1024
+2026-10-07 18:08:16	200	1280
+2026-10-07 18:08:32	200	1300
+2026-10-07 18:08:48	200	992
+2026-10-07 18:09:04	200	954
+2026-10-07 18:09:20	200	987
+2026-10-07 18:09:37	200	1023
+2026-10-07 18:09:53	200	1256
+2026-10-07 18:10:09	200	1386
+2026-10-07 18:10:39	200	13955
+2026-10-07 18:10:55	200	1653
+2026-10-07 18:11:12	200	1824
+2026-10-07 18:11:29	200	1247
+2026-10-07 18:11:45	200	1274
+2026-10-07 18:12:02	200	1539
+2026-10-07 18:12:18	200	1335
+2026-10-07 18:12:35	200	1530
+2026-10-07 18:13:04	200	13994
+2026-10-07 18:13:21	200	1454
+2026-10-07 18:13:37	200	1591
+2026-10-07 18:13:54	200	1030
+2026-10-07 18:14:10	200	829
+2026-10-07 18:14:26	200	1085
+2026-10-07 18:14:42	200	1217
+2026-10-07 18:14:58	200	1134
+2026-10-07 18:15:15	200	934
+2026-10-07 18:15:31	200	1125
+2026-10-07 18:15:47	200	1089
+2026-10-07 18:16:03	200	1026
+2026-10-07 18:16:20	200	1488
+2026-10-07 18:16:36	200	1477
+2026-10-07 18:16:53	200	1367
+2026-10-07 18:17:10	200	1488
+2026-10-07 18:17:26	200	1003
+2026-10-07 18:17:42	200	1038
+2026-10-07 18:17:58	200	981
+2026-10-07 18:18:15	200	1471
+2026-10-07 18:18:31	200	1255
+2026-10-07 18:18:47	200	1233
+2026-10-07 18:19:04	200	1439
+2026-10-07 18:19:20	200	1008
+2026-10-07 18:19:36	200	1023
+2026-10-07 18:19:52	200	1049
+2026-10-07 18:20:10	200	2696
+2026-10-07 18:20:26	200	985
+2026-10-07 18:20:56	200	14428
+2026-10-07 18:21:13	200	1632
+2026-10-07 18:21:30	200	1731
+2026-10-07 18:21:46	200	1160
+2026-10-07 18:22:03	200	1462
+2026-10-07 18:22:19	200	1455
+2026-10-07 18:22:48	200	14144
+2026-10-07 18:23:05	200	1596
+2026-10-07 18:23:21	200	1055
+2026-10-07 18:23:38	200	987
+2026-10-07 18:23:54	200	1048
+2026-10-07 18:24:10	200	940
+2026-10-07 18:24:26	200	1256
+2026-10-07 18:24:44	200	2653
+2026-10-07 18:25:01	200	1705
+2026-10-07 18:25:17	200	1408
+2026-10-07 18:25:34	200	1557
+2026-10-07 18:25:51	200	1660
+2026-10-07 18:26:07	200	1005
+2026-10-07 18:26:23	200	1015
+2026-10-07 18:26:39	200	1079
+2026-10-07 18:26:56	200	1542
+2026-10-07 18:27:13	200	1534
+2026-10-07 18:27:29	200	1196
+2026-10-07 18:27:45	200	1163
+2026-10-07 18:28:02	200	1239
+2026-10-07 18:28:18	200	1232
+2026-10-07 18:28:35	200	1560
+2026-10-07 18:28:51	200	1267
+2026-10-07 18:29:08	200	1328
+2026-10-07 18:29:24	200	1070
+2026-10-07 18:29:40	200	1048
+2026-10-07 18:30:09	200	13901
+2026-10-07 18:30:26	200	1257
+2026-10-07 18:30:42	200	1670
+2026-10-07 18:30:59	200	1488
+2026-10-07 18:31:16	200	1716
+2026-10-07 18:31:33	200	1518
+2026-10-07 18:31:49	200	1522
+2026-10-07 18:32:06	200	1537
+2026-10-07 18:32:23	200	1513
+2026-10-07 18:32:39	200	1547
+2026-10-07 18:32:56	200	1237
+2026-10-07 18:33:12	200	1378
+2026-10-07 18:33:29	200	1255
+2026-10-07 18:33:45	200	1212
+2026-10-07 18:34:02	200	2046
+2026-10-07 18:34:19	200	1424
+2026-10-07 18:34:35	200	1406
+2026-10-07 18:34:52	200	1279
+2026-10-07 18:35:08	200	974
+2026-10-07 18:35:24	200	957
+2026-10-07 18:35:40	200	937
+2026-10-07 18:35:56	200	903
+2026-10-07 18:36:12	200	1223
+2026-10-07 18:36:29	200	1456
+2026-10-07 18:36:45	200	1183
+2026-10-07 18:37:01	200	1076
+2026-10-07 18:37:18	200	1182
+2026-10-07 18:37:34	200	937
+2026-10-07 18:37:50	200	1144
+2026-10-07 18:38:06	200	1218
+2026-10-07 18:38:23	200	1185
+2026-10-07 18:38:39	200	1028
+2026-10-07 18:38:55	200	969
+2026-10-07 18:39:11	200	933
+2026-10-07 18:39:28	200	1706
+2026-10-07 18:39:45	200	2392
+2026-10-07 18:40:02	200	1735
+2026-10-07 18:40:31	200	13866
+2026-10-07 18:40:48	200	1531
+2026-10-07 18:41:05	200	1282
+2026-10-07 18:41:34	200	14107
+2026-10-07 18:41:50	200	906
+2026-10-07 18:42:19	200	14242
+2026-10-07 18:42:36	200	1260
+2026-10-07 18:42:52	200	1254
+2026-10-07 18:43:08	200	1260
+2026-10-07 18:43:25	200	1021
+2026-10-07 18:43:41	200	829
+2026-10-07 18:43:57	200	1012
+2026-10-07 18:44:13	200	1613
+2026-10-07 18:44:30	200	1556
+2026-10-07 18:44:47	200	1422
+2026-10-07 18:45:04	200	2419
+2026-10-07 18:45:20	200	978
+2026-10-07 18:45:37	200	1787
+2026-10-07 18:45:53	200	968
+2026-10-07 18:46:10	200	1652
+2026-10-07 18:46:27	200	1504
+2026-10-07 18:46:43	200	944
+2026-10-07 18:46:59	200	1006
+2026-10-07 18:47:15	200	968
+2026-10-07 18:47:31	200	963
+2026-10-07 18:47:48	200	1245
+2026-10-07 18:48:04	200	1551
+2026-10-07 18:48:21	200	1194
+2026-10-07 18:48:37	200	941
+2026-10-07 18:48:53	200	1010
+2026-10-07 18:49:09	200	1051
+2026-10-07 18:49:25	200	1205
+2026-10-07 18:49:42	200	1372
+2026-10-07 18:49:58	200	1310
+2026-10-07 18:50:28	200	14115
+2026-10-07 18:50:45	200	2386
+2026-10-07 18:51:02	200	1415
+2026-10-07 18:51:18	200	1195
+2026-10-07 18:51:34	200	1230
+2026-10-07 18:51:51	200	1333
+2026-10-07 18:52:20	200	13900
+2026-10-07 18:52:36	200	1245
+2026-10-07 18:52:53	200	1218
+2026-10-07 18:53:09	200	963
+2026-10-07 18:53:26	200	1529
+2026-10-07 18:53:42	200	1053
+2026-10-07 18:53:58	200	1069
+2026-10-07 18:54:14	200	1012
+2026-10-07 18:54:31	200	1846
+2026-10-07 18:54:48	200	1324
+2026-10-07 18:55:04	200	1550
+2026-10-07 18:55:20	200	1008
+2026-10-07 18:55:37	200	1066
+2026-10-07 18:55:53	200	1065
+2026-10-07 18:56:09	200	1515
+2026-10-07 18:56:26	200	988
+2026-10-07 18:56:42	200	1003
+2026-10-07 18:56:58	200	1077
+2026-10-07 18:57:15	200	2306
+2026-10-07 18:57:33	200	2405
+2026-10-07 18:57:50	200	1549
+2026-10-07 18:58:07	200	2098
+2026-10-07 18:58:23	200	970
+2026-10-07 18:58:39	200	1089
+2026-10-07 18:58:56	200	1596
+2026-10-07 18:59:13	200	1906
+2026-10-07 18:59:29	200	1012
+2026-10-07 18:59:46	200	1588
+2026-10-07 19:00:02	200	1317
+2026-10-07 19:00:20	502	2101
+2026-10-07 19:00:36	200	1627
+2026-10-07 19:00:54	200	2006
+2026-10-07 19:01:23	200	14099
+2026-10-07 19:01:39	200	1599
+2026-10-07 19:01:56	200	1539
+2026-10-07 19:02:26	200	14438
+2026-10-07 19:02:42	200	1264
+2026-10-07 19:03:06	200	8534
+2026-10-07 19:03:22	200	1311
+2026-10-07 19:03:38	200	971
+2026-10-07 19:03:55	200	1676
+2026-10-07 19:04:12	200	1795
+2026-10-07 19:04:29	200	1552
+2026-10-07 19:04:45	200	994
+2026-10-07 19:05:03	200	3017
+2026-10-07 19:05:19	200	1048
+2026-10-07 19:05:36	200	1253
+2026-10-07 19:05:52	200	1607
+2026-10-07 19:06:10	200	2535
+2026-10-07 19:06:26	200	1126
+2026-10-07 19:06:43	200	1116
+2026-10-07 19:06:59	200	1361
+2026-10-07 19:07:16	200	1255
+2026-10-07 19:07:32	200	1161
+2026-10-07 19:07:49	200	2006
+2026-10-07 19:08:06	200	1564
+2026-10-07 19:08:22	200	1161
+2026-10-07 19:08:39	200	1480
+2026-10-07 19:08:55	200	998
+2026-10-07 19:09:11	200	993
+2026-10-07 19:09:27	200	981
+2026-10-07 19:09:44	200	1409
+2026-10-07 19:10:00	200	1522
+2026-10-07 19:10:17	200	1633
+2026-10-07 19:10:46	200	14107
+2026-10-07 19:11:04	200	2563
+

_build/docs_check_zips.py

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+r'''检查两个 zip 里实际发出去的说明文档写了什么。
+
+重点确认三件事：
+  1. 硬编码的作者中转地址（xxmxxs / 192.168.x.x）已经彻底没了
+  2. 「默认不带中转地址、要跨网络得自己部署」这句话真的在文档里
+  3. 版本号是 1.8.2，不是旧的
+'''
+from __future__ import annotations
+
+import re
+import sys
+import zipfile
+from pathlib import Path
+
+ROOT = Path(r"C:\Users\shu\Desktop\deepseekagent\LanRemote")
+AGENT = ROOT / "dist" / "ykxmz-agent-1.8.2.zip"
+SERVER = ROOT / "dist" / "ykxmz-server-1.8.2.zip"
+
+WANT = {
+    "AGENT": [
+        ("README-agent.txt", ["没有内置任何中转地址", "自己部署", "deploy.sh"]),
+        ("BEFORE-INSTALL.txt", ["不带任何中转地址", "deploy.sh", "安卓 7.0"]),
+        ("AFTER-INSTALL.txt", ["中转地址默认为空", "1.8.2"]),
+    ],
+    "SERVER": [
+        ("README-server.txt", ["deploy.sh", "两种协议同时在跑", "边缘缓存"]),
+    ],
+}
+
+BANNED = [b"relay.xxmxxs.top", b"192.168.2.156", b"192.168.10.105"]
+
+# 只扫文档，不扫 .sh / .py —— install.sh 这个名字本身就是脚本文件名，
+# 不是"文档里让用户去跑旧脚本"的证据。
+DOC_SUFFIX = (".txt", ".md")
+
+ok = True
+
+
+def check(name: str, good: bool, detail: str = "") -> None:
+    global ok
+    print("  [%s] %s%s" % ("PASS" if good else "FAIL", name,
+                           ("  " + detail) if detail else ""))
+    if not good:
+        ok = False
+
+
+for label, path in (("AGENT", AGENT), ("SERVER", SERVER)):
+    print("=" * 62)
+    print("  %s  %s" % (label, path.name))
+    print("=" * 62)
+    if not path.is_file():
+        check("%s 存在" % path.name, False)
+        continue
+    with zipfile.ZipFile(path) as z:
+        names = z.namelist()
+        # 1. 全包扫禁用串（只扫文档）
+        hits = []
+        for name in names:
+            if not name.endswith(DOC_SUFFIX):
+                continue
+            blob = z.read(name)
+            for needle in BANNED:
+                if needle in blob:
+                    hits.append("%s 含 %s" % (name, needle.decode().strip()))
+        check("文档里没有硬编码的作者中转地址", not hits, "; ".join(hits[:3]))
+        check("文档里没有让用户跑旧脚本 install.sh", not any(
+            re.search(rb"(sudo\s+)?bash\s+install\.sh", z.read(n))
+            for n in names if n.endswith(DOC_SUFFIX)),
+            "（README-server 里【关于 install.sh】那节只是说明它仍留在包里，"
+            "不是让用户去跑它 —— 那种是允许的）")
+
+        # 2. 关键文档里该有的话
+        for fname, phrases in WANT.get(label, []):
+            match = [n for n in names if n.endswith(fname)]
+            if not match:
+                check("%s 在包里" % fname, False)
+                continue
+            text = z.read(match[0]).decode("utf-8-sig", "replace")
+            for phrase in phrases:
+                check("%s 里有「%s」" % (fname, phrase), phrase in text)
+
+        # 3. 版本号：只看**抬头**那几行。
+        #    正文里的「八、版本记录」本来就该列历史版本（1.7.1 等），
+        #    把那些也算成"过期"是误判。
+        for fname in ("README-agent.txt", "README-server.txt",
+                      "BEFORE-INSTALL.txt", "AFTER-INSTALL.txt"):
+            match = [n for n in names if n.endswith(fname)]
+            if not match:
+                continue
+            text = z.read(match[0]).decode("utf-8-sig", "replace")
+            head = "\n".join(text.splitlines()[:10])
+            stale = re.findall(r"\b1\.[0-7]\.\d+\b", head)
+            check("%s 抬头没有旧版本号" % fname, not stale,
+                  "发现 %s" % set(stale) if stale else "")
+            check("%s 抬头写了 1.8.2" % fname, "1.8.2" in head)
+    print()
+
+print("=" * 62)
+print("  %s" % ("全部通过" if ok else "有失败项"))
+sys.exit(0 if ok else 1)

_build/docs_fix_versions.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+r'''修 README.md 和 docs/ 两份装机文档里过期的版本号。
+
+现状：
+    README.md            三件套文件名 / 编译产物路径写成 1.5.0、1.8.0
+    BEFORE-INSTALL.txt   抬头和落款写成 1.7.1
+    AFTER-INSTALL.txt    抬头 / 版本记录 / 落款写成 1.7.1
+
+目标版本：1.8.2（和 relay.py / AndroidManifest / installer 一致）
+
+只改版本号本身，不动措辞 —— 措辞的修改用 edit 工具单独做，
+这样每一步都能看清楚改了什么。
+'''
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+ROOT = Path(r"C:\Users\shu\Desktop\deepseekagent\LanRemote")
+TARGET = "1.8.2"
+
+FILES = [
+    "README.md",
+    "docs/BEFORE-INSTALL.txt",
+    "docs/AFTER-INSTALL.txt",
+]
+
+# 只替换这些"产品版本号"形态，避免误伤日期、端口号之类：
+#   ykxmz-xxx-1.5.0.zip / ykxmz-watch-1.5.0.apk / 版本：1.7.1 / 软件：ykxmz 1.7.1
+PATTERNS = [
+    # 文件名里的版本：ykxmz-agent-1.5.0.zip、ykxmz-watch-1.8.0.apk
+    (re.compile(r"(ykxmz-[a-z]+-)\d+\.\d+\.\d+"), r"\g<1>" + TARGET),
+    # 抬头/落款：版本：1.7.1 / 软件：ykxmz 1.7.1
+    (re.compile(r"(版本[：:]\s*)\d+\.\d+\.\d+"), r"\g<1>" + TARGET),
+    (re.compile(r"(软件[：:]\s*ykxmz\s*)\d+\.\d+\.\d+"), r"\g<1>" + TARGET),
+    # 编译产物注释：# 产物：dist\ykxmz-watch-1.5.0.apk（上面已覆盖）
+]
+
+
+def main() -> int:
+    print("  目标版本 %s" % TARGET)
+    print()
+    total = 0
+    for rel in FILES:
+        path = ROOT / rel
+        if not path.is_file():
+            print("  [跳过] %s 不存在" % rel)
+            continue
+        raw = path.read_bytes()
+        bom = raw.startswith(b"\xef\xbb\xbf")
+        text = raw.decode("utf-8-sig")
+        before = text
+        hits = []
+        for pattern, repl in PATTERNS:
+            for match in pattern.finditer(text):
+                hits.append(match.group(0).strip())
+            text = pattern.sub(repl, text)
+        if text != before:
+            data = text.encode("utf-8")
+            if bom:
+                data = b"\xef\xbb\xbf" + data
+            path.write_bytes(data)
+            print("  %s  改了 %d 处" % (rel, len(hits)))
+            for h in hits:
+                print("      %s" % h)
+            total += len(hits)
+        else:
+            print("  %s  没有需要改的版本号" % rel)
+
+    print()
+    print("  共改 %d 处" % total)
+
+    # 复核：看还有没有残留的旧版本号
+    print()
+    print("  残留检查:")
+    stale = re.compile(r"\b1\.[0-7]\.\d+\b")
+    for rel in FILES:
+        path = ROOT / rel
+        if not path.is_file():
+            continue
+        for i, line in enumerate(
+                path.read_text(encoding="utf-8-sig").splitlines(), 1):
+            for m in stale.finditer(line):
+                print("    ! %s:%d  %s" % (rel, i, line.strip()[:80]))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/dump_assets.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+r'''列出两个平台发行版的全部附件（含 ID），并试删一个看接口通不通。'''
+from __future__ import annotations
+
+import json
+import sys
+import urllib.error
+import urllib.request
+from collections import defaultdict
+from pathlib import Path
+
+ROOT = Path(r"C:\Users\shu\Desktop\deepseekagent\LanRemote")
+GT = (ROOT / "_build" / ".gitee_token").read_text(encoding="utf-8").strip()
+ET = (Path.home() / ".ykxmz" / "ezhub_token").read_text(
+    encoding="utf-8").strip()
+TAG = "v1.8.0"
+
+
+def get(url: str, token: str, kind: str):
+    headers = {"User-Agent": "ykxmz"}
+    if kind == "gitee":
+        sep = "&" if "?" in url else "?"
+        url = url + sep + "access_token=" + token
+    else:
+        headers["Authorization"] = "token " + token
+    with urllib.request.urlopen(
+            urllib.request.Request(url, headers=headers), timeout=60) as r:
+        return json.loads(r.read().decode("utf-8", "replace"))
+
+
+def dump(name: str, url: str, token: str, kind: str) -> None:
+    print("  ═══ %s ═══" % name)
+    try:
+        rel = get(url, token, kind)
+    except Exception as exc:                          # noqa: BLE001
+        print("    查询失败: %s" % exc)
+        return
+    rid = rel.get("id")
+    print("    release id = %s" % rid)
+    assets = (rel.get("assets") or rel.get("attach_files") or [])
+    print("    附件 %d 个:" % len(assets))
+    groups = defaultdict(list)
+    for a in assets:
+        aname = a.get("name") or a.get("filename") or "?"
+        aid = a.get("id")
+        when = a.get("created_at") or a.get("created_at") or ""
+        size = a.get("size") or 0
+        groups[aname].append((aid, when, size))
+        print("      id=%-10s %-32s %8.2f MB  %s"
+              % (aid, aname, size / 1024 / 1024, str(when)[:19]))
+    print()
+    print("    重复情况:")
+    for aname, items in sorted(groups.items()):
+        if len(items) > 1:
+            print("      %-32s %d 份" % (aname, len(items)))
+    print()
+
+
+def main() -> int:
+    dump("Gitee",
+         "https://gitee.com/api/v5/repos/xmz7891/ykxmz/releases/tags/" + TAG,
+         GT, "gitee")
+    dump("EzHub",
+         "https://git.261826.xyz/api/v1/repos/xmz/ykxmz/releases/tags/" + TAG,
+         ET, "gitea")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/fetch_gitee_notice.py

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+r'''抓 Gitee 在 README 页面上挂的违规公告原文。
+
+== 为什么要抓原文 ==
+
+    网页版 README 页里出现了：
+        「违规信息」2 次
+        「内容可能」2 次
+        「违规」2 次
+        「举报」10 次
+
+但 raw 接口是 451。光看关键词猜没用 —— 要把 Gitee 的**原话**读出来，
+才知道它到底判的是哪一条，才能对症改。
+
+== 抓什么 ==
+
+把「违规信息」「内容可能」附近的 HTML 片段剥掉标签打出来。
+'''
+from __future__ import annotations
+
+import html
+import re
+import sys
+import urllib.error
+import urllib.request
+
+URL = "https://gitee.com/xmz7891/ykxmz/blob/main/README.md"
+
+
+def main() -> int:
+    req = urllib.request.Request(URL)
+    req.add_header("User-Agent",
+                   "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                   "AppleWebKit/537.36 Chrome/120 Safari/537.36")
+    try:
+        with urllib.request.urlopen(req, timeout=30) as r:
+            page = r.read().decode("utf-8", "replace")
+    except urllib.error.HTTPError as exc:
+        print("  ✗ HTTP %s" % exc.code)
+        return 1
+
+    print("  页面 %d 字节" % len(page))
+
+    # 去掉 script/style
+    body = re.sub(r"<script.*?</script>", " ", page, flags=re.S | re.I)
+    body = re.sub(r"<style.*?</style>", " ", body, flags=re.S | re.I)
+
+    print()
+    print("=" * 62)
+    print("  「违规」/「内容可能」附近的原文")
+    print("=" * 62)
+    for kw in ("违规信息", "内容可能", "违规"):
+        for m in re.finditer(kw, body):
+            start = max(0, m.start() - 500)
+            end = min(len(body), m.end() + 500)
+            chunk = body[start:end]
+            chunk = re.sub(r"<[^>]+>", " ", chunk)
+            chunk = html.unescape(chunk)
+            chunk = re.sub(r"\s+", " ", chunk).strip()
+            if len(chunk) > 30:
+                print()
+                print("  【%s】" % kw)
+                print("    ...%s..." % chunk)
+                break   # 每个词只看第一条，免得太长
+
+    print()
+    print("=" * 62)
+    print("  页面里所有提到「审核 / 举报 / 法律」的短句")
+    print("=" * 62)
+    for kw in ("审核", "举报", "法律", "不可用"):
+        seen = set()
+        for m in re.finditer(kw, body):
+            start = max(0, m.start() - 120)
+            end = min(len(body), m.end() + 120)
+            chunk = re.sub(r"<[^>]+>", " ", body[start:end])
+            chunk = html.unescape(chunk)
+            chunk = re.sub(r"\s+", " ", chunk).strip()
+            # 只留信息量够、而且不是重复的
+            key = chunk[:40]
+            if len(chunk) > 25 and key not in seen:
+                seen.add(key)
+                print("  【%s】%s" % (kw, chunk[:180]))
+                if len(seen) >= 2:
+                    break
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

_build/find_css_percent.py

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+r'''找出 SITE_CSS 里没转义的 %（% 格式化会把它们当占位符）。
+
+规则：既然 SITE_CSS 最后要过 `% {...}`，那么**所有字面的百分号**
+都必须写成 %%。CSS 里最常见的漏网之鱼是：
+    width:50%          渐变里的 60% 60%
+    rgba(...) 不会
+'''
+from __future__ import annotations
+
+import ast
+import sys
+from pathlib import Path
+
+SRC = Path(__file__).resolve().parent.parent / "relay" / "landing.py"
+text = SRC.read_text(encoding="utf-8")
+tree = ast.parse(text)
+
+target = None
+for node in ast.walk(tree):
+    if isinstance(node, ast.Assign):
+        for t in node.targets:
+            if isinstance(t, ast.Name) and t.id == "SITE_CSS":
+                target = node.value
+                break
+
+if target is None:
+    print("  找不到 SITE_CSS 赋值")
+    sys.exit(1)
+
+# 第一段是那个大三引号字符串（后面还接了 showcase）
+first = target
+while isinstance(first, ast.BinOp):
+    first = first.left
+if isinstance(first, ast.Constant):
+    css = first.value
+    offset = first.col_offset
+    print("  找到 SITE_CSS 的字面量部分：%d 字符，起始行 %d"
+          % (len(css), first.lineno))
+else:
+    print("  结构不认识：%s" % type(first).__name__)
+    sys.exit(1)
+
+# 逐行找单个 % （不是 %%）
+print()
+print("  ════ 可疑的单 % ════")
+bad = 0
+for i, line in enumerate(css.splitlines(), 1):
+    # 去掉 %(name)s 这类合法占位符，再看还有没有单 %
+    stripped = line
+    import re
+    stripped = re.sub(r"%\([a-zA-Z_]+\)[sd]", "", stripped)
+    # 现在剩下的 % 都必须是 %%
+    for m in re.finditer(r"%(.)", stripped):
+        if m.group(1) != "%":
+            print("    第 %d 行: ...%s..." % (i, line.strip()[:90]))
+            print("            这里有个单 %% 后面跟了 %r" % m.group(1))
+            bad += 1
+            break
+
+if not bad:
+    print("    （没找到）")
+
+# 直接试一下格式化，把出错位置算出来
+print()
+print("  ════ 试格式化 ════")
+try:
+    css % {"BG": "#fff", "SURFACE": "#fafafa", "SURFACE2": "#f5f5f5",
+           "BORDER": "#eee", "TEXT": "#111", "MUTED": "#666",
+           "FAINT": "#999", "ACCENT": "#07e", "ACCENT_DARK": "#06d"}
+    print("    ✓ 能格式化")
+except ValueError as exc:
+    print("    ✗ %s" % exc)
+    # 把出错位置附近打出来
+    import re
+    m = re.search(r"index (\d+)", str(exc))
+    if m:
+        pos = int(m.group(1))
+        lo = max(0, pos - 90)
+        print("      位置 %d 附近：" % pos)
+        print("      ...%s..." % css[lo:pos + 30].replace("\n", "\\n"))

_build/find_css_percent2.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+r'''直接把 SITE_CSS 那段字符串抠出来，报出出错位置附近的内容。'''
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+SRC = Path(__file__).resolve().parent.parent / "relay" / "landing.py"
+lines = SRC.read_text(encoding="utf-8").splitlines()
+
+# 找 SITE_CSS = """ 到对应的 """
+start = None
+for i, line in enumerate(lines):
+    if line.startswith("SITE_CSS = \"\"\""):
+        start = i + 1
+        break
+if start is None:
+    print("  找不到 SITE_CSS")
+    sys.exit(1)
+
+# 找结束的 """
+end = None
+for i in range(start, len(lines)):
+    if lines[i].startswith('""" %'):
+        end = i
+        break
+if end is None:
+    print("  找不到结束")
+    sys.exit(1)
+
+css = "\n".join(lines[start:end])
+print("  SITE_CSS 字面量: 第 %d~%d 行，共 %d 字符" % (start + 1, end, len(css)))
+
+# 试格式化
+PLACE = {"BG": "#fff", "SURFACE": "#fafafa", "SURFACE2": "#f5f5f5",
+         "BORDER": "#eee", "TEXT": "#111", "MUTED": "#666",
+         "FAINT": "#999", "ACCENT": "#07e", "ACCENT_DARK": "#06d"}
+try:
+    css % PLACE
+    print("  ✓ 能格式化 —— 那问题在别处")
+except ValueError as exc:
+    print("  ✗ %s" % exc)
+    m = re.search(r"index (\d+)", str(exc))
+    if m:
+        pos = int(m.group(1))
+        lo = max(0, pos - 120)
+        seg = css[lo:pos + 40]
+        print()
+        print("  ════ 出错位置 %d 附近 ════" % pos)
+        # 算出这是第几行
+        line_no = css[:pos].count("\n") + start + 1
+        print("  （大约在第 %d 行）" % line_no)
+        print()
+        for k, seg_line in enumerate(seg.split("\n")):
+            mark = "  <<<<" if k == seg.count("\n") - 1 or (lo + sum(len(x) + 1 for x in seg.split("\n")[:k]) <= pos < lo + sum(len(x) + 1 for x in seg.split("\n")[:k + 1])) else ""
+            print("    %s%s" % (seg_line, mark))
+
+# 另外全文列一遍「单 % 后跟非 % 非 ( 的地方」
+print()
+print("  ════ CSS 里的单 % （排除 %(name)s 和 %% ）════")
+found = 0
+for i, line in enumerate(css.splitlines(), start + 1):
+    tmp = re.sub(r"%\([a-zA-Z_]+\)[sd]", "", line)
+    for m in re.finditer(r"%(.)", tmp):
+        if m.group(1) != "%":
+            print("    第 %d 行: %s" % (i, line.strip()[:100]))
+            found += 1
+            break
+if not found:
+    print("    （没找到）")