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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clash_controller
-Version: 0.2.5
+Version: 0.2.6
 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` | 刷新 |

{clash_controller-0.2.5 → clash_controller-0.2.6}/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` | 刷新 |

{clash_controller-0.2.5 → clash_controller-0.2.6}/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.6"

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

@@ -54,7 +54,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 +65,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 +84,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:
@@ -116,6 +121,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.
@@ -267,16 +277,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 +302,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.
+
+        内核没有 ``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):
-        """Test the delay of all proxies in a group."""
+    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 +335,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 +368,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 +526,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.6}/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.6/clash_controller/proxies.py

@@ -0,0 +1,238 @@
+"""策略组 / 节点数据归一化（零 Textual 依赖）。
+
+Clash 的 ``GET /proxies`` 把节点与策略组放在同一个顶层字典里：组带 ``all`` 数组，
+节点没有；provider 节点只出现在 ``GET /providers/proxies`` 中（``config.go`` 不把
+它们注册进顶层字典）。本模块把两份原始响应合并成可展示的 :class:`ProxiesSnapshot`，
+并负责把 ``history`` / ``extra`` 里的延迟记录解释成「毫秒 / 失败 / 未测」。
+
+约定：``delay is None`` = 未测；``delay == 0`` = 测试失败（不是 0ms）。
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+DEFAULT_TEST_URL = "https://www.gstatic.com/generate_204"
+DEFAULT_TEST_TIMEOUT = 5000
+
+GROUP_TYPE_LABELS = {
+    "selector": "手动",
+    "urltest": "自动",
+    "fallback": "故障转移",
+    "loadbalance": "负载均衡",
+}
+
+
+@dataclass
+class ProxyNode:
+    name: str
+    type: str
+    udp: bool = False
+    provider: str = ""  # 空 = 配置内节点；否则 provider 名
+    is_group: bool = False  # 该成员是嵌套策略组
+    delay: int | None = None  # None=未测；0=失败；>0=毫秒
+
+
+@dataclass
+class ProxyGroup:
+    name: str
+    type: str  # 原始类型字符串，如 "Selector"
+    kind: str  # 小写归一化：selector/urltest/fallback/loadbalance/other
+    now: str = ""
+    all: list[str] = field(default_factory=list)
+    fixed: str = ""
+    hidden: bool = False
+    test_url: str = ""
+
+
+@dataclass
+class ProxiesSnapshot:
+    nodes: dict[str, ProxyNode]
+    groups: dict[str, ProxyGroup]
+    order: list[str]  # 组装后的组顺序（GLOBAL 最后）
+
+    def group_list(self, include_hidden: bool = False) -> list[ProxyGroup]:
+        out: list[ProxyGroup] = []
+        for name in self.order:
+            group = self.groups.get(name)
+            if group is None:
+                continue
+            if group.hidden and not include_hidden:
+                continue
+            out.append(group)
+        return out
+
+    def member(self, group: ProxyGroup, name: str) -> ProxyNode:
+        node = self.nodes.get(name)
+        if node is not None:
+            return node
+        nested = self.groups.get(name)
+        if nested is not None:
+            return ProxyNode(
+                name=name,
+                type=nested.type,
+                provider="",
+                is_group=True,
+                delay=self.resolve_delay(nested.now),
+            )
+        return ProxyNode(name=name, type="")
+
+    def resolve_delay(self, name: str, _seen: set[str] | None = None) -> int | None:
+        """沿组的 ``now`` 递归到叶子节点；遇到环或找不到返回 None。"""
+        if not name:
+            return None
+        seen = _seen if _seen is not None else set()
+        if name in seen:
+            return None
+        seen.add(name)
+        node = self.nodes.get(name)
+        if node is not None:
+            return node.delay
+        group = self.groups.get(name)
+        if group is None:
+            return None
+        return self.resolve_delay(group.now, seen)
+
+
+def group_test_url(group: ProxyGroup) -> str:
+    return group.test_url or DEFAULT_TEST_URL
+
+
+def _as_int(value) -> int | None:
+    if isinstance(value, bool) or value is None:
+        return None
+    if isinstance(value, int):
+        return value
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _history_delay(entries) -> int | None:
+    if not isinstance(entries, list) or not entries:
+        return None
+    last = entries[-1]
+    if not isinstance(last, dict):
+        return None
+    return _as_int(last.get("delay"))
+
+
+def _node_delay(raw: dict) -> int | None:
+    """优先取 ``history[-1].delay``；否则取 ``extra`` 里时间最晚的一条记录。"""
+    delay = _history_delay(raw.get("history"))
+    if delay is not None:
+        return delay
+    extra = raw.get("extra")
+    if not isinstance(extra, dict):
+        return None
+    best_time: str | None = None
+    best: int | None = None
+    for entry in extra.values():
+        if not isinstance(entry, dict):
+            continue
+        history = entry.get("history")
+        if not isinstance(history, list) or not history:
+            continue
+        last = history[-1]
+        if not isinstance(last, dict):
+            continue
+        stamp = str(last.get("time") or "")
+        value = _as_int(last.get("delay"))
+        if value is None:
+            continue
+        if best_time is None or stamp > best_time:
+            best_time = stamp
+            best = value
+    return best
+
+
+def _build_node(name: str, raw: dict, provider: str = "") -> ProxyNode:
+    return ProxyNode(
+        name=name,
+        type=str(raw.get("type") or ""),
+        udp=bool(raw.get("udp", False)),
+        provider=provider,
+        is_group=False,
+        delay=_node_delay(raw),
+    )
+
+
+def _build_group(name: str, raw: dict) -> ProxyGroup:
+    raw_type = str(raw.get("type") or "")
+    kind = raw_type.lower()
+    if kind not in GROUP_TYPE_LABELS:
+        kind = "other"
+    members = [str(item) for item in raw.get("all") or [] if isinstance(item, (str, int))]
+    return ProxyGroup(
+        name=name,
+        type=raw_type,
+        kind=kind,
+        now=str(raw.get("now") or ""),
+        all=members,
+        fixed=str(raw.get("fixed") or ""),
+        hidden=bool(raw.get("hidden", False)),
+        test_url=str(raw.get("testUrl") or ""),
+    )
+
+
+def build_snapshot(proxies_result, providers_result=None) -> ProxiesSnapshot:
+    """合并 ``/proxies`` 与 ``/providers/proxies`` 的返回体；非法入参按空处理。"""
+    nodes: dict[str, ProxyNode] = {}
+    groups: dict[str, ProxyGroup] = {}
+
+    data = proxies_result if isinstance(proxies_result, dict) else {}
+    raw_proxies = data.get("proxies")
+    if isinstance(raw_proxies, dict):
+        for key, raw in raw_proxies.items():
+            if not isinstance(raw, dict):
+                continue
+            name = str(raw.get("name") or key)
+            if isinstance(raw.get("all"), list):
+                groups[name] = _build_group(name, raw)
+            else:
+                nodes[name] = _build_node(name, raw)
+
+    providers = providers_result.get("providers") if isinstance(providers_result, dict) else None
+    if isinstance(providers, dict):
+        for key, entry in providers.items():
+            if not isinstance(entry, dict):
+                continue
+            pname = str(entry.get("name") or key)
+            # 每个内联组都会生成同名 Compatible provider，default 是内置项，均需过滤
+            if pname.lower() == "default":
+                continue
+            if str(entry.get("vehicleType") or "").lower() == "compatible":
+                continue
+            plist = entry.get("proxies")
+            if not isinstance(plist, list):
+                continue
+            for raw in plist:
+                if not isinstance(raw, dict):
+                    continue
+                node_name = str(raw.get("name") or "")
+                if not node_name:
+                    continue
+                existing = nodes.get(node_name)
+                if existing is not None:
+                    if not existing.provider:
+                        existing.provider = pname
+                    continue
+                nodes[node_name] = _build_node(node_name, raw, provider=pname)
+
+    return ProxiesSnapshot(nodes=nodes, groups=groups, order=_group_order(groups))
+
+
+def _group_order(groups: dict[str, ProxyGroup]) -> list[str]:
+    """GLOBAL.all 决定组顺序；不在其中的组按名称排在前面；GLOBAL 永远最后。"""
+    global_group = groups.get("GLOBAL")
+    if global_group is None:
+        return sorted(groups, key=str.casefold)
+    listed: list[str] = []
+    for name in global_group.all:
+        if name != "GLOBAL" and name in groups and name not in listed:
+            listed.append(name)
+    rest = sorted(
+        (name for name in groups if name != "GLOBAL" and name not in listed),
+        key=str.casefold,
+    )
+    return [*rest, *listed, "GLOBAL"]

{clash_controller-0.2.5 → clash_controller-0.2.6}/clash_controller/screens/home.py

@@ -12,7 +12,7 @@ from ..widgets import HintBar, MenuMarquee
 
 
 class HomeScreen(Screen):
-    """功能主菜单：概览 / 配置管理 / 设置 / 切换端点。"""
+    """功能主菜单：概览 / 节点 / 配置管理 / 设置 / 切换端点。"""
 
     def __init__(self) -> None:
         super().__init__(classes="logo-page")
@@ -20,13 +20,15 @@ class HomeScreen(Screen):
     BINDINGS = [
         Binding("escape,ctrl+c", "menu('quit')", "退出"),
         Binding("1", "menu('overview')", "概览", show=False),
-        Binding("2", "menu('configuration')", "配置", show=False),
-        Binding("3", "menu('settings')", "设置", show=False),
-        Binding("4", "menu('switch')", "端点", show=False),
+        Binding("2", "menu('nodes')", "节点", show=False),
+        Binding("3", "menu('configuration')", "配置", show=False),
+        Binding("4", "menu('settings')", "设置", show=False),
+        Binding("5", "menu('switch')", "端点", show=False),
     ]
 
     ITEMS = [
         ("overview", "概览", "流量 / 内存 / 活动连接实时监控"),
+        ("nodes", "节点", "策略组成员 / 延迟测速 / 手动指定"),
         ("configuration", "配置管理", "配置提供方与拉取部署"),
         ("settings", "设置", "TUN / 模式 / 重载 / 升级 / 日志"),
         ("switch", "切换端点", "返回端点选择"),
@@ -40,7 +42,7 @@ class HomeScreen(Screen):
                 name = (self.app.profile or {}).get("name", "")
                 yield Static(f"v{__version__}" + (f" · {name}" if name else ""), id="home-version")
                 yield OptionList(id="home-list")
-        yield HintBar("↑↓ 选择 · 回车 进入 · 1-4 直达 · Esc/Ctrl+C 退出", classes="page-hint")
+        yield HintBar("↑↓ 选择 · 回车 进入 · 1-5 直达 · Esc/Ctrl+C 退出", classes="page-hint")
 
     def on_mount(self) -> None:
         ol = self.query_one("#home-list", OptionList)
@@ -66,11 +68,14 @@ class HomeScreen(Screen):
 
     def _open(self, key: str) -> None:
         from .config import ConfigScreen
+        from .nodes import NodeScreen
         from .overview import OverviewScreen
         from .settings import SettingsScreen
 
         if key == "overview":
             self.app.push_screen(OverviewScreen())
+        elif key == "nodes":
+            self.app.push_screen(NodeScreen())
         elif key == "configuration":
             self.app.push_screen(ConfigScreen())
         elif key == "settings":