clash-controller 0.2.5__tar.gz → 0.2.7__tar.gz

{clash_controller-0.2.5 → clash_controller-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clash_controller
-Version: 0.2.5
+Version: 0.2.7
 Summary: A Textual TUI for managing Clash proxy instances
 Author-email: Moha-Master <hongkongreporter@outlook.com>
 License-Expression: MIT
@@ -38,7 +38,8 @@ Requires-Dist: pytest-asyncio; extra == "dev"
     - 支持 HTTP 与 Unix Domain Socket 连接。
     - 远程端点支持 SSH 部署（密码 / 私钥文件 / 私钥文本三种认证）。
 - **实时监控面板**：
-    - **概览**：合并流式监控与连接管理，在一个页面同时显示上/下行流量、内存使用、内核版本，并带每秒自动刷新的当前活动连接表与累计流量。
+    - **概览**：合并流式监控与连接管理，在一个页面同时显示上/下行流量、内存使用、内核版本，并带每秒自动刷新的当前活动连接表与累计流量；连接表支持关键字（地址 / 规则 / 节点 / 进程）、节点、隐藏 DIRECT 筛选，以及按默认（API 原始顺序）、上/下载速度、流量、时长、地址、规则、节点排序（可切换升/降序）。
+- **节点管理**：按策略组浏览组内成员（节点 / 嵌套组 / DIRECT / REJECT），显示服务端记录的最新延迟、失败与未测状态；支持单节点测速、整组测速、在组内手动指定当前节点，以及对 URLTest / 故障转移组恢复自动（清除固定选择）。provider 节点测速自动走 provider 作用域接口。
 - **配置管理**：维护配置提供方列表，一键拉取远端配置、比对时间戳/哈希、部署到目标端点（本地或 SSH）并重载。
 - **设置菜单**：端点名称置于顶栏，TUN 与规则/全局/直连模式在面板内直接通过 Switch 和 Select 下拉列表即时生效切换（无需手动保存）、重载 GEO、重启 Clash、在线升级内核 / UI / GEO，以及查看运行日志。
 
@@ -51,9 +52,19 @@ Requires-Dist: pytest-asyncio; extra == "dev"
 | | `Ctrl+N` / `Ctrl+E` / `Ctrl+D` | 新增 / 编辑 / 删除端点配置 |
 | | `Ctrl+R` | 刷新列表 |
 | | `Esc` / `Ctrl+C` | 退出程序 |
-| **主菜单** | `1` / `2` / `3` / `4` | 直达概览 / 配置管理 / 设置 / 切换端点 |
+| **主菜单** | `1` / `2` / `3` / `4` / `5` | 直达概览 / 节点 / 配置管理 / 设置 / 切换端点 |
 | | `↑` / `↓` · `回车` | 移动光标 · 确认 |
-| | `Esc` / `Ctrl+C` | 退出程序（切换端点请按 `4`） |
+| | `Esc` / `Ctrl+C` | 退出程序（切换端点请按 `5`） |
+| **概览** | `↑` / `↓` / `PgUp` / `PgDn` | 滚动连接表 |
+| | `/` | 聚焦筛选输入框（地址 / 规则 / 节点 / 进程） |
+| | `Tab` / `Shift+Tab` | 在筛选框、节点 / 排序下拉、隐藏 DIRECT 开关间轮切 |
+| | `Ctrl+R` | 刷新（焦点在输入框时让位给文本编辑） |
+| **节点** | `↑` / `↓` · `回车` 或 **双击行** | 移动光标 · 在组内指定所选节点 |
+| | `Ctrl+T` | 测所选节点延迟 |
+| | `Ctrl+G` | 测整组延迟（URLTest / 故障转移组会清除固定选择，先确认） |
+| | `Ctrl+U` | 恢复自动（清除 URLTest / 故障转移组的固定选择） |
+| | `/` | 聚焦节点名称筛选框 |
+| | `Ctrl+R` | 刷新策略组与延迟 |
 | **配置管理** | `↑` / `↓` · `回车` 或 **双击行** | 移动光标 · 部署所选提供方 |
 | | `Ctrl+N` / `Ctrl+E` / `Ctrl+D` | 新增 / 编辑 / 删除提供方 |
 | | `Ctrl+R` | 刷新 |
@@ -85,6 +96,14 @@ clashctl -D /path/to/config/dir   # 指定配置目录（默认 ~/.config/clash-
 clashctl --debug                  # 启用 API / SSH 调试日志（显示在应用日志页）
 ```
 
+## Windows 说明
+
+- Clash 配置目录默认从 `%USERPROFILE%\.config\clash` / `%USERPROFILE%\.config\mihomo` 探测，也可在端点里手动填写（支持 `~`、`%VAR%`）。
+- 若配置目录位于 `Program Files`、`ProgramData` 等受保护位置，部署时会弹出 UAC 请求管理员写入；请在端点设置中保持“管理员写入 (UAC)”开启，并在弹出的对话框中点击“是”。提权后由程序自身的管理员进程完成写入（不借助 PowerShell，避免被安全软件当成攻击行为掐掉）。部署界面会显示当前阶段（请求授权 / 已授权正在写入），详情同时写入“应用日志”页。
+- 写入是否成功以 `config.yaml` 的实际内容为准：只要目标文件已替换为拉取到的配置就判定成功，不会因提权进程未回写确认文件而误报“等待 UAC 超时”。替换走系统 `ReplaceFileW`，会保留 `config.yaml` 原有的访问权限（ACL），原配置备份为同目录的 `config.yaml.bak`。
+- 如果当前进程已经是管理员权限、或账户不属于管理员组，程序不会白弹 UAC，而是直接说明真正的原因（只读属性 / ACL 拒绝 / 文件被占用，或建议把配置目录放到用户目录）。
+- 订阅与本地配置会按 UTF-8 / GB18030 / 带 BOM 的 UTF-16 自动识别，并统一以 UTF-8（无 BOM、LF 换行）写入，不会再把中文变成乱码；控制 API 响应体同样按字节解码，中文节点名不受 `Content-Type` 缺 charset 影响。
+
 ## 开发者安装
 
 ```bash

{clash_controller-0.2.5 → clash_controller-0.2.7}/README.md

@@ -11,7 +11,8 @@
     - 支持 HTTP 与 Unix Domain Socket 连接。
     - 远程端点支持 SSH 部署（密码 / 私钥文件 / 私钥文本三种认证）。
 - **实时监控面板**：
-    - **概览**：合并流式监控与连接管理，在一个页面同时显示上/下行流量、内存使用、内核版本，并带每秒自动刷新的当前活动连接表与累计流量。
+    - **概览**：合并流式监控与连接管理，在一个页面同时显示上/下行流量、内存使用、内核版本，并带每秒自动刷新的当前活动连接表与累计流量；连接表支持关键字（地址 / 规则 / 节点 / 进程）、节点、隐藏 DIRECT 筛选，以及按默认（API 原始顺序）、上/下载速度、流量、时长、地址、规则、节点排序（可切换升/降序）。
+- **节点管理**：按策略组浏览组内成员（节点 / 嵌套组 / DIRECT / REJECT），显示服务端记录的最新延迟、失败与未测状态；支持单节点测速、整组测速、在组内手动指定当前节点，以及对 URLTest / 故障转移组恢复自动（清除固定选择）。provider 节点测速自动走 provider 作用域接口。
 - **配置管理**：维护配置提供方列表，一键拉取远端配置、比对时间戳/哈希、部署到目标端点（本地或 SSH）并重载。
 - **设置菜单**：端点名称置于顶栏，TUN 与规则/全局/直连模式在面板内直接通过 Switch 和 Select 下拉列表即时生效切换（无需手动保存）、重载 GEO、重启 Clash、在线升级内核 / UI / GEO，以及查看运行日志。
 
@@ -24,9 +25,19 @@
 | | `Ctrl+N` / `Ctrl+E` / `Ctrl+D` | 新增 / 编辑 / 删除端点配置 |
 | | `Ctrl+R` | 刷新列表 |
 | | `Esc` / `Ctrl+C` | 退出程序 |
-| **主菜单** | `1` / `2` / `3` / `4` | 直达概览 / 配置管理 / 设置 / 切换端点 |
+| **主菜单** | `1` / `2` / `3` / `4` / `5` | 直达概览 / 节点 / 配置管理 / 设置 / 切换端点 |
 | | `↑` / `↓` · `回车` | 移动光标 · 确认 |
-| | `Esc` / `Ctrl+C` | 退出程序（切换端点请按 `4`） |
+| | `Esc` / `Ctrl+C` | 退出程序（切换端点请按 `5`） |
+| **概览** | `↑` / `↓` / `PgUp` / `PgDn` | 滚动连接表 |
+| | `/` | 聚焦筛选输入框（地址 / 规则 / 节点 / 进程） |
+| | `Tab` / `Shift+Tab` | 在筛选框、节点 / 排序下拉、隐藏 DIRECT 开关间轮切 |
+| | `Ctrl+R` | 刷新（焦点在输入框时让位给文本编辑） |
+| **节点** | `↑` / `↓` · `回车` 或 **双击行** | 移动光标 · 在组内指定所选节点 |
+| | `Ctrl+T` | 测所选节点延迟 |
+| | `Ctrl+G` | 测整组延迟（URLTest / 故障转移组会清除固定选择，先确认） |
+| | `Ctrl+U` | 恢复自动（清除 URLTest / 故障转移组的固定选择） |
+| | `/` | 聚焦节点名称筛选框 |
+| | `Ctrl+R` | 刷新策略组与延迟 |
 | **配置管理** | `↑` / `↓` · `回车` 或 **双击行** | 移动光标 · 部署所选提供方 |
 | | `Ctrl+N` / `Ctrl+E` / `Ctrl+D` | 新增 / 编辑 / 删除提供方 |
 | | `Ctrl+R` | 刷新 |
@@ -58,6 +69,14 @@ clashctl -D /path/to/config/dir   # 指定配置目录（默认 ~/.config/clash-
 clashctl --debug                  # 启用 API / SSH 调试日志（显示在应用日志页）
 ```
 
+## Windows 说明
+
+- Clash 配置目录默认从 `%USERPROFILE%\.config\clash` / `%USERPROFILE%\.config\mihomo` 探测，也可在端点里手动填写（支持 `~`、`%VAR%`）。
+- 若配置目录位于 `Program Files`、`ProgramData` 等受保护位置，部署时会弹出 UAC 请求管理员写入；请在端点设置中保持“管理员写入 (UAC)”开启，并在弹出的对话框中点击“是”。提权后由程序自身的管理员进程完成写入（不借助 PowerShell，避免被安全软件当成攻击行为掐掉）。部署界面会显示当前阶段（请求授权 / 已授权正在写入），详情同时写入“应用日志”页。
+- 写入是否成功以 `config.yaml` 的实际内容为准：只要目标文件已替换为拉取到的配置就判定成功，不会因提权进程未回写确认文件而误报“等待 UAC 超时”。替换走系统 `ReplaceFileW`，会保留 `config.yaml` 原有的访问权限（ACL），原配置备份为同目录的 `config.yaml.bak`。
+- 如果当前进程已经是管理员权限、或账户不属于管理员组，程序不会白弹 UAC，而是直接说明真正的原因（只读属性 / ACL 拒绝 / 文件被占用，或建议把配置目录放到用户目录）。
+- 订阅与本地配置会按 UTF-8 / GB18030 / 带 BOM 的 UTF-16 自动识别，并统一以 UTF-8（无 BOM、LF 换行）写入，不会再把中文变成乱码；控制 API 响应体同样按字节解码，中文节点名不受 `Content-Type` 缺 charset 影响。
+
 ## 开发者安装
 
 ```bash

{clash_controller-0.2.5 → clash_controller-0.2.7}/clash_controller/__init__.py

@@ -2,4 +2,4 @@
 Clash Controller - A Textual TUI for managing Clash proxy instances.
 """
 
-__version__ = "0.2.5"
+__version__ = "0.2.7"

{clash_controller-0.2.5 → clash_controller-0.2.7}/clash_controller/api.py

@@ -1,12 +1,39 @@
+import json
 from urllib.parse import quote
 
 import requests
 
+BODY_ENCODINGS = ("utf-8-sig", "gb18030")
+
 
 def _noop(_message: str) -> None:
     pass
 
 
+def _decode_body(response) -> str:
+    """按字节显式解码响应体。
+
+    不要直接用 ``response.text``：中间层（反向代理 / CDN）可能把 Content-Type 改成
+    没有 charset 的 ``text/*``，requests 会强制按 ISO-8859-1 解码，中文节点名直接乱码。
+    """
+    data = response.content or b""
+    for encoding in BODY_ENCODINGS:
+        try:
+            return data.decode(encoding)
+        except UnicodeDecodeError:
+            continue
+    return data.decode("utf-8", errors="replace")
+
+
+def _parse_body(response):
+    """解析响应体：优先按 JSON，失败则退回解码后的文本。"""
+    text = _decode_body(response)
+    try:
+        return json.loads(text)
+    except ValueError:
+        return text
+
+
 class ClashAPI:
     # Special sentinel returned when the request was sent but the connection
     # was interrupted (server closed connection / connection reset) and the
@@ -54,7 +81,10 @@ class ClashAPI:
         except Exception:
             return False
 
-    def _request(self, method, endpoint, params=None, json_data=None, stream=False):
+    def _request(
+        self, method, endpoint, params=None, json_data=None, stream=False,
+        timeout: float | None = None, retry: bool = True,
+    ):
         """Helper method to make requests to the API.
 
         Behavior changes:
@@ -62,8 +92,10 @@ class ClashAPI:
         - Treats PUT /configs ReadTimeout conservatively as success (server-side reload may have completed).
         - For streaming requests (stream=True) returns the raw response object so callers can iterate.
         - When debug=True, emits basic request/response information via the log callback.
+        - ``timeout``（秒）覆盖本次请求超时；``retry=False`` 时 ReadTimeout 不重试（测速不能重复打内核）。
         """
         url = f"{self.base_url}{endpoint}"
+        effective_timeout = self.timeout if timeout is None else timeout
 
         def do_request(timeout_val):
             return self.session.request(
@@ -79,11 +111,11 @@ class ClashAPI:
         try:
             if self.debug:
                 try:
-                    self._log(f"[DEBUG] Request: {method} {url}\n  headers={self.headers}\n  params={params}\n  json={json_data}\n  stream={stream}\n  timeout={self.timeout}")
+                    self._log(f"[DEBUG] Request: {method} {url}\n  headers={self.headers}\n  params={params}\n  json={json_data}\n  stream={stream}\n  timeout={effective_timeout}")
                 except Exception:
                     pass
 
-            response = do_request(self.timeout)
+            response = do_request(effective_timeout)
 
             # If caller requested streaming, return the raw response so the caller can iterate
             if stream:
@@ -100,13 +132,10 @@ class ClashAPI:
                 return {"status": "success", "status_code": response.status_code}, None
 
             # Try JSON first, fall back to text
-            try:
-                parsed = response.json()
-            except Exception:
-                parsed = response.text
+            parsed = _parse_body(response)
 
             if self.debug:
-                raw = (response.text or '')[:4096]
+                raw = _decode_body(response)[:4096]
                 self._log(f"[DEBUG] Response: status={response.status_code} headers={dict(response.headers)} body(<=4k)={raw}")
 
             # If the parsed result is a dict, inject status_code for caller convenience
@@ -116,6 +145,11 @@ class ClashAPI:
             return {"body": parsed, "status_code": response.status_code}, None
 
         except requests.exceptions.ReadTimeout as e:
+            # 测速等场景不能重试（会重复打内核），由调用方显式关闭。
+            if not retry:
+                if self.debug:
+                    self._log("[DEBUG] ReadTimeout occurred, retry disabled")
+                return None, "请求超时"
             # Retry once with an increased timeout. If retry fails due to
             # connection problems and the API is local, return the sentinel so
             # caller can ask user to verify the outcome manually.
@@ -137,9 +171,13 @@ class ClashAPI:
                     return {"status": "success"}, None
 
                 if self.debug:
-                    raw = response.text[:4096]
+                    raw = _decode_body(response)[:4096]
                     self._log(f"[DEBUG] Response after retry: status={response.status_code} headers={dict(response.headers)} body(<=4k)={raw}")
-                return response.json(), None
+                parsed = _parse_body(response)
+                if isinstance(parsed, dict):
+                    parsed.setdefault('status_code', response.status_code)
+                    return parsed, None
+                return {"body": parsed, "status_code": response.status_code}, None
 
             except requests.exceptions.RequestException as exc:
                 if self.debug:
@@ -172,16 +210,13 @@ class ClashAPI:
             resp = getattr(e, 'response', None)
             if resp is not None:
                 try:
-                    body = resp.json()
+                    body = _parse_body(resp)
                 except Exception:
-                    try:
-                        body = resp.text
-                    except Exception:
-                        body = ''
+                    body = ''
 
                 if self.debug:
                     try:
-                        self._log(f"[DEBUG] Error Response: status={resp.status_code} headers={dict(resp.headers)} body(<=4k)={(resp.text or '')[:4096]}")
+                        self._log(f"[DEBUG] Error Response: status={resp.status_code} headers={dict(resp.headers)} body(<=4k)={_decode_body(resp)[:4096]}")
                     except Exception:
                         self._log(f"[DEBUG] Error Response: status={getattr(resp, 'status_code', 'unknown')}")
 
@@ -267,16 +302,24 @@ class ClashAPI:
 
     def get_proxy(self, name: str):
         """Get a specific proxy or group's information."""
-        return self._request('GET', f'/proxies/{quote(name)}')
+        return self._request('GET', f'/proxies/{quote(name, safe="")}')
 
     def select_proxy_in_group(self, group_name: str, proxy_name: str):
         """Select a proxy for a specific group."""
-        return self._request('PUT', f'/proxies/{quote(group_name)}', json_data={"name": proxy_name})
+        return self._request('PUT', f'/proxies/{quote(group_name, safe="")}', json_data={"name": proxy_name})
 
-    def test_proxy_delay(self, name: str, url: str, timeout: int):
-        """Test a proxy's delay."""
+    def test_proxy_delay(self, name: str, url: str, timeout: int = 5000, expected=None):
+        """Test a proxy's delay (timeout 单位为毫秒，内核限制 <= 32767)。"""
         params = {'url': url, 'timeout': str(timeout)}
-        return self._request('GET', f'/proxies/{quote(name)}/delay', params=params)
+        if expected:
+            params['expected'] = str(expected)
+        return self._request(
+            'GET',
+            f'/proxies/{quote(name, safe="")}/delay',
+            params=params,
+            timeout=timeout / 1000 + 10,
+            retry=False,
+        )
 
     def get_groups(self):
         """Get policy groups."""
@@ -284,16 +327,31 @@ class ClashAPI:
 
     def get_group(self, name: str):
         """Get a specific policy group."""
-        return self._request('GET', f'/group/{quote(name)}')
+        return self._request('GET', f'/group/{quote(name, safe="")}')
 
     def reset_auto_group_selection(self, name: str):
-        """Reset the fixed selection of an auto policy group."""
-        return self._request('DELETE', f'/group/{quote(name)}')
+        """Reset the fixed selection of an auto policy group.
 
-    def test_group_delay(self, name: str, url: str, timeout: int):
-        """Test the delay of all proxies in a group."""
+        内核没有 ``DELETE /group/{name}``；清除 URLTest / Fallback 的 fixed 走
+        ``DELETE /proxies/{name}``（仅 SelectAble 且非 Selector 的组返回 204）。
+        """
+        return self._request('DELETE', f'/proxies/{quote(name, safe="")}')
+
+    def test_group_delay(self, name: str, url: str, timeout: int = 5000, expected=None):
+        """Test the delay of all proxies in a group.
+
+        注意：该端点会先清除 URLTest / Fallback 的 fixed，再并发测试成员。
+        """
         params = {'url': url, 'timeout': str(timeout)}
-        return self._request('GET', f'/group/{quote(name)}/delay', params=params)
+        if expected:
+            params['expected'] = str(expected)
+        return self._request(
+            'GET',
+            f'/group/{quote(name, safe="")}/delay',
+            params=params,
+            timeout=timeout / 1000 + 10,
+            retry=False,
+        )
 
     # === Providers ===
     def get_proxy_providers(self):
@@ -302,15 +360,32 @@ class ClashAPI:
 
     def get_proxy_provider(self, name: str):
         """Get a specific proxy provider."""
-        return self._request('GET', f'/providers/proxies/{quote(name)}')
+        return self._request('GET', f'/providers/proxies/{quote(name, safe="")}')
 
     def update_proxy_provider(self, name: str):
         """Update a proxy provider."""
-        return self._request('PUT', f'/providers/proxies/{quote(name)}')
+        return self._request('PUT', f'/providers/proxies/{quote(name, safe="")}')
 
     def healthcheck_proxy_provider(self, name: str):
         """Trigger a health check for a proxy provider."""
-        return self._request('GET', f'/providers/proxies/{quote(name)}/healthcheck')
+        return self._request('GET', f'/providers/proxies/{quote(name, safe="")}/healthcheck')
+
+    def test_provider_proxy_delay(self, provider: str, node: str, url: str, timeout: int = 5000, expected=None):
+        """Test a single provider node's delay.
+
+        provider 节点不在 ``/proxies`` 顶层字典里，单测必须走 provider 作用域
+        （``/providers/proxies/{provider}/{node}/healthcheck``），否则 404。
+        """
+        params = {'url': url, 'timeout': str(timeout)}
+        if expected:
+            params['expected'] = str(expected)
+        return self._request(
+            'GET',
+            f'/providers/proxies/{quote(provider, safe="")}/{quote(node, safe="")}/healthcheck',
+            params=params,
+            timeout=timeout / 1000 + 10,
+            retry=False,
+        )
 
     def get_rule_providers(self):
         """Get all rule providers."""
@@ -318,7 +393,7 @@ class ClashAPI:
 
     def update_rule_provider(self, name: str):
         """Update a rule provider."""
-        return self._request('PUT', f'/providers/rules/{quote(name)}')
+        return self._request('PUT', f'/providers/rules/{quote(name, safe="")}')
 
     def update_all_providers(self):
         """更新所有代理合集 (proxy-providers) 与规则合集 (rule-providers)。
@@ -476,6 +551,70 @@ def interpret_api_result(action_desc: str, result, error) -> tuple[str, str]:
     return (f"{action_desc}失败：{error}", "err")
 
 
+DELAY_OK = "ok"
+DELAY_TIMEOUT = "timeout"
+DELAY_ERROR = "error"
+
+
+def _delay_error_kind(error) -> str | None:
+    """把传输层错误归一化为 timeout / error；无错误返回 None。"""
+    if error == ClashAPI.SENT_BUT_DISCONNECTED:
+        return DELAY_TIMEOUT
+    if not error:
+        return None
+    low = str(error).lower()
+    if "timeout" in low or "timed out" in low or "超时" in low:
+        return DELAY_TIMEOUT
+    return DELAY_ERROR
+
+
+def interpret_delay_result(result, error) -> tuple[str, int | None]:
+    """解释单节点测速结果：``(DELAY_OK|DELAY_TIMEOUT|DELAY_ERROR, 毫秒或 None)``。
+
+    内核把 504 当正常响应体返回（ClashAPI 不抛异常），因此必须读 ``status_code``。
+    """
+    kind = _delay_error_kind(error)
+    if kind is not None:
+        return kind, None
+    if not isinstance(result, dict):
+        return DELAY_ERROR, None
+    status_code = result.get("status_code")
+    if status_code == 504:
+        return DELAY_TIMEOUT, None
+    if status_code in (400, 404, 503):
+        return DELAY_ERROR, None
+    if status_code != 200:
+        return DELAY_ERROR, None
+    delay = result.get("delay")
+    if isinstance(delay, bool) or not isinstance(delay, int) or delay <= 0:
+        return DELAY_ERROR, None
+    return DELAY_OK, delay
+
+
+def interpret_group_delay_result(result, error) -> tuple[str, dict[str, int]]:
+    """解释整组测速结果：``(状态, {节点名: 毫秒})``；只有整数项被保留。"""
+    kind = _delay_error_kind(error)
+    if kind is not None:
+        return kind, {}
+    if not isinstance(result, dict):
+        return DELAY_ERROR, {}
+    status_code = result.get("status_code")
+    if status_code == 504:
+        return DELAY_TIMEOUT, {}
+    if status_code in (400, 404, 503):
+        return DELAY_ERROR, {}
+    if status_code != 200:
+        return DELAY_ERROR, {}
+    mapping: dict[str, int] = {}
+    for key, value in result.items():
+        if key == "status_code":
+            continue
+        if isinstance(value, bool) or not isinstance(value, int):
+            continue
+        mapping[str(key)] = value
+    return DELAY_OK, mapping
+
+
 def _brief(raw, limit: int = 120) -> str:
     """把任意响应体压成一行短文本，供提示栏/通知展示。"""
     if raw is None:

{clash_controller-0.2.5 → clash_controller-0.2.7}/clash_controller/app.tcss

@@ -112,6 +112,35 @@ Button:disabled {
     margin-left: 2;
 }
 
+/* 概览页连接筛选：Select 显式定宽（否则内部 1fr 标签会吃掉整行），Switch 压成单行 */
+#cn-node {
+    width: 20;
+}
+
+#cn-sort {
+    width: 14;
+}
+
+/* 节点页：策略组 / 排序下拉显式定宽（Select 内部 1fr 标签会吃掉整行） */
+#nd-group {
+    width: 24;
+}
+
+#nd-sort {
+    width: 12;
+}
+
+.filter-row Switch {
+    height: 1;
+    border: none;
+    padding: 0 1;
+    margin-left: 1;
+}
+
+.filter-row Switch:focus {
+    background-tint: $foreground 8%;
+}
+
 /* ---------- 表格 ---------- */
 .tbl {
     height: 1fr;

{clash_controller-0.2.5 → clash_controller-0.2.7}/clash_controller/config.py

@@ -31,9 +31,13 @@ def _load_json(path: Path, log: Callable[[str], None]) -> list:
     if not path.exists():
         return []
     try:
-        with open(path, encoding="utf-8") as f:
-            data = json.load(f)
-    except (json.JSONDecodeError, OSError) as e:
+        raw = path.read_bytes()
+        if raw.startswith((b"\xff\xfe", b"\xfe\xff")):
+            text = raw.decode("utf-16")
+        else:
+            text = raw.decode("utf-8-sig")
+        data = json.loads(text)
+    except (json.JSONDecodeError, UnicodeDecodeError, OSError) as e:
         log(f"无法读取或解析配置文件 {path}: {e}")
         return []
     return data if isinstance(data, list) else []
@@ -41,7 +45,7 @@ def _load_json(path: Path, log: Callable[[str], None]) -> list:
 
 def _save_json(path: Path, data: list) -> Path:
     path.parent.mkdir(parents=True, exist_ok=True)
-    with open(path, "w", encoding="utf-8") as f:
+    with open(path, "w", encoding="utf-8", newline="\n") as f:
         json.dump(data, f, indent=4, ensure_ascii=False)
     return path
 

{clash_controller-0.2.5 → clash_controller-0.2.7}/clash_controller/deploy.py

@@ -8,8 +8,11 @@ from urllib.parse import urlparse
 
 import requests
 
+from .platform_utils import default_local_config_dir, expand_local_path
 from .ssh import fetch_remote_file_meta_and_content
 
+CONFIG_ENCODINGS = ("utf-8-sig", "gb18030")
+
 
 def _noop(_message: str) -> None:
     pass
@@ -40,25 +43,59 @@ def default_ssh_host(url: str) -> str:
     return '127.0.0.1'
 
 
-def get_remote_last_modified(url: str) -> datetime | None:
-    """读取远端 URL 的 Last-Modified 头，失败或缺失返回 None。"""
+def decode_config_bytes(data: bytes) -> str:
+    """把订阅 / 本地配置字节解码为文本。
+
+    不能用 ``response.text``：requests 对没有 charset 的 ``text/*`` 会强制按
+    ISO-8859-1 解码，中文会变成乱码。这里显式按 UTF-8（去 BOM）→ GB18030
+    的顺序尝试，覆盖国内机场常见的两种编码；带 BOM 的 UTF-16（Windows 记事本
+    “Unicode”格式）也能识别。
+    """
+    if data.startswith((b"\xff\xfe", b"\xfe\xff")):
+        # Windows 记事本“Unicode”保存的是带 BOM 的 UTF-16。
+        try:
+            return data.decode("utf-16")
+        except UnicodeDecodeError:
+            pass
+    for encoding in CONFIG_ENCODINGS:
+        try:
+            return data.decode(encoding)
+        except UnicodeDecodeError:
+            continue
+    raise RuntimeError("配置内容不是有效的 UTF-8 / GB18030 文本，无法部署")
+
+
+def normalize_config_text(text: str) -> str:
+    """统一为 LF 换行，避免 Windows 文本模式写出的 CRLF 造成哈希反复不一致。"""
+    return text.replace("\r\n", "\n").replace("\r", "\n")
+
+
+def canonical_config_bytes(data: bytes) -> bytes:
+    """把配置规范化为 UTF-8（无 BOM、LF 换行）字节，用于落盘与哈希比对。"""
+    return normalize_config_text(decode_config_bytes(data)).encode("utf-8")
+
+
+def parse_last_modified(value: str | None) -> datetime | None:
+    if not value:
+        return None
     try:
-        response = requests.head(url, timeout=5)
-        response.raise_for_status()
-        last_modified = response.headers.get('Last-Modified')
-        if last_modified:
-            return parsedate_to_datetime(last_modified)
-    except requests.exceptions.RequestException:
+        return parsedate_to_datetime(value)
+    except (TypeError, ValueError, OverflowError):
         return None
-    return None
 
 
 def fetch_remote_config(url: str) -> tuple[str, str, datetime | None]:
-    """拉取远端配置，返回 (text, sha256, last_modified)。失败抛异常。"""
+    """拉取远端配置，返回 (规范化文本, sha256, last_modified)。失败抛异常。
+
+    直接读取 ``response.content`` 并显式解码，最后统一换行；哈希基于规范化后的
+    UTF-8 字节，保证与本地落盘内容可比。Last-Modified 取自本次 GET 响应，避免
+    额外 HEAD 请求（部分订阅服务器不支持 HEAD）。
+    """
     response = requests.get(url, timeout=30)
     response.raise_for_status()
-    text = response.text
-    return text, compute_sha256(text.encode('utf-8')), get_remote_last_modified(url)
+    payload = canonical_config_bytes(response.content)
+    text = payload.decode('utf-8')
+    return text, compute_sha256(payload), parse_last_modified(response.headers.get('Last-Modified'))
 
 
 def read_current_config(
@@ -70,7 +107,7 @@ def read_current_config(
     if profile.get('endpoint_type', 'local') == 'remote':
         return fetch_remote_file_meta_and_content(profile, log=log, debug=debug)
 
-    config_dir = profile.get('config_directory', '/etc/clash')
+    config_dir = expand_local_path(profile.get('config_directory') or default_local_config_dir())
     config_path = os.path.join(config_dir, 'config.yaml')
     if not os.path.exists(config_path):
         raise RuntimeError(f"local config file not found: {config_path}")

clash_controller-0.2.7/clash_controller/elevated_helper.py

@@ -0,0 +1,36 @@
+"""Windows 提权写入 helper：由 ``platform_utils`` 通过 UAC 以管理员令牌再启动本包执行。
+
+职责刻意收窄成「读 payload → 原子写目标 → 回写状态」三件事：不读应用配置、不联网、不碰 UI，
+所以被提权的进程能做的事非常有限，出错也只可能来自这几个路径。
+"""
+import argparse
+import sys
+
+from .platform_utils import HELPER_FLAG, elevated_apply_payload, write_status
+
+EXIT_OK = 0
+EXIT_FAILED = 1
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog=f"clashctl {HELPER_FLAG}",
+        description="以管理员权限写入 Clash 配置文件（由 clashctl 内部调用，无需手动执行）",
+    )
+    parser.add_argument("payload", help="待写入内容所在的临时文件")
+    parser.add_argument("target", help="目标 config.yaml 的绝对路径")
+    parser.add_argument("backup", help="备份文件路径")
+    parser.add_argument("status", help="回写结果的状态文件路径")
+    args = parser.parse_args(argv)
+
+    try:
+        elevated_apply_payload(args.payload, args.target, args.backup)
+    except BaseException as exc:  # noqa: BLE001  # 提权进程必须把任何失败原因带回主进程
+        write_status(args.status, f"ERR {type(exc).__name__}: {exc}")
+        return EXIT_FAILED
+    write_status(args.status, "OK")
+    return EXIT_OK
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{clash_controller-0.2.5 → clash_controller-0.2.7}/clash_controller/main.py

@@ -7,6 +7,7 @@ from pathlib import Path
 
 from . import __version__
 from .config import CONFIG_DIR_ENV, DEFAULT_CONFIG_DIR
+from .platform_utils import HELPER_FLAG
 
 
 def _setup_logging() -> None:
@@ -37,6 +38,14 @@ def parse_args():
 
 
 def main() -> int:
+    # 提权 helper：打包成 exe 后 sys.executable 就是本程序，UAC 提权重启时由这里分派；
+    # pip 安装则直接走 `python -m clash_controller.elevated_helper`，不经过本函数。
+    argv = sys.argv[1:]
+    if argv[:1] == [HELPER_FLAG]:
+        from .elevated_helper import main as elevated_main
+
+        return elevated_main(argv[1:])
+
     _setup_logging()
     args = parse_args()
     os.environ[CONFIG_DIR_ENV] = args.dir