mihomo-cli 3.6.0 → 3.7.0

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## [3.7.0] - 2026-08-22
+
+### 修复
+
+- **错误响应体绕过大小上限，可致 OOM** - `!response.ok` 分支直接 `await response.json()`，不经流式大小检查。实测 60MB 错误体使客户端 RSS 增长 303MB——攻击者只需返回非 2xx 即可绕过 50MB 防护。现错误体限量 64KB 读取（仅用于诊断），修后 RSS 增长 9MB
+- **机场返回错误 JSON 会覆盖磁盘上可用的订阅** - 下载后只要内容能解析成对象就原子覆盖写盘。机场返回 `{"error":"quota exceeded"}` 之类响应时报「已更新 (0 节点)」，把原本可用的订阅**不可恢复地覆盖**，随后 mihomo 带零节点启动导致断网；且这在 `start` 的自动更新路径上，用户无操作即触发。现写盘前要求 `proxies`/`proxy-groups`/`proxy-providers` 至少其一非空，并提取服务端错误信息作为提示
+- **`ps` 输出截断致测速实例泄漏并占用端口** - `isProcessCommandMatching` 未带 `-ww`，BSD/macOS 的 `ps` 即使 stdout 非终端也把 command 列截断到 79 列。测速实例的匹配串（`test/runtime/config.yaml`）起始偏移随用户名增长（`alice` 为 80、`jonathan.smith` 为 98），常见家目录下均越界 → 匹配恒失败 → `stopTestInstance` 跳过 SIGKILL 却仍删 pid 文件，内核残留占着 27890/29090 且再无记录，下次 `sub test` 直接启动失败
+- **`sub add` 失败时劫持当前活跃订阅** - `setDefaultSubscription` 在下载之前执行，回滚时 `removeSubscription` 把活跃订阅落到列表首项而非用户原选择。复现：活跃为 `work`、列表为 `[airport-a, work]`，添加一个不可达 URL 失败后活跃变成 `airport-a`，下次 `start` 静默连错机场。现切换移到下载成功之后
+- **`MIHOMO_CLI_DAEMON_LABEL` 未校验导致 root 任意路径写** - 该值经 `path.join` 拼成 plist 路径后，是 `sudo install -m 644 -o root` 的写入目标与 `sudo rm -f` 的删除目标，而 `path.join` 会折叠 `..`（`../../etc/sudoers.d/evil` → `/etc/sudoers.d/evil.plist`），内容还部分可控。现加字符集校验：非法值回退默认标签，并在 `enableDaemon`/`disableDaemon` 入口报错
+- **覆写注入节点的 `exclude-filter` 误排除同前缀节点** - mihomo 的 `exclude-filter` 是无锚点正则搜索。注入名为 `HK` 的节点后，订阅里的 `HK-01`/`HK-02` 全被踢出 `include-all` 分组。现改为 `^(?:...)$` 整名锚定
+- **覆写 YAML 笔误抛裸 `TypeError` 并打印堆栈** - `validateConfig` 的类型断言无校验，四种常见笔误会崩溃：`proxies` 含空列表项、`rules` 漏写 `-` 成标量、`proxy-groups` 写成映射、`rules` 含非字符串。用户配置错误被当成程序 bug。现全部转为带修正提示的 `CliError`
+- **`~key`/`+key` 作用于非数组时静默损坏配置** - 静默包成单元素数组：`~dns: {enable: true}` 把映射 `dns` 变成 `[{enable: true}]` 并丢掉原有字段，而 mihomo 要求 `dns` 是映射；`log-level+: debug` → `["debug"]` 同理。现报错并提示改用 `key!` 或直接写 `key`；目标不存在时仍放行（新增数组的正常用法）
+- **`maskUrl` 逗号切分致 token 明文泄漏** - 无条件按逗号切分，`?nodes=us,hk&token=SECRET` 被劈开后两段都识别不出 token 参数，密钥明文输出。同一根因还让 query 含逗号的合法单 URL（`?flag=clash,meta`）被误判多源、`sub add` 报「无效的 URL」而无法添加。现统一判据为「切分后每段都是合法 http(s) URL 且不止一段」
+- **`settings.json` 为合法 JSON 但非对象时绕过损坏恢复** - `null`/`[]`/`123`/`"hi"` 都直接进缓存，不备份不告警：`null` 让 `getSubscriptions()` 抛裸 `TypeError` 且缓存判定恒失效，字符串被展开成 `{"0":"h","1":"i",...}`。现一并走备份+回退分支
+- **`subscriptions` 非数组时被按字符展开** - 手改成 `"oops"` 后 `addSubscription` 写出 `["o","o","p","s",{...}]` 且不报错。现在唯一读取入口 `getSubscriptions()` 收口校验，并滤掉缺 name/url 的残缺条目
+- **`reset` 忽略停止进程的结果** - root 实例（TUN）下走 `sudo pkill`，用户取消密码时失败的 pid 被静默丢弃，仍继续删除数据，留下孤儿 root 进程跑在已删配置上。现删数据前复查并中止
+- **`reset --full` 残留含密钥的备份文件** - `settings.json.bak`（损坏恢复时生成）带 `controller_secret` 与订阅 token 明文留下，与「已重置: 设置」矛盾。现纳入删除路径
+- **`reset` 结果依赖参数顺序** - `subs` 目标的后置钩子会重建 `settings.json`，故 `reset settings subs` 留下 `{}` 而 `reset subs settings` 才真删。现按注册表顺序执行
+- **`match` 的订阅名匹配与 `sub use` 口径不一致** - `sub use home` 能切到订阅 `Home`（模糊匹配大小写不敏感），但 `match: {subscription: home}` 精确比对匹配不上。现统一为大小写不敏感
+- **`parseIntArg` 接受危险值** - 无范围校验：`-j 0` 让测速起 0 个 worker、结果全空洞、被报成「所有节点失败」（伪造结果）；`-t 5s` 静默取 5ms 让全部节点超时。现非正整数一律报错，并把 `test`/`clean` 的参数校验移到运行状态检查之前
+- **合并订阅的错误指向被连带取消的 URL** - 任一 URL 失败即中断其余请求，按顺序取第一个错误报出的往往是被取消的那条，真正的 403/token 过期被隐藏。现优先报非取消类错误
+- **`dir` 子命令的错误绕过统一渲染** - `cmdDirectory` 用 `void` 丢弃 async 分发的 Promise，`dir open <未知目标>` 抛的错误退化成「未处理的 Promise 拒绝」，丢掉标签颜色与可用目标列表
+- **`ow`/`dir` 未知子命令静默回落** - `ow onn` 静默打印列表且退出码 0（对比 `sub adz` 会报错并给纠错建议）。现补齐纠错提示
+- **测速实例的 pid 记录时机存在泄漏窗口** - spawn 与写 pid 文件之间被 Ctrl+C 中断时，只认 pid 文件的清理逻辑会漏掉 detached 子进程。现增加内存记录作为第二来源
+- **`reset` 保活取消路径退出码为 0** - `console.error` + `return` 使「重置中止」被脚本误判成功，且绕过统一渲染
+- **`mihomo on`/`off` 丢弃启动选项** - 唯二不透传后续参数的快捷命令，`mihomo on -s` 静默吞掉 `-s`，而 README 声明其与 `ow on` 等价
+- **`restartDaemon` 抛裸 `Error`** - 最后一处未迁移的数据层预期错误
+
+### 新增
+
+- **平台守卫** - `package.json` 声明 `"os": ["darwin"]`，`main()` 开头校验平台（豁免 `help`/`version`，`MIHOMO_CLI_ALLOW_ANY_PLATFORM=1` 为开发逃生阀）。此前非 macOS 上是「部分成功」：`status`/`sub` 看着正常，`daemon on` 输完 root 密码才撞 `/Library/LaunchDaemons`，`ui` 报告成功却什么都没打开（`open` 命令缺失被吞掉，且 Debian 的 `open` 指向 `run-mailcap` 会把 URL 当附件处理）。守卫先于目录创建，避免在不支持的平台留下数据目录
+- **`sub remove` 模糊匹配需确认** - 精确名称直接删除；模糊命中时展示完整名称并要求确认（`-y`/`--yes` 跳过）。此前 `sub remove air` 会无提示删掉 `production-airport`
+- **`subs` 别名** - 与 `directory` 的 `dirs` 对称，落地命名规范的「简写复数」档
+- **GitHub Actions CI** - 在 `macos-latest` 上跑 typecheck / lint / test / build
+- **`prepublishOnly` 钩子** - `dist/` 被 gitignore 且此前无发布钩子，漏跑构建即发布陈旧或缺失产物
+
+### 变更
+
+- **破坏性操作在非交互环境报错而非静默取消** - `reset`（无 `-y`）与 `sub remove`（模糊匹配）在管道/CI 下此前打印「已取消」并退出 0，脚本会误判操作已完成。现报错退出 1 并提示加 `-y` 或用完整名称
+- **`confirmPrompt` 收敛到 `commands/shared.ts`** 并增加 TTY 守卫（此前在非交互环境会挂住等输入）
+
+### 内部
+
+- **单测从 55 增至 101** - 新增覆盖：配置形态校验、`exclude-filter` 锚定、覆写数组语义误用、`match` 大小写、`parseIntArg` 边界、多源 URL 逗号判据
+- **`CODE_REVIEW.md` 重写** - 上一轮（v2.9.x 基线）的「仍待处理」清单已逐项复核：#12/#14 实际已修复，#10 的后果比原描述严重（是 token 泄漏而非仅显示切碎），#17 的建议不可行——上游 v1.19.30 的 127 个资产中零 checksum 文件，故真实缺口是下载地址的 host 未钉死。新增 9 项待处理（tar symlink 致任意文件 chmod 755、热重载信任任意 9090 响应、`Subscription-Userinfo` 边界等）
+- **`README.md` / `CLAUDE.md` 校正** - 平台说明从「Windows / Linux 正在适配中」改为「仅支持 macOS」（此前无对应代码）；覆写实为默认启用（此前文档教用户先 `ow on`）；`log -o` 是系统默认程序而非编辑器；补齐 `logs current`、长选项、`reset`/`dir open` 完整目标列表、分阶段调试文件；新增「选项写法」「数据保护」两节
+
 ## [3.6.0] - 2026-08-15
 
 ### 修复

package/README.md

@@ -1,12 +1,14 @@
 # mihomo-cli
 
-一个基于命令行的 mihomo (Clash.Meta) 客户端，专为 macOS 设计。Windows / Linux 正在适配中，敬请期待。
+一个基于命令行的 mihomo (Clash.Meta) 客户端，**仅支持 macOS**。
+
+进程保活依赖 launchd、目录/UI 打开依赖 `open`、提权依赖 `sudo`，均无其他平台实现，故在非 macOS 上会直接报错退出而非部分可用。Windows / Linux 适配尚无时间表。
 
 ## 功能特性
 
 - 🌐 **订阅管理** - 添加/更新订阅，支持流量统计和到期时间显示
 - 🔄 **自动更新** - 启动时自动检查并更新过期订阅
-- 🔍 **模糊匹配** - `sub use` / `sub web` 支持订阅名称模糊匹配
+- 🔍 **模糊匹配** - `sub use` / `web` / `update` / `remove` / `test` / `clean` 均支持订阅名称模糊匹配（大小写不敏感）
 - 🧹 **节点测速清理** - `test` 快速测试、`clean` 清理并重启；`sub test/clean` 独立进程测试任意订阅
 - 📝 **覆写配置** - 在订阅基础上进行自定义覆写，支持强制覆盖、数组合并、按 name 就地 patch、按订阅限定作用域
 - 🔄 **智能重启** - `sub use` 切换订阅、`ow on/off` 切换覆写后自动重启
@@ -88,8 +90,10 @@ mihomo ui yacd     # YACD
 | `mihomo start [tun\|mixed]` | 启动/重启/切换代理模式（`-s` 跳过更新，`-u` 更新超时，`-r` 清理轮次，`-t` 超时，`-j` 并发，`--no-clean` 跳过启动自动清理） |
 | `mihomo stop`               | 停止代理                                                                     |
 | `mihomo status`             | 查看运行状态（含订阅流量、到期时间）                                         |
-| `mihomo log`                | 实时查看日志 (`-o` 用系统编辑器打开)                                         |
+| `mihomo log`                | 实时查看日志 (`-o` 用系统默认程序打开)                                       |
 | `mihomo logs`               | 列出所有日志（当前 + 历史归档）                                              |
+| `mihomo logs current`       | 查看当前日志（等同 `logs 0`）                                                |
+| `mihomo logs <名称/子串>`   | 按文件名或子串查看指定归档日志                                               |
 | `mihomo logs <编号>`        | 查看指定日志（`0`=当前日志，`1+`=归档日志，支持 `-n N` 指定行数、`-o` 打开） |
 
 ### 订阅管理
@@ -101,10 +105,10 @@ mihomo ui yacd     # YACD
 | `mihomo sub add <url> [name]` | 添加订阅并自动切换（支持逗号分隔多 URL 合并，名称不可重复） |
 | `mihomo sub update`           | 更新所有订阅                           |
 | `mihomo sub update <name>`    | 更新指定订阅（支持模糊匹配）           |
-| `mihomo sub remove <name>`    | 删除订阅（支持模糊匹配）               |
-| `mihomo sub web [name]`       | 打开订阅页面（无参打开默认）           |
+| `mihomo sub remove <name>`    | 删除订阅（别名 `rm`/`delete`；精确名直接删，模糊匹配需确认，`-y` 跳过） |
+| `mihomo sub web [name]`       | 打开订阅页面（别名 `open`，无参打开默认，支持模糊匹配） |
 | `mihomo sub test [name]`      | 测试节点连通性（独立隔离实例，无需运行主实例，`-t` 超时，`-j` 并发） |
-| `mihomo sub clean [name]`     | 测速并清理失败节点（独立实例，不动主实例，`-r` 轮数，默认2）|
+| `mihomo sub clean [name]`     | 测速并清理失败节点（独立实例，不动主实例，`-r` 轮数默认 2，`-t` 超时，`-j` 并发） |
 | `mihomo test`                 | 测试当前节点（经运行中的主实例，`-t` 超时，`-j` 并发） |
 | `mihomo clean`                | 清理失败节点并重启（经主实例，`-t` 超时，`-j` 并发，`-r` 轮数） |
 
@@ -112,9 +116,9 @@ mihomo ui yacd     # YACD
 
 | 命令                           | 说明                       |
 | ------------------------------ | -------------------------- |
-| `mihomo ow` / `mihomo ow list` | 查看覆写配置状态和文件列表 |
-| `mihomo ow on`                 | 启用覆写配置（自动重启）   |
-| `mihomo ow off`                | 禁用覆写配置（自动重启）   |
+| `mihomo ow` / `mihomo ow list`   | 查看覆写配置状态和文件列表（别名 `enable`/`disable` 亦可用于开关） |
+| `mihomo ow on`                   | 启用覆写配置（**默认已启用**，自动重启）                          |
+| `mihomo ow off`                  | 禁用覆写配置（自动重启）                                          |
 
 ### 其他命令
 
@@ -125,8 +129,8 @@ mihomo ui yacd     # YACD
 | `mihomo update`                   | 更新 mihomo-cli（先查 npm 最新版，已是最新则跳过重装）              |
 | `mihomo ui [zash\|dash\|yacd]`    | 打开 Web UI                                                         |
 | `mihomo dir`                      | 显示数据目录位置                                                    |
-| `mihomo dir open [target]`        | 打开指定目录（`root`, `subs`, `logs`, `kernel` 等）                 |
-| `mihomo reset [目标...] [--full] [-y]` | 重置用户数据（可用目标：`subs`, `logs`, `kernel`, `overwrites` 等；`--full` 删全部，`-y` 跳过确认） |
+| `mihomo dir open [target]`        | 打开指定目录（`root`, `subs`, `logs`, `data`, `runtime`, `kernel`）  |
+| `mihomo reset [目标...] [--full] [-y]` | 重置用户数据（可用目标：`subs`, `logs`, `data`, `runtime`, `settings`, `kernel`, `overwrites`, `daemon`；`--full` 删全部，`-y` 跳过确认） |
 | `mihomo version`                  | 显示版本信息                                                        |
 | `mihomo help`                     | 显示帮助信息                                                        |
 
@@ -139,6 +143,8 @@ mihomo ui yacd     # YACD
 - `mhm`
 - `mh`
 
+子命令组亦有别名：`subscription` = `sub`/`subs`/`subscriptions`，`directory` = `dir`/`dirs`/`directories`，`overwrite` = `ow`
+
 ### 快捷命令
 
 常用操作的快捷方式：
@@ -235,6 +241,35 @@ mihomo kernel --mirror-all hk.gh-proxy.org
 - 同一订阅 12 小时内只自动清理一次（冷却记录在订阅缓存），避免每次启动都全量测速
 - `--no-clean` 可跳过；随时可用 `mihomo clean` / `mihomo sub clean` 手动清理
 
+## 选项写法
+
+带值选项支持三种等价写法，长短选项对应关系：
+
+| 短 | 长 | 用途 | 默认 |
+| --- | --- | --- | --- |
+| `-t` | `--timeout` | 测速超时（ms） | 2000 |
+| `-j` | `--concurrency` | 测速并发数 | 100 |
+| `-r` | `--rounds` | 清理时失败节点重试轮数 | 2 |
+| `-u` | `--update-timeout` | 启动时自动更新订阅超时（ms） | 10000 |
+| `-n` | `--lines` | 日志显示行数 | 100 |
+
+```bash
+mihomo test -t 3000          # 短选项 + 空格
+mihomo test --timeout 3000   # 长选项 + 空格
+mihomo test --timeout=3000   # 长选项 + 等号
+```
+
+布尔开关：`-s`（跳过订阅更新）、`--no-update`、`--no-clean`、`-y`/`--yes`（跳过确认）、`-o`（用系统默认程序打开）。
+
+上述数值选项只接受 **>= 1 的整数**，非法值（`0`、负数、`5s`、`abc`）会直接报错而非静默取默认值——避免 `-j 0` 之类静默产出"全部节点失败"的假结果。
+
+## 数据保护
+
+- **订阅内容校验**：下载到的内容必须含 `proxies` / `proxy-groups` / `proxy-providers` 之一才写盘。机场返回配额或错误 JSON（如 `{"error":"quota exceeded"}`）时报错并**保留磁盘上原有的可用配置**，不会被覆盖
+- **`sub add` 失败回滚**：下载失败时移除半成品订阅，且不改动当前活跃订阅
+- **`settings.json` 损坏恢复**：格式损坏（含合法 JSON 但非对象的情况）时自动备份为 `.bak` 并回退默认设置
+- **`reset` 停止确认**：需要停止进程的重置会先确认进程真的已终止，未能停止时中止重置而非留下孤儿进程跑在已删配置上
+
 ## 数据目录
 
 用户数据存储位置（与安装位置分离，更新不丢失）：
@@ -255,7 +290,10 @@ mihomo kernel --mirror-all hk.gh-proxy.org
 ├── data/                 # mihomo 运行数据（GeoIP 等，由内核自行管理）
 └── runtime/              # 运行时临时文件（stop 自动清除）
     ├── pid               # 进程 PID
-    └── config.yaml       # 运行时生成的配置
+    ├── config.yaml       # 运行时生成的配置
+    ├── 1.subscription.yaml   # 分阶段调试：订阅原始配置
+    ├── 2.overwrite.yaml      # 分阶段调试：应用覆写后
+    └── 3.system.yaml         # 分阶段调试：合并系统配置后
 ```
 
 可通过环境变量 `MIHOMO_CLI_DIR` 自定义数据目录位置。
@@ -270,7 +308,7 @@ mihomo kernel --mirror-all hk.gh-proxy.org
    - `overwrite.yaml` — 主覆写文件
    - `overwrite.dns.yaml` — 按功能拆分的扩展文件（`overwrite.*.yaml` 格式）
 2. `overwrite.yaml` 始终最先加载，扩展文件按文件名排序加载
-3. 使用 `mihomo ow on` 启用覆写配置（会自动重启）
+3. 覆写**默认即启用**，放好文件后重启生效（`mihomo start`）；如曾 `ow off` 禁用过，用 `mihomo ow on` 重新启用（会自动重启）
 
 ### 特殊语法
 
@@ -286,14 +324,16 @@ mihomo kernel --mirror-all hk.gh-proxy.org
 
 `~key` 用于**只修改数组里某一个元素的部分字段**，而不动其余元素、也不必复制整个元素。以 `name` 为主键匹配：命中同名元素则深度合并该元素，找不到则追加。典型用途：修改订阅下发的某个 `proxy-group` 的字段（如默认选中的节点），订阅更新后依然生效。
 
+> `~key` / `+key` / `key+` 都是**数组语义**：若目标键已存在且不是数组（如 `~dns` 作用于映射、`log-level+` 作用于字符串），会直接报错而非静默包成单元素数组——后者会丢掉原有字段并生成 mihomo 无法解析的配置。要覆盖非数组值请用 `key!`（强制覆盖）或直接写 `key`（深度合并）。
+
 ### 作用域限定（match）
 
 在覆写文件顶部加 `match:` 块，可让该文件**只对指定订阅生效**（无 `match` 则全局生效）。所列条件需全部满足（AND），条件值为数组时其内部为 OR：
 
 | 匹配键        | 作用                          |
 | ------------- | ----------------------------- |
-| `subscription` | 按订阅名精确匹配              |
-| `url-domain`   | 按订阅 URL 的 hostname 后缀匹配 |
+| `subscription` | 按订阅名匹配（大小写不敏感，与 `sub use` 口径一致） |
+| `url-domain`   | 按订阅 URL 的 hostname 后缀匹配（大小写不敏感） |
 
 ### 示例
 
@@ -364,7 +404,7 @@ sudo pkill -9 mihomo
 
 ## 安全特性
 
-- **URL 脱敏**：订阅 URL 中的 token、key、password 等敏感参数（含 query、userinfo 及路径型令牌）自动替换为 `***`
+- **URL 脱敏**：订阅 URL 中的 token、key、password 等敏感参数（含 query、userinfo 及路径型令牌）自动替换为 `***`。逗号分隔的多源订阅逐段脱敏；query 内含逗号的单条 URL 不会被误拆（否则参数被劈开会导致 token 漏脱敏）
 - **文件权限**：配置文件使用 `0o600` 权限（仅所有者可读可写），目录使用 `0o700` 权限
 - **入站默认关闭**：订阅/覆写未指定时 `allow-lan` 默认 `false`；如需局域网设备连入代理端口，可在订阅或覆写中显式开启
 - **信号处理**：优雅处理 SIGINT/SIGTERM 信号

package/dist/index.js

@@ -3067,7 +3067,14 @@ var UI_URLS = {
   dash: "https://metacubex.github.io/metacubexd",
   yacd: "https://yacd.metacubex.one"
 };
-var LAUNCH_DAEMON_LABEL = process.env.MIHOMO_CLI_DAEMON_LABEL || "com.mihomo-cli.daemon";
+var DEFAULT_DAEMON_LABEL = "com.mihomo-cli.daemon";
+var DAEMON_LABEL_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function isValidDaemonLabel(label) {
+  return DAEMON_LABEL_RE.test(label) && !label.includes("..");
+}
+var RAW_DAEMON_LABEL = process.env.MIHOMO_CLI_DAEMON_LABEL;
+var RAW_DAEMON_LABEL_INPUT = RAW_DAEMON_LABEL;
+var LAUNCH_DAEMON_LABEL = RAW_DAEMON_LABEL && isValidDaemonLabel(RAW_DAEMON_LABEL) ? RAW_DAEMON_LABEL : DEFAULT_DAEMON_LABEL;
 var CONTROLLER_PORT = 9090;
 var CONTROLLER_ADDR = `127.0.0.1:${CONTROLLER_PORT}`;
 var CONTROLLER_BASE_URL = `http://${CONTROLLER_ADDR}`;
@@ -3120,6 +3127,41 @@ var AUTO_CLEAN_THRESHOLD = 100;
 var AUTO_CLEAN_THRESHOLD_GITHUB = 50;
 var AUTO_CLEAN_COOLDOWN_HOURS = 12;
 
+// src/errors.ts
+var TimeoutError = class extends Error {
+  constructor() {
+    super("timeout");
+    this.name = "TimeoutError";
+  }
+};
+var CliError = class extends Error {
+  hint;
+  label;
+  exitCode;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "CliError";
+    this.label = options.label ?? "\u9519\u8BEF";
+    this.hint = options.hint === void 0 ? [] : Array.isArray(options.hint) ? options.hint : [options.hint];
+    this.exitCode = options.exitCode ?? 1;
+  }
+};
+function withTimeout(promise, ms) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new TimeoutError()), ms);
+    promise.then(
+      (v) => {
+        clearTimeout(timer);
+        resolve(v);
+      },
+      (e) => {
+        clearTimeout(timer);
+        reject(e);
+      }
+    );
+  });
+}
+
 // src/overwrite.ts
 import fs3 from "fs";
 import path3 from "path";
@@ -3191,62 +3233,32 @@ function rmrf(dir) {
 // src/settings.ts
 import fs2 from "fs";
 import path2 from "path";
-
-// src/errors.ts
-var TimeoutError = class extends Error {
-  constructor() {
-    super("timeout");
-    this.name = "TimeoutError";
-  }
-};
-var CliError = class extends Error {
-  hint;
-  label;
-  exitCode;
-  constructor(message, options = {}) {
-    super(message);
-    this.name = "CliError";
-    this.label = options.label ?? "\u9519\u8BEF";
-    this.hint = options.hint === void 0 ? [] : Array.isArray(options.hint) ? options.hint : [options.hint];
-    this.exitCode = options.exitCode ?? 1;
-  }
-};
-function withTimeout(promise, ms) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => reject(new TimeoutError()), ms);
-    promise.then(
-      (v) => {
-        clearTimeout(timer);
-        resolve(v);
-      },
-      (e) => {
-        clearTimeout(timer);
-        reject(e);
-      }
-    );
-  });
-}
-
-// src/settings.ts
 var settingsCache = null;
 function readSettings() {
   if (settingsCache !== null) return settingsCache;
   ensureDirs();
   if (fs2.existsSync(PATHS.settingsFile)) {
+    let parsed;
     try {
-      const content = fs2.readFileSync(PATHS.settingsFile, "utf8");
-      settingsCache = JSON.parse(content);
-      return settingsCache;
+      parsed = JSON.parse(fs2.readFileSync(PATHS.settingsFile, "utf8"));
     } catch {
-      try {
-        fs2.copyFileSync(PATHS.settingsFile, `${PATHS.settingsFile}.bak`);
-        console.warn(`\u8B66\u544A: settings.json \u683C\u5F0F\u635F\u574F\uFF0C\u5DF2\u5907\u4EFD\u5230 ${PATHS.settingsFile}.bak\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u8BBE\u7F6E`);
-      } catch {
-        console.warn("\u8B66\u544A: settings.json \u683C\u5F0F\u635F\u574F\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u8BBE\u7F6E");
-      }
-      settingsCache = {};
-      return settingsCache;
+      return recoverCorruptedSettings();
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return recoverCorruptedSettings();
     }
+    settingsCache = parsed;
+    return settingsCache;
+  }
+  settingsCache = {};
+  return settingsCache;
+}
+function recoverCorruptedSettings() {
+  try {
+    fs2.copyFileSync(PATHS.settingsFile, `${PATHS.settingsFile}.bak`);
+    console.warn(`\u8B66\u544A: settings.json \u683C\u5F0F\u635F\u574F\uFF0C\u5DF2\u5907\u4EFD\u5230 ${PATHS.settingsFile}.bak\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u8BBE\u7F6E`);
+  } catch {
+    console.warn("\u8B66\u544A: settings.json \u683C\u5F0F\u635F\u574F\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u8BBE\u7F6E");
   }
   settingsCache = {};
   return settingsCache;
@@ -3265,11 +3277,7 @@ function writeSettings(settings) {
 function invalidateSettingsCache() {
   settingsCache = null;
 }
-function maskUrl(url) {
-  if (!url) return url;
-  if (url.includes(",")) {
-    return url.split(",").map((u) => maskUrl(u.trim())).join(", ");
-  }
+function maskSingleUrl(url) {
   try {
     const parsed = new URL(url);
     const tokenKeys = ["token", "key", "secret", "pass", "password", "auth", "access_token", "api_key"];
@@ -3289,6 +3297,26 @@ function maskUrl(url) {
     return url;
   }
 }
+function looksLikeMultiUrl(url) {
+  if (!url.includes(",")) return false;
+  const parts = url.split(",").map((u) => u.trim()).filter(Boolean);
+  if (parts.length < 2) return false;
+  return parts.every((p) => {
+    try {
+      const u = new URL(p);
+      return u.protocol === "http:" || u.protocol === "https:";
+    } catch {
+      return false;
+    }
+  });
+}
+function maskUrl(url) {
+  if (!url) return url;
+  if (looksLikeMultiUrl(url)) {
+    return url.split(",").map((u) => maskSingleUrl(u.trim())).join(", ");
+  }
+  return maskSingleUrl(url);
+}
 function readSubscriptionCache() {
   ensureDirs();
   if (fs2.existsSync(PATHS.subscriptionsCacheFile)) {
@@ -3318,7 +3346,14 @@ function saveSubscriptionCache(subName, data) {
 }
 function getSubscriptions() {
   const settings = readSettings();
-  return settings.subscriptions || [];
+  const subs = settings.subscriptions;
+  if (!Array.isArray(subs)) {
+    if (subs !== void 0) {
+      console.warn("\u8B66\u544A: settings.json \u7684 subscriptions \u4E0D\u662F\u5217\u8868\uFF0C\u5DF2\u5FFD\u7565\uFF08\u53EF\u7528 mihomo sub add \u91CD\u65B0\u6DFB\u52A0\uFF09");
+    }
+    return [];
+  }
+  return subs.filter((s) => s != null && typeof s === "object" && typeof s.name === "string" && typeof s.url === "string");
 }
 function getSubscriptionsWithCache() {
   const subs = getSubscriptions();
@@ -3337,7 +3372,7 @@ function validateSubscriptionName(name) {
 function addSubscription(url, name = "default") {
   validateSubscriptionName(name);
   const settings = readSettings();
-  const subs = [...settings.subscriptions || []];
+  const subs = [...getSubscriptions()];
   if (subs.some((s) => s.name === name)) {
     throw new CliError(`\u8BA2\u9605 "${name}" \u5DF2\u5B58\u5728\uFF0C\u8BF7\u6362\u4E2A\u540D\u79F0\uFF08mihomo sub add <url> <\u540D\u79F0>\uFF09\uFF0C\u6216\u5148\u5220\u9664\uFF08mihomo sub remove ${name}\uFF09`);
   }
@@ -3350,7 +3385,7 @@ function addSubscription(url, name = "default") {
 }
 function removeSubscription(name) {
   const settings = readSettings();
-  const subs = [...settings.subscriptions || []];
+  const subs = [...getSubscriptions()];
   const idx = subs.findIndex((s) => s.name === name);
   if (idx < 0) return null;
   subs.splice(idx, 1);
@@ -3374,7 +3409,7 @@ function removeSubscription(name) {
 }
 function setDefaultSubscription(name) {
   const settings = readSettings();
-  const subs = settings.subscriptions || [];
+  const subs = getSubscriptions();
   const idx = subs.findIndex((s) => s.name === name);
   if (idx < 0) return false;
   if (settings.active_subscription === name) return true;
@@ -3459,6 +3494,18 @@ function deepMergeWithOverrides(target, override) {
     const { key, forceOverwrite, arrayPrepend, arrayAppend, arrayMergeByName } = parseOverrideKey(rawKey);
     const existingValue = result[key];
     if (arrayMergeByName) {
+      if (existingValue !== void 0 && !Array.isArray(existingValue)) {
+        throw new CliError(
+          `\u8986\u5199\u952E "${rawKey}" \u7684 ~ \u8BED\u4E49\u53EA\u9002\u7528\u4E8E\u6570\u7EC4\uFF0C\u4F46 "${key}" \u5F53\u524D\u662F${existingValue === null ? " null" : typeof existingValue === "object" ? "\u6620\u5C04" : `\u6807\u91CF\uFF08${typeof existingValue}\uFF09`}`,
+          {
+            label: "\u8986\u5199\u914D\u7F6E\u9519\u8BEF",
+            hint: [
+              `~${key} \u7528\u4E8E\u6309 name \u5C31\u5730\u5408\u5E76\u6570\u7EC4\u5143\u7D20\uFF08\u5982 ~proxy-groups\uFF09\u3002`,
+              `\u82E5\u8981\u8986\u76D6\u975E\u6570\u7EC4\u7684 ${key}\uFF0C\u8BF7\u7528 ${key}!\uFF08\u5F3A\u5236\u8986\u76D6\uFF09\u6216\u76F4\u63A5\u5199 ${key}\uFF08\u6DF1\u5EA6\u5408\u5E76\uFF09\u3002`
+            ]
+          }
+        );
+      }
       const existingArr = Array.isArray(existingValue) ? existingValue : [];
       const overrideArr = Array.isArray(value) ? value : [value];
       const merged = [...existingArr];
@@ -3475,6 +3522,15 @@ function deepMergeWithOverrides(target, override) {
       continue;
     }
     if (arrayPrepend || arrayAppend) {
+      if (existingValue !== void 0 && !Array.isArray(existingValue)) {
+        throw new CliError(
+          `\u8986\u5199\u952E "${rawKey}" \u7684\u6570\u7EC4\u62FC\u63A5\u8BED\u4E49\u53EA\u9002\u7528\u4E8E\u6570\u7EC4\uFF0C\u4F46 "${key}" \u5F53\u524D\u662F${existingValue === null ? " null" : typeof existingValue === "object" ? "\u6620\u5C04" : `\u6807\u91CF\uFF08${typeof existingValue}\uFF09`}`,
+          {
+            label: "\u8986\u5199\u914D\u7F6E\u9519\u8BEF",
+            hint: [`+${key} / ${key}+ \u7528\u4E8E\u5411\u6570\u7EC4\u524D\u7F6E/\u8FFD\u52A0\u5143\u7D20\uFF08\u5982 rules+\uFF09\u3002`, `\u82E5\u8981\u66FF\u6362\u975E\u6570\u7EC4\u7684 ${key}\uFF0C\u8BF7\u76F4\u63A5\u5199 ${key}: <\u503C>\u3002`]
+          }
+        );
+      }
       const existingArr = Array.isArray(existingValue) ? existingValue : [];
       const overrideArr = Array.isArray(value) ? value : [value];
       if (arrayPrepend) {
@@ -3537,7 +3593,18 @@ function summarizeMatch(match) {
   return parts.length > 0 ? parts.join(", ") : void 0;
 }
 function splitUrlsLocal(url) {
-  return url.split(",").map((u) => u.trim()).filter(Boolean);
+  const isValidHttp = (u) => {
+    try {
+      const parsed = new URL(u.trim());
+      return parsed.protocol === "http:" || parsed.protocol === "https:";
+    } catch {
+      return false;
+    }
+  };
+  if (!url.includes(",")) return [url.trim()];
+  const parts = url.split(",").map((u) => u.trim()).filter(Boolean);
+  if (parts.length > 1 && parts.every(isValidHttp)) return parts;
+  return [url.trim()];
 }
 function hostMatchesDomain(host, domain) {
   const h = host.toLowerCase();
@@ -3548,7 +3615,9 @@ function matchesScope(match, scope) {
   if (!match) return true;
   if (match.subscription) {
     const names = Array.isArray(match.subscription) ? match.subscription : [match.subscription];
-    if (!scope?.subName || !names.includes(scope.subName)) return false;
+    if (!scope?.subName) return false;
+    const subName = scope.subName.toLowerCase();
+    if (!names.some((n) => n.toLowerCase() === subName)) return false;
   }
   if (match["url-domain"]) {
     const domains = Array.isArray(match["url-domain"]) ? match["url-domain"] : [match["url-domain"]];
@@ -3672,15 +3741,25 @@ function hasFlag(args, short, long) {
 }
 function parseIntArg(args, short, long, defaultValue) {
   if (!args) return defaultValue;
+  const parse = (raw, flag) => {
+    if (!/^\d+$/.test(raw.trim())) {
+      throw new CliError(`\u9009\u9879 ${flag} \u9700\u8981\u6B63\u6574\u6570\uFF0C\u6536\u5230 "${raw}"`, { hint: [`\u4F8B\u5982: ${flag} ${defaultValue}`] });
+    }
+    const val = Number(raw);
+    if (!Number.isSafeInteger(val) || val < 1) {
+      throw new CliError(`\u9009\u9879 ${flag} \u9700\u8981 >= 1 \u7684\u6574\u6570\uFF0C\u6536\u5230 "${raw}"`, { hint: [`\u4F8B\u5982: ${flag} ${defaultValue}`] });
+    }
+    return val;
+  };
   for (let i = 0; i < args.length; i++) {
     if (args[i] === short || args[i] === long) {
       if (i + 1 < args.length) {
-        const val = parseInt(args[i + 1], 10);
-        return Number.isNaN(val) ? defaultValue : val;
+        return parse(args[i + 1], args[i]);
       }
-    } else if (args[i].startsWith(`${long}=`)) {
-      const val = parseInt(args[i].slice(long.length + 1), 10);
-      if (!Number.isNaN(val)) return val;
+      throw new CliError(`\u9009\u9879 ${args[i]} \u7F3A\u5C11\u503C`, { hint: [`\u4F8B\u5982: ${args[i]} ${defaultValue}`] });
+    }
+    if (args[i].startsWith(`${long}=`)) {
+      return parse(args[i].slice(long.length + 1), long);
     }
   }
   return defaultValue;
@@ -3829,7 +3908,7 @@ function excludeOverwriteProxiesFromIncludeAll(config, overwriteFiles) {
   if (injectedNames.length === 0) return;
   const groups = config["proxy-groups"];
   if (!groups) return;
-  const excludePattern = injectedNames.map((n) => escapeRegExp(n)).join("|");
+  const excludePattern = `^(?:${injectedNames.map((n) => escapeRegExp(n)).join("|")})$`;
   for (const group of groups) {
     if (!group["include-all"] && !group["include-all-proxies"]) continue;
     const existing = group["exclude-filter"];
@@ -3864,7 +3943,58 @@ function getRuleTarget(rule) {
   }
   return last;
 }
+function assertConfigShape(config) {
+  const listSections = [
+    { key: "proxies", label: "\u8282\u70B9", needsName: true },
+    { key: "proxy-groups", label: "\u4EE3\u7406\u7EC4", needsName: true },
+    { key: "rules", label: "\u89C4\u5219", needsName: false }
+  ];
+  for (const { key, label, needsName } of listSections) {
+    const value = config[key];
+    if (value === void 0 || value === null) continue;
+    if (!Array.isArray(value)) {
+      throw new CliError(`${key} \u5FC5\u987B\u662F\u5217\u8868\uFF0C\u5F53\u524D\u4E3A ${typeof value === "object" ? "\u6620\u5C04" : typeof value}`, {
+        label: "\u914D\u7F6E\u9519\u8BEF",
+        hint: [
+          `${label}\u6BB5\uFF08${key}\uFF09\u9700\u5199\u6210 YAML \u5217\u8868\uFF0C\u6BCF\u9879\u4EE5 "- " \u5F00\u5934\u3002`,
+          `\u4F8B\u5982: ${key}:`,
+          key === "rules" ? "        - MATCH,DIRECT" : "        - {name: xxx, ...}"
+        ]
+      });
+    }
+    for (let i = 0; i < value.length; i++) {
+      const item = value[i];
+      if (item === null || item === void 0) {
+        throw new CliError(`${key}[${i}] \u4E3A\u7A7A`, {
+          label: "\u914D\u7F6E\u9519\u8BEF",
+          hint: [`${label}\u6BB5\uFF08${key}\uFF09\u7B2C ${i + 1} \u9879\u662F\u7A7A\u503C\uFF0C\u901A\u5E38\u662F\u5217\u8868\u91CC\u7559\u4E86\u7A7A\u7684 "- " \u884C\u3002`]
+        });
+      }
+      if (needsName) {
+        if (typeof item !== "object" || Array.isArray(item)) {
+          throw new CliError(`${key}[${i}] \u5FC5\u987B\u662F\u6620\u5C04`, {
+            label: "\u914D\u7F6E\u9519\u8BEF",
+            hint: [`${label}\u6BB5\uFF08${key}\uFF09\u7B2C ${i + 1} \u9879\u5E94\u4E3A {name: ..., ...} \u5F62\u5F0F\uFF0C\u5F53\u524D\u662F ${Array.isArray(item) ? "\u5217\u8868" : typeof item}\u3002`]
+          });
+        }
+        const name = item.name;
+        if (typeof name !== "string" || name === "") {
+          throw new CliError(`${key}[${i}] \u7F3A\u5C11\u6709\u6548\u7684 name`, {
+            label: "\u914D\u7F6E\u9519\u8BEF",
+            hint: [`${label}\u6BB5\uFF08${key}\uFF09\u7B2C ${i + 1} \u9879\u6CA1\u6709 name \u5B57\u6BB5\uFF08\u6216\u4E3A\u7A7A\uFF09\uFF0Cmihomo \u4F1A\u62D2\u7EDD\u542F\u52A8\u3002`]
+          });
+        }
+      } else if (typeof item !== "string") {
+        throw new CliError(`${key}[${i}] \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`, {
+          label: "\u914D\u7F6E\u9519\u8BEF",
+          hint: [`${label}\u6BB5\uFF08${key}\uFF09\u7B2C ${i + 1} \u9879\u5E94\u4E3A\u5F62\u5982 "MATCH,DIRECT" \u7684\u5B57\u7B26\u4E32\uFF0C\u5F53\u524D\u662F ${typeof item}\u3002`]
+        });
+      }
+    }
+  }
+}
 function validateConfig(config) {
+  assertConfigShape(config);
   const warnings = [];
   const proxies = config.proxies || [];
   const groups = config["proxy-groups"] || [];
@@ -4187,7 +4317,7 @@ function isProcessRunning(pid) {
 function isProcessCommandMatching(pid, needle) {
   if (!pid) return false;
   try {
-    const result = spawnSync2("ps", ["-p", String(pid), "-o", "command="], { encoding: "utf8", timeout: PS_TIMEOUT_MS });
+    const result = spawnSync2("ps", ["-ww", "-p", String(pid), "-o", "command="], { encoding: "utf8", timeout: PS_TIMEOUT_MS });
     return (result.stdout || "").includes(needle);
   } catch {
     return false;
@@ -4697,6 +4827,17 @@ function viewLogWithTail(logPath, options) {
 
 // src/daemon.ts
 var SERVICE_TARGET = `system/${LAUNCH_DAEMON_LABEL}`;
+function assertDaemonLabelSafe() {
+  if (RAW_DAEMON_LABEL_INPUT !== void 0 && !isValidDaemonLabel(RAW_DAEMON_LABEL_INPUT)) {
+    throw new CliError(`MIHOMO_CLI_DAEMON_LABEL \u65E0\u6548: "${RAW_DAEMON_LABEL_INPUT}"`, {
+      label: "\u914D\u7F6E\u9519\u8BEF",
+      hint: [
+        '\u53EA\u5141\u8BB8\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u70B9\u3001\u4E0B\u5212\u7EBF\u3001\u77ED\u6A2A\u7EBF\uFF0C\u4E14\u4E0D\u80FD\u542B ".."\u3002',
+        "\u8BE5\u503C\u4F1A\u6210\u4E3A /Library/LaunchDaemons/ \u4E0B\u7684 plist \u6587\u4EF6\u540D\uFF0C\u5E76\u4F5C\u4E3A root \u5199\u5165/\u5220\u9664\u7684\u76EE\u6807\u8DEF\u5F84\u3002"
+      ]
+    });
+  }
+}
 var HOT_RELOAD_TIMEOUT_MS = 5e3;
 var DAEMON_BOOT_WAIT_MS = 500;
 var LOG_ROTATE_MAX_BYTES = 10 * 1024 * 1024;
@@ -4778,6 +4919,7 @@ function isDaemonRunning(status) {
   return status.loaded && status.pid !== null;
 }
 function enableDaemon() {
+  assertDaemonLabelSafe();
   if (!fs6.existsSync(PATHS.mihomoBinary)) {
     throw new CliError("\u672A\u627E\u5230 mihomo \u5185\u6838\uFF0C\u8BF7\u5148\u4E0B\u8F7D\u5185\u6838");
   }
@@ -4818,6 +4960,7 @@ function enableDaemon() {
   }
 }
 function disableDaemon() {
+  assertDaemonLabelSafe();
   if (!isDaemonEnabled()) return;
   const target = shellQuote(SERVICE_TARGET);
   const plistDest = shellQuote(PATHS.launchDaemonPlist);
@@ -4862,7 +5005,7 @@ async function tryHotReload() {
 }
 async function restartDaemon() {
   if (!fs6.existsSync(PATHS.launchDaemonPlist)) {
-    throw new Error("\u4FDD\u6D3B\u672A\u542F\u7528\uFF0C\u65E0\u6CD5\u91CD\u542F");
+    throw new CliError("\u4FDD\u6D3B\u672A\u542F\u7528\uFF0C\u65E0\u6CD5\u91CD\u542F", { hint: "\u542F\u7528\u4FDD\u6D3B: mihomo daemon on" });
   }
   if (!logOversized() && await tryHotReload()) return;
   const target = shellQuote(SERVICE_TARGET);
@@ -4889,6 +5032,7 @@ async function restartDaemon() {
 
 // src/http.ts
 var MAX_RESPONSE_BYTES = 50 * 1024 * 1024;
+var MAX_ERROR_BODY_BYTES = 64 * 1024;
 function createHttpClient(options = {}) {
   const { timeout = 6e4, secret } = options;
   const authHeaders = secret ? { Authorization: `Bearer ${secret}` } : {};
@@ -4906,7 +5050,8 @@ function createHttpClient(options = {}) {
           const error = new Error(`HTTP ${response.status}`);
           error.response = { status: response.status };
           try {
-            error.response.data = await response.json();
+            const text2 = await readBodyWithLimit(response, controller, MAX_ERROR_BODY_BYTES);
+            error.response.data = JSON.parse(text2);
           } catch {
           }
           throw error;
@@ -4915,7 +5060,7 @@ function createHttpClient(options = {}) {
         if (Number.isFinite(declaredLen) && declaredLen > MAX_RESPONSE_BYTES) {
           throw new Error(`\u54CD\u5E94\u4F53\u8FC7\u5927\uFF08${formatBytes(declaredLen)}\uFF0C\u4E0A\u9650 ${formatBytes(MAX_RESPONSE_BYTES)}\uFF09`);
         }
-        const text = await readBodyWithLimit(response, controller);
+        const text = await readBodyWithLimit(response, controller, MAX_RESPONSE_BYTES);
         const data = config?.responseType === "json" ? JSON.parse(text) : text;
         return { data, headers: response.headers, status: response.status };
       } finally {
@@ -4924,7 +5069,7 @@ function createHttpClient(options = {}) {
     }
   };
 }
-async function readBodyWithLimit(response, controller) {
+async function readBodyWithLimit(response, controller, limit) {
   if (!response.body) return response.text();
   const reader = response.body.getReader();
   const chunks = [];
@@ -4935,9 +5080,9 @@ async function readBodyWithLimit(response, controller) {
       if (done) break;
       if (value) {
         total += value.byteLength;
-        if (total > MAX_RESPONSE_BYTES) {
+        if (total > limit) {
           controller.abort();
-          throw new Error(`\u54CD\u5E94\u4F53\u8D85\u8FC7\u5927\u5C0F\u4E0A\u9650\uFF08${formatBytes(MAX_RESPONSE_BYTES)}\uFF09`);
+          throw new Error(`\u54CD\u5E94\u4F53\u8D85\u8FC7\u5927\u5C0F\u4E0A\u9650\uFF08${formatBytes(limit)}\uFF09`);
         }
         chunks.push(value);
       }
@@ -4964,7 +5109,9 @@ function resolveUpdateInterval(url, cachedInterval) {
 }
 var HTTP_CLIENT = createHttpClient({ timeout: 6e4 });
 function isMultiUrl(url) {
-  return url.includes(",");
+  if (!url.includes(",")) return false;
+  const parts = url.split(",").map((u) => u.trim()).filter(Boolean);
+  return parts.length > 1 && parts.every(isValidHttpUrl);
 }
 function isValidHttpUrl(url) {
   try {
@@ -4975,6 +5122,7 @@ function isValidHttpUrl(url) {
   }
 }
 function splitUrls(url) {
+  if (!isMultiUrl(url)) return [url.trim()];
   return url.split(",").map((u) => u.trim()).filter(Boolean);
 }
 function loadSubscriptionConfig(subName) {
@@ -5097,6 +5245,23 @@ function pickSingleSubscription(subs, pattern) {
 function resolveSubscription(subs, pattern) {
   return pickSingleSubscription(findSubscriptionFuzzy(subs, pattern), pattern);
 }
+function assertLooksLikeSubscription(parsed, maskedUrl) {
+  const hasProxies = Array.isArray(parsed.proxies) && parsed.proxies.length > 0;
+  const hasGroups = Array.isArray(parsed["proxy-groups"]) && parsed["proxy-groups"].length > 0;
+  const providers = parsed["proxy-providers"];
+  const hasProviders = providers != null && typeof providers === "object" && Object.keys(providers).length > 0;
+  if (hasProxies || hasGroups || hasProviders) return;
+  const serverMsg = ["error", "message", "msg", "info"].map((k) => parsed[k]).find((v) => typeof v === "string" && v.length > 0);
+  throw new CliError("\u8BA2\u9605\u5185\u5BB9\u4E0D\u542B\u4EFB\u4F55\u8282\u70B9\u6765\u6E90\uFF08proxies / proxy-groups / proxy-providers \u5747\u4E3A\u7A7A\uFF09", {
+    label: "\u8BA2\u9605\u65E0\u6548",
+    hint: [
+      ...serverMsg ? [`\u670D\u52A1\u7AEF\u8FD4\u56DE: ${serverMsg}`] : [],
+      `URL: ${maskedUrl}`,
+      "\u5E38\u89C1\u539F\u56E0\uFF1A\u8BA2\u9605\u94FE\u63A5\u8FC7\u671F\u3001\u6D41\u91CF\u8017\u5C3D\u3001\u9700\u8981\u91CD\u65B0\u83B7\u53D6\u8BA2\u9605\u5730\u5740\u3002",
+      "\u78C1\u76D8\u4E0A\u539F\u6709\u7684\u8BA2\u9605\u914D\u7F6E\u672A\u88AB\u8986\u76D6\u3002"
+    ]
+  });
+}
 async function downloadSubscription(url, subName = "default", signal, persist = true) {
   let response;
   try {
@@ -5118,6 +5283,7 @@ async function downloadSubscription(url, subName = "default", signal, persist =
   }
   const parsed = parseYamlOrJson(content, "\u8BA2\u9605\u5185\u5BB9");
   if (!parsed) throw new Error("\u8BA2\u9605\u5185\u5BB9\u4E3A\u7A7A");
+  assertLooksLikeSubscription(parsed, maskUrl(url));
   if (persist) {
     saveSubscriptionRawConfig(subName, content);
   }
@@ -5150,12 +5316,13 @@ async function downloadMergedSubscription(urls, subName, signal, persist = true)
       }
     })
   );
-  for (const r of responses) {
-    if (r.error) {
-      const maskedUrl = maskUrl(r.url);
-      throw new Error(`\u5408\u5E76\u8BA2\u9605\u7B2C ${r.index + 1} \u4E2A URL \u83B7\u53D6\u5931\u8D25: ${r.error.message}
+  const failures = responses.filter((r) => r.error);
+  if (failures.length > 0) {
+    const isAbort = (e) => e.name === "AbortError" || /abort/i.test(e.message);
+    const real = failures.find((r) => !isAbort(r.error)) ?? failures[0];
+    const maskedUrl = maskUrl(real.url);
+    throw new Error(`\u5408\u5E76\u8BA2\u9605\u7B2C ${real.index + 1} \u4E2A URL \u83B7\u53D6\u5931\u8D25: ${real.error.message}
   URL: ${maskedUrl}`);
-    }
   }
   const parsed = responses.map((r, i) => {
     const content = r.response?.data;
@@ -5176,6 +5343,7 @@ async function downloadMergedSubscription(urls, subName, signal, persist = true)
   }
   base.proxies = baseProxies;
   const mergedContent = dumpYaml(base);
+  assertLooksLikeSubscription(base, urls.map((u) => maskUrl(u)).join(", "));
   if (persist) {
     saveSubscriptionRawConfig(subName, mergedContent);
   }
@@ -5465,6 +5633,9 @@ async function autoCleanSubscription(subName, options = {}) {
   return { summary, removedProxies, updatedGroups, removedGroups, skipped };
 }
 
+// src/commands/shared.ts
+import readline from "readline";
+
 // src/runtime.ts
 function getRuntimeMode() {
   if (isDaemonEnabled()) return "mixed";
@@ -5768,6 +5939,17 @@ async function dispatchSubcommand(args, table, options) {
   }
   return options.fallback(args);
 }
+async function confirmPrompt(question) {
+  if (!process.stdin.isTTY) return false;
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise((resolve) => {
+    rl.question(`${question} (y/N) `, (a) => {
+      rl.close();
+      resolve(a);
+    });
+  });
+  return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+}
 function requireRunning() {
   const state = getRunningState();
   if (!state.running) {
@@ -5927,9 +6109,26 @@ function printDirectoryInfo() {
   console.log("  MIHOMO_CLI_DIR: \u81EA\u5B9A\u4E49\u6839\u76EE\u5F55\u4F4D\u7F6E");
   console.log("");
 }
-var SUBCOMMANDS2 = [{ name: "open", handler: openDirectory }];
-function cmdDirectory(args) {
-  void dispatchSubcommand(args, SUBCOMMANDS2, { fallback: printDirectoryInfo });
+var SUBCOMMANDS2 = [
+  { name: "open", handler: openDirectory },
+  { name: "list", handler: printDirectoryInfo }
+];
+async function cmdDirectory(args) {
+  await dispatchSubcommand(args, SUBCOMMANDS2, {
+    fallback: printDirectoryInfo,
+    onUnknown: (action) => {
+      const names = SUBCOMMANDS2.flatMap((c) => [c.name, ...c.aliases ?? []]);
+      const suggestion = suggestSimilar(action, names);
+      throw new CliError(`\u672A\u77E5\u7684\u76EE\u5F55\u5B50\u547D\u4EE4: ${action}`, {
+        hint: [
+          ...suggestion.length > 0 ? [`\u662F\u5426\u60F3\u8F93\u5165: ${suggestion.join(" / ")}?`] : [],
+          "",
+          "\u53EF\u7528\u5B50\u547D\u4EE4: open, list",
+          "\u6253\u5F00\u6307\u5B9A\u76EE\u5F55: mihomo dir open <target>"
+        ]
+      });
+    }
+  });
 }
 
 // src/kernel.ts
@@ -6375,20 +6574,35 @@ async function setOverwrite(enabled, args) {
 }
 var SUBCOMMANDS3 = [
   { name: "on", aliases: ["enable"], handler: (args) => setOverwrite(true, args) },
-  { name: "off", aliases: ["disable"], handler: (args) => setOverwrite(false, args) }
+  { name: "off", aliases: ["disable"], handler: (args) => setOverwrite(false, args) },
+  // list 显式注册：onUnknown 生效后，未注册的子命令会报错，不能再靠 fallback 兜住 `ow list`
+  {
+    name: "list",
+    handler: () => {
+      console.log("");
+      printOverwriteList();
+    }
+  }
 ];
 async function cmdOverwrite(args) {
   await dispatchSubcommand(args, SUBCOMMANDS3, {
+    // 无子命令 → 列表；未知子命令 → 报错（与 sub/daemon 同构，避免 `ow onn` 静默当成 list）
     fallback: () => {
       console.log("");
       printOverwriteList();
+    },
+    onUnknown: (action) => {
+      const names = SUBCOMMANDS3.flatMap((c) => [c.name, ...c.aliases ?? []]);
+      const suggestion = suggestSimilar(action, names);
+      throw new CliError(`\u672A\u77E5\u7684\u8986\u5199\u5B50\u547D\u4EE4: ${action}`, {
+        hint: [...suggestion.length > 0 ? [`\u662F\u5426\u60F3\u8F93\u5165: ${suggestion.join(" / ")}?`] : [], "", "\u53EF\u7528\u5B50\u547D\u4EE4: on, off, list"]
+      });
     }
   });
 }
 
 // src/commands/reset.ts
 import fs8 from "fs";
-import readline from "readline";
 var RESET_TARGETS = [
   {
     id: "subs",
@@ -6425,7 +6639,10 @@ var RESET_TARGETS = [
     id: "settings",
     aliases: ["setting", "settings", "config"],
     label: "\u8BBE\u7F6E",
-    paths: () => [PATHS.settingsFile],
+    // 同时删 .bak：readSettings 遇格式损坏会备份原文件（settings.ts），里面含
+    // controller_secret 与订阅 URL 的 token。只删主文件会让 "已重置: 设置" 名不副实，
+    // 凭据仍明文留在数据目录（cache.json.bak 在 subscriptions/ 内，随整目录删除，无需单列）
+    paths: () => [PATHS.settingsFile, `${PATHS.settingsFile}.bak`],
     needsStop: false
   },
   {
@@ -6475,18 +6692,9 @@ function resolveResetTargets(names) {
       unmatched.push(name);
     }
   }
+  matched.sort((a, b) => RESET_TARGETS.indexOf(a) - RESET_TARGETS.indexOf(b));
   return { matched, unmatched };
 }
-async function confirmPrompt(question) {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve) => {
-    rl.question(`${question} (y/N) `, (a) => {
-      rl.close();
-      resolve(a);
-    });
-  });
-  return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
-}
 async function cmdReset(args) {
   const flags = (args || []).filter((a) => a.startsWith("-"));
   const names = (args || []).slice(1).filter((a) => !a.startsWith("-"));
@@ -6541,25 +6749,41 @@ async function cmdReset(args) {
     console.log(colors.yellow("\u4FDD\u6D3B\u5DF2\u542F\u7528\uFF0C\u91CD\u7F6E\u5C06\u4E00\u5E76\u5173\u95ED\u4FDD\u6D3B\uFF08\u79FB\u9664\u5F00\u673A\u81EA\u542F\uFF09"));
   }
   console.log(`\u5C06\u5220\u9664: ${targets.map((t) => t.label).join("\u3001")}`);
-  if (!skipConfirm && !await confirmPrompt("\u786E\u8BA4?")) {
-    console.log("\u5DF2\u53D6\u6D88");
-    return;
+  if (!skipConfirm) {
+    if (!process.stdin.isTTY) {
+      throw new CliError("\u975E\u4EA4\u4E92\u73AF\u5883\u65E0\u6CD5\u786E\u8BA4", { label: "\u5DF2\u53D6\u6D88", hint: ["\u8DF3\u8FC7\u786E\u8BA4\u8BF7\u52A0 -y: mihomo reset ... -y"] });
+    }
+    if (!await confirmPrompt("\u786E\u8BA4?")) {
+      console.log("\u5DF2\u53D6\u6D88");
+      return;
+    }
   }
   if (disablesDaemon && isDaemonEnabled()) {
     try {
       disableDaemon();
     } catch (e) {
-      console.error(`${colors.red("\u4FDD\u6D3B\u5173\u95ED\u5DF2\u53D6\u6D88\uFF0C\u91CD\u7F6E\u4E2D\u6B62:")} ${e.message.split("\n")[0]}`);
-      return;
+      if (e instanceof CliError) throw e;
+      throw new CliError(e.message.split("\n")[0], { label: "\u4FDD\u6D3B\u5173\u95ED\u5DF2\u53D6\u6D88\uFF0C\u91CD\u7F6E\u4E2D\u6B62" });
     }
   }
   if (needsStop && getMihomoPids().length > 0) {
     console.log("\u505C\u6B62\u8FDB\u7A0B...");
-    cleanupAll();
+    const cleanup = cleanupAll();
     for (let i = 0; i < PROCESS_WAIT_ATTEMPTS; i++) {
       if (getMihomoPids().length === 0) break;
       await new Promise((r) => setTimeout(r, PROCESS_WAIT_INTERVAL));
     }
+    const remaining = getMihomoPids();
+    if (remaining.length > 0) {
+      throw new CliError(remaining.join(", "), {
+        label: "\u8FDB\u7A0B\u672A\u80FD\u505C\u6B62\uFF0C\u91CD\u7F6E\u4E2D\u6B62",
+        hint: [
+          `\u672A\u7EC8\u6B62\u7684\u8FDB\u7A0B: ${remaining.join(", ")}${cleanup.failed > 0 ? `\uFF08${cleanup.failed} \u4E2A\u7EC8\u6B62\u5931\u8D25\uFF09` : ""}`,
+          "\u8BF7\u624B\u52A8\u8FD0\u884C: sudo pkill -9 mihomo",
+          "\u5426\u5219\u6B8B\u7559\u8FDB\u7A0B\u4F1A\u7EE7\u7EED\u4F7F\u7528\u5373\u5C06\u5220\u9664\u7684\u914D\u7F6E\u3002"
+        ]
+      });
+    }
   }
   for (const t of targets) {
     for (const p of t.paths()) {
@@ -6585,6 +6809,7 @@ import { spawn as spawn2 } from "child_process";
 import fs9 from "fs";
 import path8 from "path";
 function isProxyValid(proxy) {
+  if (proxy === null || typeof proxy !== "object") return false;
   if (!proxy.name || !proxy.server || !proxy.port) return false;
   if (!proxy.type) return false;
   if (proxy.type === "ss" && typeof proxy.cipher === "string" && proxy.cipher.startsWith("2022-blake3")) {
@@ -6661,6 +6886,7 @@ async function startTestInstance() {
   child.unref();
   const pid = child.pid;
   if (!pid) throw new CliError("\u6D4B\u8BD5\u5B9E\u4F8B\u542F\u52A8\u5931\u8D25\uFF1A\u65E0\u6CD5\u521B\u5EFA\u8FDB\u7A0B\uFF08\u5185\u6838\u4E8C\u8FDB\u5236\u53EF\u80FD\u4E0D\u53EF\u6267\u884C\uFF09");
+  spawnedTestPid = pid;
   fs9.writeFileSync(TEST_PATHS.pidFile, pid.toString(), { mode: 384 });
   const client = createHttpClient({ timeout: 2e3 });
   let ready = false;
@@ -6687,13 +6913,16 @@ ${errorDetail}` : ""}`);
     throw new CliError("\u6D4B\u8BD5\u5B9E\u4F8B\u542F\u52A8\u8D85\u65F6\uFF0CAPI \u672A\u54CD\u5E94");
   }
 }
+var spawnedTestPid = null;
 function stopTestInstance() {
-  let pid;
+  let pid = null;
   try {
-    pid = parseInt(fs9.readFileSync(TEST_PATHS.pidFile, "utf8").trim(), 10);
+    const fromFile = parseInt(fs9.readFileSync(TEST_PATHS.pidFile, "utf8").trim(), 10);
+    if (fromFile > 0) pid = fromFile;
   } catch {
-    return;
   }
+  if (pid === null) pid = spawnedTestPid;
+  if (pid === null) return;
   if (pid > 0 && isProcessRunning(pid) && isProcessCommandMatching(pid, TEST_PATHS.configFile)) {
     process.kill(pid, "SIGKILL");
     for (let i = 0; i < 20; i++) {
@@ -6701,6 +6930,7 @@ function stopTestInstance() {
       sleepSync(100);
     }
   }
+  spawnedTestPid = null;
   try {
     fs9.unlinkSync(TEST_PATHS.pidFile);
   } catch {
@@ -6824,11 +7054,12 @@ async function subAdd(args) {
     console.log(`\u6DFB\u52A0\u5408\u5E76\u8BA2\u9605: ${name} (${urls.length} \u4E2A\u6E90)`);
     addSubscription(normalizedUrl, name);
     try {
-      setDefaultSubscription(name);
       const info = await downloadMergedSubscription(urls, name);
+      setDefaultSubscription(name);
       console.log(`\u5DF2\u6DFB\u52A0\u5E76\u5207\u6362\u5230 "${name}" (${formatProxySummary(info)}, \u5408\u5E76 ${urls.length} \u6E90)`);
     } catch (e) {
       removeSubscription(name);
+      if (e instanceof CliError) throw new CliError(e.message, { label: "\u6DFB\u52A0\u5931\u8D25", hint: e.hint });
       throw new CliError(e.message, { label: "\u6DFB\u52A0\u5931\u8D25" });
     }
   } else {
@@ -6838,13 +7069,14 @@ async function subAdd(args) {
     console.log(`\u6DFB\u52A0\u8BA2\u9605: ${name}`);
     addSubscription(url, name);
     try {
-      setDefaultSubscription(name);
       const info = await downloadSubscription(url, name);
+      setDefaultSubscription(name);
       const repoUrl = githubRepoUrl(url);
       if (repoUrl) saveSubscriptionCache(name, { web_page_url: repoUrl });
       console.log(`\u5DF2\u6DFB\u52A0\u5E76\u5207\u6362\u5230 "${name}" (${formatProxySummary(info)})`);
     } catch (e) {
       removeSubscription(name);
+      if (e instanceof CliError) throw new CliError(e.message, { label: "\u6DFB\u52A0\u5931\u8D25", hint: e.hint });
       throw new CliError(e.message, { label: "\u6DFB\u52A0\u5931\u8D25" });
     }
   }
@@ -6941,8 +7173,8 @@ async function subWeb(args) {
     console.log("\u8BF7\u624B\u52A8\u8BBF\u95EE\u4E0A\u9762\u7684\u5730\u5740");
   }
 }
-function subRemove(args) {
-  const name = args[2];
+async function subRemove(args) {
+  const name = getNonFlagArg(args, 2);
   const subs = getSubscriptions();
   if (!name) {
     throw new CliError("\u8BF7\u6307\u5B9A\u8981\u5220\u9664\u7684\u8BA2\u9605\u540D\u79F0", {
@@ -6950,6 +7182,21 @@ function subRemove(args) {
     });
   }
   const target = resolveSubscription(subs, name);
+  const isExact = target.name === name;
+  const skipConfirm = hasFlag(args, "-y", "--yes");
+  if (!isExact && !skipConfirm) {
+    if (!process.stdin.isTTY) {
+      throw new CliError(`\u6A21\u7CCA\u5339\u914D\u5230 "${target.name}"\uFF0C\u975E\u4EA4\u4E92\u73AF\u5883\u9700\u786E\u8BA4`, {
+        label: "\u5DF2\u53D6\u6D88",
+        hint: [`\u8BF7\u7528\u5B8C\u6574\u540D\u79F0: mihomo sub remove ${target.name}`, `\u6216\u8DF3\u8FC7\u786E\u8BA4: mihomo sub remove ${name} -y`]
+      });
+    }
+    console.log(`\u5C06\u5220\u9664\u8BA2\u9605 "${target.name}" (\u6A21\u7CCA\u5339\u914D "${name}")`);
+    if (!await confirmPrompt("\u6B64\u64CD\u4F5C\u4E0D\u53EF\u6062\u590D\uFF0C\u786E\u8BA4?")) {
+      console.log("\u5DF2\u53D6\u6D88");
+      return;
+    }
+  }
   const switchedTo = removeSubscription(target.name);
   console.log(`\u5DF2\u5220\u9664\u8BA2\u9605 "${target.name}"`);
   if (switchedTo) {
@@ -7031,10 +7278,10 @@ async function cmdSubscription(args) {
 
 // src/commands/test.ts
 async function cmdTest(args) {
-  requireRunning();
-  const activeSub = requireActiveSubscription("\u6CA1\u6709\u6D3B\u8DC3\u8BA2\u9605");
   const timeout = parseIntArg(args, "-t", "--timeout", DEFAULT_TEST_TIMEOUT);
   const concurrency = parseIntArg(args, "-j", "--concurrency", DEFAULT_TEST_CONCURRENCY);
+  requireRunning();
+  const activeSub = requireActiveSubscription("\u6CA1\u6709\u6D3B\u8DC3\u8BA2\u9605");
   console.log(`\u6D4B\u8BD5 "${activeSub.name}" \u8282\u70B9\u8FDE\u901A\u6027...`);
   console.log(`\u8D85\u65F6: ${timeout}ms  \u5E76\u53D1: ${concurrency}`);
   console.log("");
@@ -7048,11 +7295,11 @@ async function cmdTest(args) {
   console.log(formatTestSummary(summary));
 }
 async function cmdClean(args) {
-  requireRunning();
-  const activeSub = requireActiveSubscription("\u6CA1\u6709\u6D3B\u8DC3\u8BA2\u9605");
   const timeout = parseIntArg(args, "-t", "--timeout", DEFAULT_TEST_TIMEOUT);
   const concurrency = parseIntArg(args, "-j", "--concurrency", DEFAULT_TEST_CONCURRENCY);
   const rounds = parseIntArg(args, "-r", "--rounds", DEFAULT_CLEAN_ROUNDS);
+  requireRunning();
+  const activeSub = requireActiveSubscription("\u6CA1\u6709\u6D3B\u8DC3\u8BA2\u9605");
   console.log(`\u6E05\u7406 "${activeSub.name}" \u5931\u8D25\u8282\u70B9...`);
   console.log(`\u8D85\u65F6: ${timeout}ms  \u5E76\u53D1: ${concurrency}`);
   console.log("");
@@ -7236,18 +7483,18 @@ var COMMANDS = [
   // === 订阅 ===
   {
     name: "subscription",
-    aliases: ["sub", "subscriptions"],
+    aliases: ["sub", "subs", "subscriptions"],
     handler: cmdSubscription,
     group: "subscription",
     usage: [
-      "subscription                 \u5217\u51FA\u6240\u6709\u8BA2\u9605\uFF08\u522B\u540D sub\uFF09",
+      "subscription                 \u5217\u51FA\u6240\u6709\u8BA2\u9605\uFF08\u522B\u540D sub/subs\uFF09",
       "subscription use <name>      \u5207\u6362\u5F53\u524D\u8BA2\u9605",
       "subscription add <url> [name]  \u6DFB\u52A0\u8BA2\u9605",
       "subscription update [name]   \u66F4\u65B0\u8BA2\u9605\uFF08\u65E0\u53C2\u66F4\u65B0\u6240\u6709\uFF09",
-      "subscription remove <name>   \u5220\u9664\u8BA2\u9605",
+      "subscription remove <name>   \u5220\u9664\u8BA2\u9605\uFF08\u6A21\u7CCA\u5339\u914D\u9700\u786E\u8BA4\uFF0C-y \u8DF3\u8FC7\uFF09",
       "subscription web [name]      \u6253\u5F00\u8BA2\u9605\u9875\u9762",
       "subscription test [name]     \u6D4B\u8BD5\u8282\u70B9\uFF08\u72EC\u7ACB\u5B9E\u4F8B\uFF0C\u65E0\u9700\u8FD0\u884C\uFF09",
-      "subscription clean [name]    \u6D4B\u901F\u6E05\u7406\uFF08\u72EC\u7ACB\u5B9E\u4F8B\uFF0C\u4E0D\u52A8\u4E3B\u5B9E\u4F8B\uFF09"
+      "subscription clean [name]    \u6D4B\u901F\u6E05\u7406\uFF08\u72EC\u7ACB\u5B9E\u4F8B\uFF0C\u4E0D\u52A8\u4E3B\u5B9E\u4F8B\uFF09[-r N] [-t ms] [-j N]"
     ]
   },
   {
@@ -7284,7 +7531,7 @@ var COMMANDS = [
     name: "on",
     aliases: [],
     handler: cmdOverwrite,
-    rewrite: () => ["ow", "on"],
+    rewrite: (args) => ["ow", "on", ...args.slice(1)],
     group: "config",
     usage: []
   },
@@ -7292,7 +7539,7 @@ var COMMANDS = [
     name: "off",
     aliases: [],
     handler: cmdOverwrite,
-    rewrite: () => ["ow", "off"],
+    rewrite: (args) => ["ow", "off", ...args.slice(1)],
     group: "config",
     usage: []
   },
@@ -7411,11 +7658,26 @@ function clearProxyEnv() {
   delete process.env.all_proxy;
   delete process.env.ALL_PROXY;
 }
+var PLATFORM_FREE_COMMANDS = /* @__PURE__ */ new Set(["help", "version"]);
+function assertSupportedPlatform(commandName) {
+  if (process.platform === "darwin") return;
+  if (PLATFORM_FREE_COMMANDS.has(commandName)) return;
+  if (process.env.MIHOMO_CLI_ALLOW_ANY_PLATFORM === "1") return;
+  throw new CliError(`mihomo-cli \u76EE\u524D\u4EC5\u652F\u6301 macOS\uFF08\u5F53\u524D\u5E73\u53F0: ${process.platform}\uFF09`, {
+    label: "\u5E73\u53F0\u4E0D\u652F\u6301",
+    hint: [
+      "\u8FDB\u7A0B\u4FDD\u6D3B\u4F9D\u8D56 launchd\u3001\u76EE\u5F55/UI \u6253\u5F00\u4F9D\u8D56 open\u3001\u63D0\u6743\u4F9D\u8D56 sudo\uFF0C\u5747\u65E0\u5176\u4ED6\u5E73\u53F0\u5B9E\u73B0\u3002",
+      "Windows / Linux \u9002\u914D\u4ECD\u5728\u8FDB\u884C\u4E2D\u3002",
+      "\u5982\u9700\u5728\u975E macOS \u4E0A\u5F00\u53D1\u8C03\u8BD5\uFF0C\u53EF\u8BBE MIHOMO_CLI_ALLOW_ANY_PLATFORM=1\uFF08\u529F\u80FD\u4E0D\u4FDD\u8BC1\u53EF\u7528\uFF09\u3002"
+    ]
+  });
+}
 async function main() {
   clearProxyEnv();
-  ensureDirs();
   const args = process.argv.slice(2);
   if (args.length === 0) {
+    assertSupportedPlatform("status");
+    ensureDirs();
     printStatus();
     printShortHelp();
     return;
@@ -7428,6 +7690,8 @@ async function main() {
       hint: [suggestion.length > 0 ? `\u662F\u5426\u60F3\u8F93\u5165: ${suggestion.join(" / ")}?` : '\u4F7F\u7528 "mihomo help" \u67E5\u770B\u5E2E\u52A9']
     });
   }
+  assertSupportedPlatform(command.name);
+  ensureDirs();
   await command.handler(command.rewrite ? command.rewrite(args) : args);
 }
 main().catch((e) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mihomo-cli",
-  "version": "3.6.0",
+  "version": "3.7.0",
   "type": "module",
   "description": "A terminal-based mihomo (Clash.Meta) client for macOS",
   "bin": {
@@ -21,6 +21,7 @@
     "format": "biome format --write .",
     "typecheck": "tsc --noEmit",
     "test": "node --import tsx --test \"src/**/*.spec.ts\"",
+    "prepublishOnly": "npm run build",
     "prepare": "husky"
   },
   "keywords": [
@@ -41,6 +42,9 @@
   "engines": {
     "node": ">=22.22.1"
   },
+  "os": [
+    "darwin"
+  ],
   "dependencies": {
     "compare-versions": "^6.1.0",
     "js-yaml": "^5.2.1"